tinyflux 1.2.1__tar.gz → 1.3.0__tar.gz

{tinyflux-1.2.1/tinyflux.egg-info → tinyflux-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tinyflux
-Version: 1.2.1
+Version: 1.3.0
 Summary: The Tiny Time-Series Database Optimized for Your Happiness
 Home-page: https://github.com/citrusvanilla/tinyflux
 Author: Justin Fung

{tinyflux-1.2.1 → tinyflux-1.3.0}/tests/test_measurement.py

@@ -918,9 +918,9 @@ def test_update():
         m1.update(TagQuery().noop(), tags={"a": 1})
 
     with pytest.raises(
-        ValueError, match="Field set must contain only numeric values."
+        ValueError, match="Field set must contain only numeric, string, or bool"
     ):
-        m1.update(TagQuery().noop(), fields={"a": "a"})
+        m1.update(TagQuery().noop(), fields={"a": ["a"]})
 
     # Valid index, no index results.
     db.reindex()

{tinyflux-1.2.1 → tinyflux-1.3.0}/tests/test_point.py

@@ -2,7 +2,12 @@
 
 from datetime import datetime, timezone, timedelta
 import pytest
-from tinyflux.point import Point, validate_tags, validate_fields
+from tinyflux.point import (
+    Point,
+    _serialize_field_value,
+    validate_tags,
+    validate_fields,
+)
 
 
 @pytest.fixture
@@ -100,8 +105,13 @@ def test_args_and_kwargs_invalid(args, kwargs, exception_type):
         ),
         (
             validate_fields,
-            [3, {1: "A"}, {"a": "A"}],
-            [{"a": 1}, {"temp": 70.5}, {"count": 10, "avg": 25.3}],
+            [3, {1: "A"}, {"a": ["A"]}, {"a": b"A"}],
+            [
+                {"a": 1},
+                {"temp": 70.5},
+                {"count": 10, "avg": 25.3},
+                {"s": "A", "b": True, "n": None},
+            ],
         ),
     ],
 )
@@ -199,8 +209,8 @@ def invalid_field_values(test_times):
         {test_time: "all good"},
         {tuple((1, 2)): "ok"},
         {"key": {"a": "b"}},
-        {"a": True},  # Invalid for fields (should be numeric/None)
-        # Note: {"a": 123} is valid for fields, so not included
+        {"a": ["b"]},
+        # Note: {"a": 123}, {"a": "b"}, and {"a": True} are valid for fields.
     ]
 
 
@@ -533,3 +543,100 @@ def test_compact_keys(point_data, prefix_attr, key_indices, expected_values):
     # Check that values match expected
     for key, expected_value in expected_values.items():
         assert getattr(new_p_compact, data_attr)[key] == expected_value
+
+
+@pytest.mark.parametrize(
+    "value,serialized",
+    [
+        (True, "true"),
+        (False, "false"),
+        ("abc", '"abc"'),
+        ("", '""'),
+        ("true", '"true"'),
+        ("1.5", '"1.5"'),
+        ("_none", '"_none"'),
+        ("a,b", '"a,b"'),
+        ('say "hi"', '"say \\"hi\\""'),
+        ("back\\slash", '"back\\\\slash"'),
+        ("line1\nline2\r\n", '"line1\\nline2\\r\\n"'),
+        ("\\n", '"\\\\n"'),
+        ("\u00e9\u4e2d", '"\u00e9\u4e2d"'),
+        (1, "1.0"),
+        (-2.5, "-2.5"),
+        (None, "_none"),
+    ],
+)
+def test_serialize_string_and_bool_fields(value, serialized):
+    """Test the serialized form of, and round trip for, each field type."""
+    p = Point(
+        time=datetime(2022, 1, 1, tzinfo=timezone.utc), fields={"k": value}
+    )
+    row = p._serialize_to_list()
+
+    assert row[-2:] == ("_field_k", serialized)
+    assert not any("\n" in i or "\r" in i for i in row)
+
+    result = Point()._deserialize_from_list(row)
+
+    # Numbers always come back as floats, everything else as it went in.
+    expected = float(value) if type(value) is int else value
+    assert result.fields == {"k": expected}
+    assert type(result.fields["k"]) is type(expected)
+
+
+def test_serialize_numeric_field_subclasses():
+    """Test numeric subclasses keep the same serialized form as numbers."""
+
+    class MyInt(int):
+        pass
+
+    class MyFloat(float):
+        pass
+
+    p = Point(
+        time=datetime(2022, 1, 1, tzinfo=timezone.utc),
+        fields={"i": MyInt(1), "f": MyFloat(2.5)},
+    )
+    row = p._serialize_to_list()
+
+    assert row[-4:] == ("_field_i", "1.0", "_field_f", "2.5")
+
+
+def test_serialize_unsupported_field_value():
+    """Test the serializer rejects unsupported values defensively."""
+    with pytest.raises(TypeError, match="Unsupported field value type: list"):
+        _serialize_field_value([], "_none")
+
+
+def test_deserialize_legacy_and_unknown_field_values():
+    """Test that values written by earlier releases read back unchanged."""
+    row = [
+        "2022-01-01T00:00:00",
+        "m",
+        "_tag_t",
+        "true",
+        "_field_a",
+        "1.0",
+        "_field_b",
+        "-3",
+        "_field_c",
+        "2.5e-05",
+        "_field_d",
+        "_none",
+        "_field_e",
+        "nan",
+        "_field_f",
+        "garbage",
+        "_field_g",
+        '"unterminated',
+    ]
+    p = Point()._deserialize_from_list(row)
+
+    assert p.tags == {"t": "true"}
+    assert p.fields["a"] == 1.0 and isinstance(p.fields["a"], float)
+    assert p.fields["b"] == -3 and isinstance(p.fields["b"], int)
+    assert p.fields["c"] == 2.5e-05
+    assert p.fields["d"] is None
+    assert p.fields["e"] != p.fields["e"]
+    assert p.fields["f"] is None
+    assert p.fields["g"] is None

{tinyflux-1.2.1 → tinyflux-1.3.0}/tests/test_queries.py

@@ -625,6 +625,27 @@ def test_hash():
     assert not (~(q1 & q5)).is_hashable()
 
 
+def test_bool_numeric_field_query_hash_identity():
+    """Test bool field queries are distinct from numeric field queries."""
+    q_true = FieldQuery().a == True  # noqa: E712
+    q_one = FieldQuery().a == 1
+    q_one_float = FieldQuery().a == 1.0
+    q_false = FieldQuery().a == False  # noqa: E712
+    q_zero = FieldQuery().a == 0
+    q_zero_float = FieldQuery().a == 0.0
+
+    assert q_true != q_one
+    assert q_false != q_zero
+    assert q_one == q_one_float
+    assert q_zero == q_zero_float
+
+    assert q_true._hash[-1] != True  # noqa: E712
+    assert len({q_true, q_one, q_one_float, q_false, q_zero, q_zero_float}) == 4
+
+    assert (q_true & q_one) != (q_one & q_one)
+    assert (q_false | q_zero) != (q_zero | q_zero)
+
+
 def test_empty_query_evaluation():
     """Test calling an empty query raises Exception."""
     with pytest.raises(TypeError):
@@ -870,6 +891,61 @@ def test_bad_queries():
     with pytest.raises(TypeError):
         TagQuery().city == ["a", "b"]
 
-    # Test a non-numeric right hand side.
+    # Test a right hand side that is not numeric, string, or bool.
     with pytest.raises(TypeError):
-        FieldQuery().a == "a"
+        FieldQuery().a == ["a"]
+
+
+def test_string_and_bool_field_queries():
+    """Test queries against string and bool field values."""
+    s = Point(fields={"a": "abc"})
+    t = Point(fields={"a": True})
+    f = Point(fields={"a": False})
+    n = Point(fields={"a": 1})
+    z = Point(fields={"a": 0.0})
+    none = Point(fields={"a": None})
+    missing = Point(fields={"b": "abc"})
+    points = [s, t, f, n, z, none, missing]
+
+    yes, no = True, False
+
+    def matches(q):
+        return [p for p in points if q(p)]
+
+    # Equality is typed.
+    assert matches(FieldQuery().a == "abc") == [s]
+    assert matches(FieldQuery().a == "ABC") == []
+    assert matches(FieldQuery().a == "") == []
+    assert matches(FieldQuery().a == yes) == [t]
+    assert matches(FieldQuery().a == no) == [f]
+    assert matches(FieldQuery().a == 1) == [n]
+    assert matches(FieldQuery().a == 0) == [z]
+    assert matches(FieldQuery().a == "1") == []
+
+    # Inequality is typed too: a missing field is never a match.
+    assert matches(FieldQuery().a != "abc") == [t, f, n, z, none]
+    assert matches(FieldQuery().a != yes) == [s, f, n, z, none]
+    assert matches(FieldQuery().a != 1) == [s, t, f, z, none]
+
+    # Numeric comparisons skip strings and bools instead of raising.
+    assert matches(FieldQuery().a > 0) == [n]
+    assert matches(FieldQuery().a >= 0) == [n, z]
+    assert matches(FieldQuery().a < 1) == [z]
+    assert matches(FieldQuery().a <= 1) == [n, z]
+
+    # String comparisons are lexicographic and skip numbers and bools.
+    assert matches(FieldQuery().a > "abb") == [s]
+    assert matches(FieldQuery().a < "abd") == [s]
+    assert matches(FieldQuery().a >= "abc") == [s]
+    assert matches(FieldQuery().a <= "abc") == [s]
+
+    # Bools only order against bools.
+    assert matches(FieldQuery().a > no) == [t]
+    assert matches(FieldQuery().a <= yes) == [t, f]
+
+    # Compound queries work as for any other field value.
+    assert matches((FieldQuery().a == "abc") | (FieldQuery().a == yes)) == [
+        s,
+        t,
+    ]
+    assert matches(~(FieldQuery().a == "abc")) == [t, f, n, z, none, missing]

{tinyflux-1.2.1 → tinyflux-1.3.0}/tests/test_storages.py

@@ -667,3 +667,116 @@ def test_compact_key_prefixes(tmpdir):
     assert m._serialize_point(
         p, compact_key_prefixes=False
     ) == p._serialize_to_list(compact_key_prefixes=False)
+
+
+STRING_AND_BOOL_FIELDS = {
+    "s": "plain",
+    "empty": "",
+    "t": True,
+    "f": False,
+    "str_true": "true",
+    "str_num": "1.5",
+    "str_none": "_none",
+    "comma": "a,b",
+    "quote": 'she said "hi", then left',
+    "backslash": "C:\\temp\\new",
+    "newline": "line1\nline2\r\nline3\r",
+    "unicode": "caf\u00e9 \u4e2d\u6587",
+    "n": 1.5,
+    "i": 3,
+    "none": None,
+}
+
+
+@pytest.mark.parametrize("compact_key_prefixes", [False, True])
+def test_string_and_bool_fields_round_trip(tmpdir, compact_key_prefixes):
+    """Test writing, closing, reopening, and reading string/bool fields."""
+    path = os.path.join(tmpdir, "test.csv")
+    t = datetime(2022, 1, 1, tzinfo=timezone.utc)
+    points = [
+        Point(time=t, measurement="m", fields=STRING_AND_BOOL_FIELDS),
+        Point(
+            time=t + timedelta(seconds=1),
+            measurement="m",
+            tags={"tag": "true"},
+            fields={"s": "second", "t": False},
+        ),
+    ]
+
+    db = TinyFlux(path, encoding="utf-8")
+    db.insert_multiple(points, compact_key_prefixes=compact_key_prefixes)
+    db.close()
+
+    # Each point is still exactly one line in the file.
+    with open(path, encoding="utf-8", newline="") as f:
+        assert len(f.read().split("\n")) == len(points) + 1
+
+    db = TinyFlux(path, encoding="utf-8")
+    assert len(db) == 2
+    result = db.all()
+    assert result == points
+
+    # Types survive, in particular bool vs. int vs. str.
+    first = result[0].fields
+    for key, value in STRING_AND_BOOL_FIELDS.items():
+        assert first[key] == value
+        assert type(first[key]) is (float if key == "i" else type(value))
+
+    # The index built on reopen sees the typed values.
+    assert db.get_field_values("s") == ["plain", "second"]
+    assert db.get_field_values("t") == [True, False]
+    db.close()
+
+
+def test_string_and_bool_fields_memory_storage():
+    """Test string and bool fields in memory storage."""
+    db = TinyFlux(storage=MemoryStorage)
+    p = Point(fields=STRING_AND_BOOL_FIELDS)
+    db.insert(p)
+
+    assert db.all() == [p]
+    assert db.get_field_values("quote") == [STRING_AND_BOOL_FIELDS["quote"]]
+
+
+def test_numeric_only_files_from_earlier_releases_read_identically(tmpdir):
+    """Test that a file written before string/bool support reads unchanged."""
+    path = os.path.join(tmpdir, "legacy.csv")
+
+    with open(path, "w", newline="") as f:
+        f.write(
+            "2022-01-01T00:00:00,m,_tag_a,b,_field_x,1.0,_field_y,-2.5,"
+            "_field_z,_none\r\n"
+            "2022-01-01T00:00:01,m,t_a,c,f_x,3.0,f_y,1e-07\r\n"
+        )
+
+    db = TinyFlux(path)
+    assert db.all() == [
+        Point(
+            time=datetime(2022, 1, 1, tzinfo=timezone.utc),
+            measurement="m",
+            tags={"a": "b"},
+            fields={"x": 1.0, "y": -2.5, "z": None},
+        ),
+        Point(
+            time=datetime(2022, 1, 1, 0, 0, 1, tzinfo=timezone.utc),
+            measurement="m",
+            tags={"a": "c"},
+            fields={"x": 3.0, "y": 1e-07},
+        ),
+    ]
+
+    # New string/bool points can be appended to an old file.
+    db.insert(
+        Point(
+            time=datetime(2022, 1, 1, 0, 0, 2, tzinfo=timezone.utc),
+            measurement="m",
+            fields={"x": "on", "y": True},
+        )
+    )
+    db.close()
+
+    db = TinyFlux(path)
+    assert len(db) == 3
+    assert db.all()[0].fields == {"x": 1.0, "y": -2.5, "z": None}
+    assert db.all()[2].fields == {"x": "on", "y": True}
+    db.close()

{tinyflux-1.2.1 → tinyflux-1.3.0}/tests/test_tinyflux.py

@@ -857,6 +857,95 @@ def test_search_field_map_index_storage_parity():
     assert db_index.search(query) == [point]
 
 
+def test_negated_field_query_index_storage_read_parity():
+    """Test negated FieldQuery reads match with and without the index."""
+    t = datetime(2022, 1, 1, tzinfo=timezone.utc)
+    points = [
+        Point(time=t, measurement="m", fields={"a": 1}),
+        Point(time=t + timedelta(seconds=1), measurement="m", fields={"a": 2}),
+        Point(time=t + timedelta(seconds=2), measurement="m", fields={"b": 3}),
+        Point(time=t + timedelta(seconds=3), measurement="n", fields={"a": 1}),
+        Point(time=t + timedelta(seconds=4), measurement="n", fields={"b": 4}),
+        Point(
+            time=t + timedelta(seconds=5),
+            measurement="full",
+            fields={"a": 9},
+        ),
+    ]
+
+    db_storage = TinyFlux(storage=MemoryStorage, auto_index=False)
+    db_storage.insert_multiple(points)
+
+    db_index = TinyFlux(storage=MemoryStorage, auto_index=True)
+    db_index.insert_multiple(points)
+
+    queries = [
+        ~FieldQuery().a.exists(),
+        ~(FieldQuery().a == 1),
+        (MeasurementQuery() == "m") & ~(FieldQuery().a == 1),
+    ]
+
+    for query in queries:
+        for measurement in (None, "m", "full"):
+            assert db_index.search(query, measurement=measurement) == (
+                db_storage.search(query, measurement=measurement)
+            )
+            assert db_index.count(query, measurement=measurement) == (
+                db_storage.count(query, measurement=measurement)
+            )
+            assert db_index.contains(query, measurement=measurement) == (
+                db_storage.contains(query, measurement=measurement)
+            )
+            assert db_index.get(query, measurement=measurement) == (
+                db_storage.get(query, measurement=measurement)
+            )
+            assert db_index.select(
+                "fields.a", query, measurement=measurement
+            ) == (db_storage.select("fields.a", query, measurement=measurement))
+
+
+def test_negated_field_query_index_storage_write_parity():
+    """Test negated FieldQuery writes match with and without the index."""
+    t = datetime(2022, 1, 1, tzinfo=timezone.utc)
+    query = (MeasurementQuery() == "m") & ~FieldQuery().a.exists()
+
+    def make_points():
+        return [
+            Point(time=t, measurement="m", fields={"a": 1}),
+            Point(
+                time=t + timedelta(seconds=1),
+                measurement="m",
+                fields={"a": 2},
+            ),
+            Point(
+                time=t + timedelta(seconds=2),
+                measurement="m",
+                fields={"b": 3},
+            ),
+            Point(
+                time=t + timedelta(seconds=3),
+                measurement="n",
+                fields={"b": 4},
+            ),
+        ]
+
+    db_storage = TinyFlux(storage=MemoryStorage, auto_index=False)
+    db_storage.insert_multiple(make_points())
+
+    db_index = TinyFlux(storage=MemoryStorage, auto_index=True)
+    db_index.insert_multiple(make_points())
+
+    assert db_index.update(query, fields={"updated": True}) == 1
+    assert db_storage.update(query, fields={"updated": True}) == 1
+    assert db_index.all() == db_storage.all()
+
+    assert db_index.remove(query) == 1
+    assert db_storage.remove(query) == 1
+    assert db_index.remove(FieldQuery().updated == True) == 0  # noqa: E712
+    assert db_storage.remove(FieldQuery().updated == True) == 0  # noqa: E712
+    assert db_index.all() == db_storage.all()
+
+
 def test_select():
     """Test select method."""
     db = TinyFlux(storage=MemoryStorage, auto_index=False)
@@ -960,9 +1049,9 @@ def test_update():
         db.update(TagQuery().noop(), tags={"a": 1})
 
     with pytest.raises(
-        ValueError, match="Field set must contain only numeric values."
+        ValueError, match="Field set must contain only numeric, string, or bool"
     ):
-        db.update(TagQuery().noop(), fields={"a": "a"})
+        db.update(TagQuery().noop(), fields={"a": ["a"]})
 
     # Missing updates.
     with pytest.raises(ValueError):
@@ -1639,3 +1728,71 @@ def test_all_get_methods_parity_storage_vs_index():
     assert sorted(
         db_test.get_tag_values(["device"], "measurement2")["device"]
     ) == ["C", "D"]
+
+
+def test_string_and_bool_fields_mixed_types(tmpdir):
+    """Test search and update with mixed field types under one field key."""
+    path = os.path.join(tmpdir, "test.csv")
+    t = datetime(2022, 1, 1, tzinfo=timezone.utc)
+    values = ["on", True, 1, 2.5, "true", False, None, "1"]
+    points = [
+        Point(time=t + timedelta(seconds=i), fields={"state": v})
+        for i, v in enumerate(values)
+    ]
+
+    db = TinyFlux(path)
+    db.insert_multiple(points)
+
+    def check(db):
+        q = FieldQuery().state
+        assert db.search(q == "on") == [points[0]]
+        assert db.search(q == "true") == [points[4]]
+        assert db.search(q == True) == [points[1]]  # noqa: E712
+        assert db.search(q == False) == [points[5]]  # noqa: E712
+        assert db.search(q == 1) == [points[2]]
+        assert db.search(q == "1") == [points[7]]
+        assert db.search(q >= 1) == [points[2], points[3]]
+        assert db.search(q > "a") == [points[0], points[4]]
+        assert db.search(q != "on") == [
+            points[i] for i in (1, 2, 3, 4, 5, 6, 7)
+        ]
+        assert db.count(q == "on") == 1
+        assert db.get_field_values("state") == values
+
+    # Index is valid.
+    check(db)
+
+    # No index.
+    db._index.invalidate()
+    check(db)
+
+    # Reopened from disk.
+    db.close()
+    db = TinyFlux(path)
+    check(db)
+    db.reindex()
+    check(db)
+
+    # Update from one type to another.
+    assert db.update(FieldQuery().state == "on", fields={"state": False}) == 1
+    assert db.search(FieldQuery().state == "on") == []
+    assert db.get_field_values("state")[0] is False
+    db.close()
+
+    db = TinyFlux(path)
+    assert db.get_field_values("state")[0] is False
+    db.close()
+
+
+def test_string_and_bool_fields_in_measurement_and_select():
+    """Test string/bool fields through the Measurement and select APIs."""
+    db = TinyFlux(storage=MemoryStorage)
+    m = db.measurement("m")
+    m.insert(Point(fields={"s": "x", "b": True}))
+    m.insert(Point(fields={"s": "y", "b": False}))
+
+    assert m.get_field_values("s") == ["x", "y"]
+    assert m.get_field_values("b") == [True, False]
+    assert m.count(FieldQuery().b == True) == 1  # noqa: E712
+    assert m.select("fields.s", FieldQuery().s == "y") == ["y"]
+    assert db.select("fields.b", FieldQuery().s >= "x") == [True, False]

{tinyflux-1.2.1 → tinyflux-1.3.0}/tinyflux/database.py

@@ -2,6 +2,7 @@
 
 import copy
 from datetime import datetime, timezone
+import operator
 from typing import (
     Any,
     Callable,
@@ -36,6 +37,24 @@ from .queries import (
 from .storages import CSVStorage, Storage
 
 
+def _query_contains_negated_field_query(query: Query) -> bool:
+    """Return whether a query needs storage evaluation for field negation."""
+    if not isinstance(query, CompoundQuery):
+        return False
+
+    if (
+        query.operator == operator.not_
+        and isinstance(query.query1, SimpleQuery)
+        and query.query1.point_attr == "_fields"
+    ):
+        return True
+
+    return _query_contains_negated_field_query(query.query1) or (
+        query.query2 is not None
+        and _query_contains_negated_field_query(query.query2)
+    )
+
+
 class TinyFlux:
     """The TinyFlux class containing the interface for the TinyFlux package.
 
@@ -220,8 +239,12 @@ class TinyFlux:
         Returns:
             True if point found, else False.
         """
+        use_index = (
+            self._index.valid and not _query_contains_negated_field_query(query)
+        )
+
         # If the index is valid, check it.
-        if self._index.valid:
+        if use_index:
             if measurement:
                 mq = MeasurementQuery() == measurement
                 index_rst = self._index.search(mq & query)
@@ -261,8 +284,12 @@ class TinyFlux:
         Returns:
             A count of matching points in the measurement.
         """
+        use_index = (
+            self._index.valid and not _query_contains_negated_field_query(query)
+        )
+
         # If the index is valid, check it.
-        if self._index.valid:
+        if use_index:
             if measurement:
                 mq = MeasurementQuery() == measurement
                 index_rst = self._index.search(mq & query)
@@ -327,7 +354,9 @@ class TinyFlux:
         Returns:
             First found Point or None.
         """
-        use_index = self._index.valid
+        use_index = (
+            self._index.valid and not _query_contains_negated_field_query(query)
+        )
 
         # If we are auto-indexing and the index is valid, check it.
         if use_index:
@@ -757,7 +786,9 @@ class TinyFlux:
         if not isinstance(query, (SimpleQuery, CompoundQuery)):
             raise ValueError("query must be a TinyFlux Query.")
 
-        use_index = self._index.valid
+        use_index = (
+            self._index.valid and not _query_contains_negated_field_query(query)
+        )
 
         # If we are auto-indexing and the index is valid, check it.
         if use_index:
@@ -870,7 +901,9 @@ class TinyFlux:
             else:
                 raise ValueError(f"Invalid key `{key}`.")
 
-        use_index = self._index.valid
+        use_index = (
+            self._index.valid and not _query_contains_negated_field_query(query)
+        )
 
         results = []
 
@@ -1337,7 +1370,9 @@ class TinyFlux:
         Raises:
             OSError if storage cannot be written to.
         """
-        use_index = self._index.valid
+        use_index = (
+            self._index.valid and not _query_contains_negated_field_query(query)
+        )
 
         # If we are auto-indexing and the index is valid, check it.
         if use_index:
@@ -1492,7 +1527,11 @@ class TinyFlux:
             unset_tags=unset_tags,
         )
 
-        use_index = not update_all and self._index.valid
+        use_index = (
+            not update_all
+            and self._index.valid
+            and not _query_contains_negated_field_query(query)
+        )
 
         # If we are auto-indexing and the index is valid, check it.
         if use_index:

{tinyflux-1.2.1 → tinyflux-1.3.0}/tinyflux/index.py

@@ -110,7 +110,7 @@ class Index:
 
     _num_items: int
     _tags: Dict[str, Dict[Union[None, str], List[int]]]
-    _fields: Dict[str, List[Tuple[int, Optional[float]]]]
+    _fields: Dict[str, List[Tuple[int, FieldValue]]]
     _measurements: Dict[str, List[int]]
     _timestamps: List[float]
     _valid: bool

{tinyflux-1.2.1 → tinyflux-1.3.0}/tinyflux/point.py

@@ -6,8 +6,8 @@ deserialized from Storage. SimpleQuery act upon individual Points.
 
 A Point is comprised of a timestamp, a measurement, fields, and tags.
 
-Fields contains string/numeric key-values, while tags contain
-string/string key-values.  This is enforced upon Point instantiation.
+Fields contains string/(numeric, string, or bool) key-values, while tags
+contain string/string key-values.  This is enforced upon Point instantiation.
 
 Usage:
 
@@ -22,10 +22,11 @@ Usage:
 """
 
 from datetime import datetime, timezone
-from typing import Any, Dict, Mapping, Optional, Sequence, Union
+import re
+from typing import Any, Dict, Mapping, Optional, Sequence, Union, cast
 
 TagSet = Dict[str, Optional[str]]
-FieldValue = Union[int, float, None]
+FieldValue = Union[int, float, str, bool, None]
 FieldSet = Dict[str, FieldValue]
 
 
@@ -73,14 +74,83 @@ def validate_fields(fields: Any) -> None:
         if i is None:
             continue
 
-        if isinstance(i, bool) or not isinstance(i, (int, float)):
+        if not isinstance(i, (int, float, str, bool)):
             raise ValueError(
-                "Field set must contain only numeric values or None."
+                "Field set must contain only numeric, string, or bool values "
+                "or None."
             )
 
     return
 
 
+_FIELD_STR_ESCAPES = {"\\": "\\\\", '"': '\\"', "\n": "\\n", "\r": "\\r"}
+_FIELD_STR_UNESCAPES = {"\\": "\\", '"': '"', "n": "\n", "r": "\r"}
+
+
+def _serialize_field_value(value: FieldValue, none_str: str) -> str:
+    """Serialize a field value to a string.
+
+    Numbers are written as floats, bools as "true"/"false", and strings in
+    double quotes with backslash, double quote, and line break characters
+    escaped so that a serialized value never spans multiple lines.
+
+    Args:
+        value: The field value.
+        none_str: The string that represents None.
+
+    Returns:
+        The serialized field value.
+    """
+    value_type = type(value)
+
+    if value_type is float:
+        return str(value)
+
+    if value_type is int:
+        return str(float(cast(int, value)))
+
+    if value is None:
+        return none_str
+
+    if isinstance(value, bool):
+        return "true" if value else "false"
+
+    if isinstance(value, str):
+        escaped = "".join(_FIELD_STR_ESCAPES.get(c, c) for c in value)
+        return f'"{escaped}"'
+
+    if isinstance(value, (int, float)):
+        return str(float(value))
+
+    raise TypeError(f"Unsupported field value type: {type(value).__name__}")
+
+
+def _deserialize_non_numeric_field_value(value: str) -> FieldValue:
+    """Deserialize a field value that is not a number.
+
+    Args:
+        value: The serialized field value.
+
+    Returns:
+        A bool for "true"/"false", a str for a double-quoted value, and None
+        for anything else.
+    """
+    if value == "true":
+        return True
+
+    if value == "false":
+        return False
+
+    if len(value) >= 2 and value[0] == '"' and value[-1] == '"':
+        return re.sub(
+            r"\\(.)",
+            lambda m: _FIELD_STR_UNESCAPES.get(m.group(1), m.group(0)),
+            value[1:-1],
+        )
+
+    return None
+
+
 class Point:
     """Define the Point class.
 
@@ -291,9 +361,9 @@ class Point:
             try:
                 p_fields[f_key] = float(f_value)
 
-            # Value is None.
+            # Value is a bool, a string, or None.
             except Exception:
-                p_fields[f_key] = None
+                p_fields[f_key] = _deserialize_non_numeric_field_value(f_value)
 
             i += 2
 
@@ -351,7 +421,7 @@ class Point:
         fields = (
             (
                 f"{field_key_prefix}{k}",
-                self._none_str if v is None else str(float(v)),
+                _serialize_field_value(v, self._none_str),
             )
             for k, v in self._fields.items()
         )

{tinyflux-1.2.1 → tinyflux-1.3.0}/tinyflux/queries.py

@@ -32,6 +32,42 @@ from .point import Point
 
 Query = Union["SimpleQuery", "CompoundQuery"]
 
+_NE = operator.ne
+
+
+class _HashableRHS:
+    """A hash key for RHS values that preserves bool identity."""
+
+    __slots__ = ("_kind", "_value", "_display_value")
+
+    def __init__(self, kind: Any, value: Any, display_value: Any) -> None:
+        self._kind = kind
+        self._value = value
+        self._display_value = display_value
+
+    def __hash__(self) -> int:
+        return hash((self._kind, self._value))
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, _HashableRHS):
+            return False
+
+        return bool((self._kind, self._value) == (other._kind, other._value))
+
+    def __repr__(self) -> str:
+        return repr(self._display_value)
+
+
+def _hashable_rhs(rhs: Any) -> Any:
+    """Return a hash key for RHS values that preserves bool identity."""
+    if isinstance(rhs, bool):
+        return _HashableRHS(bool, rhs, rhs)
+
+    if isinstance(rhs, (int, float)):
+        return _HashableRHS("number", float(rhs), rhs)
+
+    return _HashableRHS(type(rhs), rhs, rhs)
+
 
 class CompoundQuery:
     """A container class for simple and/or compound queries and an operator.
@@ -467,15 +503,25 @@ class BaseQuery:
         if (
             self._point_attr == "_fields"
             and rhs
-            and not isinstance(rhs, (int, float))
+            and not isinstance(rhs, (int, float, str))
         ):
-            raise TypeError("FieldQuery comparison value must be numeric.")
+            raise TypeError(
+                "FieldQuery comparison value must be numeric, string, or bool."
+            )
+
+        is_field_query = self._point_attr == "_fields"
+        rhs_is_bool = isinstance(rhs, bool)
 
         def test(x: Any) -> bool:
             """The test function from an operator and right-hand side."""
             if not test_against_rhs:
                 return operator(x, *args) if args else operator(x)
 
+            # A bool field is not a number, so a bool is only ever equal to
+            # another bool and never orders against a non-bool.
+            if is_field_query and isinstance(x, bool) != rhs_is_bool:
+                return operator is _NE
+
             # Wrap this in a try/except block.
             # Some operators do not work against None types.
             # They should evaluate to False.
@@ -532,7 +578,7 @@ class BaseQuery:
             test_against_rhs=True,
             rhs=rhs,
             args=None,
-            hashval=(self._point_attr, "==", self._path, rhs),
+            hashval=(self._point_attr, "==", self._path, _hashable_rhs(rhs)),
         )
 
     def __ne__(self, rhs: Any) -> SimpleQuery:  # type: ignore
@@ -551,7 +597,7 @@ class BaseQuery:
             test_against_rhs=True,
             rhs=rhs,
             args=None,
-            hashval=(self._point_attr, "!=", self._path, rhs),
+            hashval=(self._point_attr, "!=", self._path, _hashable_rhs(rhs)),
         )
 
     def __lt__(self, rhs: Any) -> SimpleQuery:
@@ -568,7 +614,7 @@ class BaseQuery:
             test_against_rhs=True,
             rhs=rhs,
             args=None,
-            hashval=(self._point_attr, "<", self._path, rhs),
+            hashval=(self._point_attr, "<", self._path, _hashable_rhs(rhs)),
         )
 
     def __le__(self, rhs: Any) -> SimpleQuery:
@@ -585,7 +631,7 @@ class BaseQuery:
             test_against_rhs=True,
             rhs=rhs,
             args=None,
-            hashval=(self._point_attr, "<=", self._path, rhs),
+            hashval=(self._point_attr, "<=", self._path, _hashable_rhs(rhs)),
         )
 
     def __gt__(self, rhs: Any) -> SimpleQuery:
@@ -602,7 +648,7 @@ class BaseQuery:
             test_against_rhs=True,
             rhs=rhs,
             args=None,
-            hashval=(self._point_attr, ">", self._path, rhs),
+            hashval=(self._point_attr, ">", self._path, _hashable_rhs(rhs)),
         )
 
     def __ge__(self, rhs: Any) -> SimpleQuery:
@@ -619,7 +665,7 @@ class BaseQuery:
             test_against_rhs=True,
             rhs=rhs,
             args=None,
-            hashval=(self._point_attr, ">=", self._path, rhs),
+            hashval=(self._point_attr, ">=", self._path, _hashable_rhs(rhs)),
         )
 
     def __and__(self, other: Any) -> None:

{tinyflux-1.2.1 → tinyflux-1.3.0}/tinyflux/storages.py

@@ -368,7 +368,9 @@ class CSVStorage(Storage):
 
     def _init_temp_storage(self) -> None:
         """Initialize temporary storage."""
-        self._temp_handle = NamedTemporaryFile("w+t", newline="", delete=False)
+        self._temp_handle = NamedTemporaryFile(
+            "w+t", encoding=self._encoding, newline="", delete=False
+        )
 
         return
 

tinyflux-1.3.0/tinyflux/version.py

@@ -0,0 +1,3 @@
+"""Version."""
+
+__version__ = "1.3.0"  # pragma: no cover

{tinyflux-1.2.1 → tinyflux-1.3.0/tinyflux.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tinyflux
-Version: 1.2.1
+Version: 1.3.0
 Summary: The Tiny Time-Series Database Optimized for Your Happiness
 Home-page: https://github.com/citrusvanilla/tinyflux
 Author: Justin Fung

tinyflux-1.2.1/tinyflux/version.py

@@ -1,3 +0,0 @@
-"""Version."""
-
-__version__ = "1.2.1"  # pragma: no cover