diff --git a/pyproject.toml b/pyproject.toml
index 07688b4..ceb6e63 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -68,7 +68,23 @@ llm = "dataforge.providers.llm"
 dataforge = "dataforge.pytest_plugin"
 
 [dependency-groups]
-dev = ["pytest>=8.0", "pytest-asyncio>=0.24", "ruff>=0.15.4,<0.17"]
+dev = [
+    "pytest>=8.0",
+    "pytest-asyncio>=0.24",
+    "pytest-cov>=5.0",
+    "ruff>=0.15.4,<0.17",
+    "sqlalchemy>=2.0",
+    "textual>=0.40",
+    "hypothesis>=6.0",
+]
+
+[tool.coverage.run]
+branch = true
+source = ["src/dataforge"]
+
+[tool.coverage.report]
+show_missing = true
+skip_covered = false
 
 [tool.ruff]
 target-version = "py312"
diff --git a/src/dataforge/backend.py b/src/dataforge/backend.py
index bc83a25..b39eacf 100644
--- a/src/dataforge/backend.py
+++ b/src/dataforge/backend.py
@@ -276,7 +276,7 @@ def regexify(self, pattern: str) -> str:
                         for _ in range(reps):
                             result.append(_rng.choice(options))
                         continue
-                    elif pattern[i] == "?":
+                    else:  # pattern[i] == "?" — the guard above constrains to {+*?}
                         if _rng.random() > 0.5:
                             result.append(chosen)
                         i += 1
diff --git a/tests/test_backend_qa.py b/tests/test_backend_qa.py
new file mode 100644
index 0000000..1008a6e
--- /dev/null
+++ b/tests/test_backend_qa.py
@@ -0,0 +1,516 @@
+"""Stdlib-only unittest suite for dataforge.backend.RandomEngine."""
+
+import re
+import string
+import unittest
+from unittest import mock
+
+from dataforge import backend as backend_module
+from dataforge.backend import RandomEngine
+
+DIGITS = set(string.digits)
+LETTERS_UPPER = set(string.ascii_uppercase)
+LETTERS_ALL = set(string.ascii_letters)
+
+
+class TestNumerify(unittest.TestCase):
+    def setUp(self) -> None:
+        self.engine = RandomEngine(seed=42)
+
+    def test_all_hash_fast_path_produces_exact_digits(self):
+        result = self.engine.numerify("#####")
+        self.assertEqual(len(result), 5)
+        self.assertTrue(set(result) <= DIGITS)
+
+    def test_no_hash_returns_pattern_unchanged(self):
+        self.assertEqual(self.engine.numerify("ABC-123"), "ABC-123")
+
+    def test_empty_string_quirk_returns_zero(self):
+        # QUIRK: for "", hash_count == len(pattern) is 0 == 0 (True), so the
+        # empty pattern routes to random_digits_str(0) -> "0". This test pins
+        # the actual behavior so any change is a deliberate, reviewed decision.
+        self.assertEqual(self.engine.numerify(""), "0")
+
+    def test_mixed_replaces_only_hash_positions(self):
+        result = self.engine.numerify("A#B##")
+        self.assertEqual(len(result), 5)
+        self.assertEqual(result[0], "A")
+        self.assertEqual(result[2], "B")
+        self.assertTrue(
+            result[1] in DIGITS and result[3] in DIGITS and result[4] in DIGITS
+        )
+
+    def test_determinism_same_seed(self):
+        a = RandomEngine(seed=7).numerify("##-##")
+        b = RandomEngine(seed=7).numerify("##-##")
+        self.assertEqual(a, b)
+
+
+class TestLetterify(unittest.TestCase):
+    def setUp(self) -> None:
+        self.engine = RandomEngine(seed=42)
+
+    def test_no_question_marks_identity(self):
+        self.assertEqual(self.engine.letterify("XYZ"), "XYZ")
+
+    def test_default_pool_includes_mixed_case(self):
+        result = self.engine.letterify("?" * 200)
+        self.assertTrue(set(result) <= LETTERS_ALL)
+        self.assertTrue(any(c.isupper() for c in result))
+        self.assertTrue(any(c.islower() for c in result))
+
+    def test_upper_flag_restricts_to_uppercase(self):
+        result = self.engine.letterify("?" * 100, upper=True)
+        self.assertTrue(set(result) <= LETTERS_UPPER)
+
+    def test_preserves_literal_positions(self):
+        result = self.engine.letterify("?-?")
+        self.assertEqual(result[1], "-")
+        self.assertEqual(len(result), 3)
+
+
+class TestBothify(unittest.TestCase):
+    def setUp(self) -> None:
+        self.engine = RandomEngine(seed=42)
+
+    def test_no_tokens_identity(self):
+        self.assertEqual(self.engine.bothify("plain"), "plain")
+
+    def test_hashes_only(self):
+        result = self.engine.bothify("##")
+        self.assertTrue(set(result) <= DIGITS)
+
+    def test_questions_only(self):
+        result = self.engine.bothify("??")
+        self.assertTrue(set(result) <= LETTERS_ALL)
+
+    def test_combined_replaces_respective_tokens(self):
+        result = self.engine.bothify("#?-?#")
+        self.assertEqual(result[2], "-")
+        self.assertTrue(result[0] in DIGITS and result[4] in DIGITS)
+        self.assertTrue(result[1] in LETTERS_ALL and result[3] in LETTERS_ALL)
+
+
+class TestRandomDigitsStr(unittest.TestCase):
+    def setUp(self) -> None:
+        self.engine = RandomEngine(seed=42)
+
+    def test_n_zero_quirk_returns_zero(self):
+        # QUIRK: n=0 takes the n<=18 branch; str(0).zfill(0) returns '0'
+        # (zfill never truncates). Pin actual behavior.
+        self.assertEqual(self.engine.random_digits_str(0), "0")
+
+    def test_n_one_single_digit(self):
+        self.assertEqual(len(self.engine.random_digits_str(1)), 1)
+
+    def test_boundary_18_exact_length(self):
+        result = self.engine.random_digits_str(18)
+        self.assertEqual(len(result), 18)
+        self.assertTrue(set(result) <= DIGITS)
+
+    def test_boundary_19_enters_chunk_loop(self):
+        result = self.engine.random_digits_str(19)
+        self.assertEqual(len(result), 19)
+        self.assertTrue(set(result) <= DIGITS)
+
+    def test_large_n_multiple_chunks(self):
+        result = self.engine.random_digits_str(50)
+        self.assertEqual(len(result), 50)
+        self.assertTrue(set(result) <= DIGITS)
+
+
+class TestWeightedCache(unittest.TestCase):
+    def setUp(self) -> None:
+        backend_module._CUM_WEIGHTS_CACHE.clear()
+        self.engine = RandomEngine(seed=42)
+
+    def tearDown(self) -> None:
+        backend_module._CUM_WEIGHTS_CACHE.clear()
+
+    def test_miss_populates_cache_with_cumulative_sums(self):
+        weights = (0.1, 0.6, 0.3)
+        self.assertNotIn(id(weights), backend_module._CUM_WEIGHTS_CACHE)
+        self.engine.weighted_choices(("a", "b", "c"), weights, 5)
+        cum = backend_module._CUM_WEIGHTS_CACHE[id(weights)]
+        self.assertEqual(len(cum), 3)
+        self.assertAlmostEqual(cum[0], 0.1)
+        self.assertAlmostEqual(cum[-1], 1.0)
+        self.assertLessEqual(cum[0], cum[1])
+        self.assertLessEqual(cum[1], cum[2])
+
+    def test_hit_reuses_cached_entry(self):
+        weights = (1.0, 2.0)
+        self.engine.weighted_choices(("x", "y"), weights, 3)
+        first_entry = backend_module._CUM_WEIGHTS_CACHE[id(weights)]
+        self.engine.weighted_choices(("x", "y"), weights, 3)
+        self.assertIs(backend_module._CUM_WEIGHTS_CACHE[id(weights)], first_entry)
+
+    def test_heavy_first_weight_biases_output(self):
+        weights = (0.99, 0.005, 0.005)
+        result = self.engine.weighted_choices(("a", "b", "c"), weights, 2000)
+        self.assertGreater(result.count("a"), 1800)
+
+    def test_weighted_choice_returns_scalar_from_data(self):
+        result = self.engine.weighted_choice(("only",), (1.0,))
+        self.assertEqual(result, "only")
+
+
+class TestDistributions(unittest.TestCase):
+    def setUp(self) -> None:
+        self.engine = RandomEngine(seed=42)
+
+    def test_random_int_inclusive_bounds(self):
+        for _ in range(200):
+            v = self.engine.random_int(5, 7)
+            self.assertTrue(5 <= v <= 7)
+        self.assertIsInstance(v, int)
+
+    def test_random_float_bounds_and_precision(self):
+        v = self.engine.random_float(1.0, 2.0, precision=3)
+        self.assertTrue(1.0 <= v <= 2.0)
+        self.assertEqual(round(v, 3), v)
+
+    def test_random_float_zero_precision_is_integral(self):
+        v = self.engine.random_float(0.0, 100.0, precision=0)
+        self.assertEqual(v, round(v, 0))
+
+    def test_gauss_int_clamps_to_range(self):
+        for _ in range(500):
+            v = self.engine.gauss_int(mu=5.0, sigma=1000.0, min_val=0, max_val=10)
+            self.assertTrue(0 <= v <= 10)
+            self.assertIsInstance(v, int)
+
+    def test_triangular_default_mode_within_bounds(self):
+        v = self.engine.triangular(0.0, 10.0)
+        self.assertTrue(0.0 <= v <= 10.0)
+
+    def test_triangular_explicit_mode(self):
+        v = self.engine.triangular(0.0, 10.0, mode=9.0)
+        self.assertTrue(0.0 <= v <= 10.0)
+
+    def test_exponential_and_gamma_positive(self):
+        self.assertGreaterEqual(self.engine.exponential(1.0), 0.0)
+        self.assertGreater(self.engine.gamma(2.0, 2.0), 0.0)
+
+    def test_log_normal_pareto_beta_vonmises_types(self):
+        self.assertGreater(self.engine.log_normal(0.0, 1.0), 0.0)
+        self.assertGreaterEqual(self.engine.pareto(1.0), 1.0)
+        beta_v = self.engine.beta(2.0, 5.0)
+        self.assertTrue(0.0 <= beta_v <= 1.0)
+        self.assertIsInstance(self.engine.vonmises(0.0, 1.0), float)
+
+    def test_zipf_within_support(self):
+        for _ in range(100):
+            v = self.engine.zipf(alpha=1.5, n=10)
+            self.assertTrue(1 <= v <= 10)
+            self.assertIsInstance(v, int)
+
+    def test_getrandbits_bit_length(self):
+        v = self.engine.getrandbits(8)
+        self.assertTrue(0 <= v < 256)
+
+    def test_sample_uniqueness(self):
+        data = tuple(range(100))
+        result = self.engine.sample(data, 25)
+        self.assertEqual(len(result), 25)
+        self.assertEqual(len(set(result)), 25)
+        self.assertTrue(set(result) <= set(data))
+
+
+class TestRegexify(unittest.TestCase):
+    def setUp(self) -> None:
+        self.engine = RandomEngine(seed=42)
+
+    def test_digit_escape_class(self):
+        result = self.engine.regexify(r"\d\d\d")
+        self.assertTrue(set(result) <= DIGITS)
+        self.assertEqual(len(result), 3)
+
+    def test_word_escape_class(self):
+        allowed = LETTERS_ALL | DIGITS | {"_"}
+        result = self.engine.regexify(r"\w" * 10)
+        self.assertTrue(set(result) <= allowed)
+
+    def test_space_escape_class(self):
+        self.assertIn(self.engine.regexify(r"\s"), (" ", "\t"))
+
+    def test_unknown_escape_quirk_double_emits(self):
+        # QUIRK: the else-branch appends esc, then _regexify_quantifier (with
+        # no following quantifier) appends base again -> double emission.
+        self.assertEqual(self.engine.regexify(r"\n"), "nn")
+
+    def test_trailing_backslash_emitted_literally(self):
+        self.assertEqual(self.engine.regexify("a\\"), "a\\")
+
+    def test_char_class_range(self):
+        for _ in range(50):
+            self.assertIn(self.engine.regexify("[a-c]"), "abc")
+
+    def test_char_class_explicit_set(self):
+        for _ in range(50):
+            self.assertIn(self.engine.regexify("[xyz]"), "xyz")
+
+    def test_unterminated_char_class_literal(self):
+        self.assertEqual(self.engine.regexify("[abc"), "[abc")
+
+    def test_group_alternation(self):
+        for _ in range(50):
+            self.assertIn(self.engine.regexify("(cat|dog)"), ("cat", "dog"))
+
+    def test_unterminated_group_literal(self):
+        self.assertEqual(self.engine.regexify("(ab"), "(ab")
+
+    def test_group_with_count_quantifier(self):
+        result = self.engine.regexify("(ab){3}")
+        self.assertEqual(result, "ababab")
+
+    def test_group_with_range_quantifier(self):
+        result = self.engine.regexify("(ab){2,4}")
+        self.assertEqual(len(result) % 2, 0)
+        self.assertTrue(4 <= len(result) <= 8)
+        self.assertTrue(set(result) <= {"a", "b"})
+
+    def test_group_open_range_quantifier(self):
+        self.assertEqual(self.engine.regexify("(ab){2,}"), "abab")
+
+    def test_group_plus_quantifier(self):
+        result = self.engine.regexify("(ab)+")
+        self.assertTrue(2 <= len(result) <= 6)
+        self.assertEqual(len(result) % 2, 0)
+
+    def test_group_star_quantifier_allows_zero(self):
+        result = self.engine.regexify("(ab)*")
+        self.assertTrue(0 <= len(result) <= 6)
+        self.assertEqual(len(result) % 2, 0)
+
+    def test_group_question_quantifier(self):
+        result = self.engine.regexify("(ab)?")
+        self.assertIn(result, ("", "ab"))
+
+    def test_group_with_unclosed_brace_treats_brace_literally(self):
+        # '{3' has no closing '}': the group emits its chosen option, then the
+        # unclosed '{' falls to the default literal path for '{' and '3'.
+        self.assertEqual(self.engine.regexify("(ab){3"), "ab{3")
+
+    def test_dot_wildcard_printable_ascii(self):
+        result = self.engine.regexify("....")
+        self.assertEqual(len(result), 4)
+        self.assertTrue(all(33 <= ord(c) <= 126 for c in result))
+
+    def test_literal_with_exact_quantifier(self):
+        self.assertEqual(self.engine.regexify("a{4}"), "aaaa")
+
+    def test_literal_with_range_quantifier(self):
+        result = self.engine.regexify("b{2,5}")
+        self.assertTrue(2 <= len(result) <= 5)
+        self.assertEqual(set(result), {"b"})
+
+    def test_literal_plus_and_star(self):
+        plus = self.engine.regexify("c+")
+        self.assertTrue(1 <= len(plus) <= 3 and set(plus) == {"c"})
+        star = self.engine.regexify("d*")
+        self.assertTrue(0 <= len(star) <= 3 and set(star) <= {"d"})
+
+    def test_literal_question_optional(self):
+        self.assertIn(self.engine.regexify("e?"), ("", "e"))
+
+    def test_literal_question_appends_when_random_high(self):
+        # Lines 365-366: '?' literal quantifier, random() > 0.5 -> append base.
+        with mock.patch.object(self.engine._rng, "random", return_value=0.9):
+            self.assertEqual(self.engine.regexify("e?"), "e")
+
+    def test_literal_question_skips_when_random_low(self):
+        with mock.patch.object(self.engine._rng, "random", return_value=0.1):
+            self.assertEqual(self.engine.regexify("e?"), "")
+
+    def test_unclosed_brace_treated_as_literal(self):
+        self.assertEqual(self.engine.regexify("a{3"), "a{3")
+
+    def test_quantifier_at_end_appends_base(self):
+        self.assertEqual(self.engine.regexify("z"), "z")
+
+    def test_complex_pattern_matches_expectation(self):
+        result = self.engine.regexify(r"[A-Z]{2}\d{3}")
+        self.assertTrue(re.fullmatch(r"[A-Z]{2}\d{3}", result), msg=result)
+
+    def test_determinism_same_seed(self):
+        a = RandomEngine(seed=99).regexify(r"\w{8}")
+        b = RandomEngine(seed=99).regexify(r"\w{8}")
+        self.assertEqual(a, b)
+
+
+class TestParseCharClass(unittest.TestCase):
+    def test_range_expansion(self):
+        self.assertEqual(RandomEngine._parse_char_class("a-c"), "abc")
+
+    def test_mixed_ranges_and_literals(self):
+        self.assertEqual(RandomEngine._parse_char_class("a-bX0-1"), "abX01")
+
+    def test_dash_at_end_is_literal(self):
+        self.assertEqual(RandomEngine._parse_char_class("a-"), "a-")
+
+    def test_empty_spec_returns_fallback(self):
+        self.assertEqual(RandomEngine._parse_char_class(""), "?")
+
+
+class TestBasicPrimitivesGap(unittest.TestCase):
+    """Close uncovered lines 28, 32, 120, 147, 156: choice/choices/seed/gauss."""
+
+    def setUp(self) -> None:
+        self.engine = RandomEngine(seed=42)
+
+    def test_choice_returns_member_of_data(self):
+        # Line 28: single-element selection via rng.choice
+        data = ("alpha", "beta", "gamma")
+        for _ in range(50):
+            self.assertIn(self.engine.choice(data), data)
+
+    def test_choices_count_and_membership(self):
+        # Line 32: batch selection via rng.choices
+        data = (1, 2, 3)
+        result = self.engine.choices(data, 40)
+        self.assertEqual(len(result), 40)
+        self.assertTrue(set(result) <= set(data))
+
+    def test_seed_method_resets_state(self):
+        # Line 120: explicit seed() produces reproducible stream
+        self.engine.seed(123)
+        first = self.engine.random_int(0, 10**9)
+        self.engine.seed(123)
+        self.assertEqual(self.engine.random_int(0, 10**9), first)
+
+    def test_gauss_returns_float(self):
+        # Line 156: unclamped gaussian
+        v = self.engine.gauss(0.0, 1.0)
+        self.assertIsInstance(v, float)
+
+    def test_weighted_choice_cache_hit_skips_recompute(self):
+        # Arc 147->152: cum is not None -> skip accumulate, go straight to
+        # choices. Pre-populate the cache for this weights id, then call.
+        backend_module._CUM_WEIGHTS_CACHE.clear()
+        weights = (0.3, 0.7)
+        cached = [0.3, 1.0]
+        backend_module._CUM_WEIGHTS_CACHE[id(weights)] = cached
+        result = self.engine.weighted_choice(("a", "b"), weights)
+        self.assertIn(result, ("a", "b"))
+        # Same object retained -> hit branch taken, not recomputed
+        self.assertIs(backend_module._CUM_WEIGHTS_CACHE[id(weights)], cached)
+        backend_module._CUM_WEIGHTS_CACHE.clear()
+
+    def test_weighted_choice_cache_miss_populates(self):
+        # Line 147: the cache-miss branch of weighted_choice (distinct from
+        # weighted_choices). Fresh weights object guarantees a miss.
+        backend_module._CUM_WEIGHTS_CACHE.clear()
+        weights = (0.5, 0.5)
+        self.assertNotIn(id(weights), backend_module._CUM_WEIGHTS_CACHE)
+        self.engine.weighted_choice(("a", "b"), weights)
+        self.assertIn(id(weights), backend_module._CUM_WEIGHTS_CACHE)
+        backend_module._CUM_WEIGHTS_CACHE.clear()
+
+
+class TestRegexifyGroupQuantifierGap(unittest.TestCase):
+    """Close lines 277, 279-281, 353, 360, 365-367: group-level quantifiers
+    that iterate _rng.choice(options) directly (char_pool=None in the group
+    handler), plus the '?' group-quantifier random>0.5 append path."""
+
+    def setUp(self) -> None:
+        self.engine = RandomEngine(seed=42)
+
+    def test_group_count_quantifier_uses_choice_per_rep(self):
+        # Lines 277/353: '(ab|cd){3}' -> for each rep, rng.choice(options)
+        result = self.engine.regexify("(ab|cd){3}")
+        self.assertEqual(len(result), 6)
+        self.assertTrue(set(result) <= {"a", "b", "c", "d"})
+        # Each 2-char chunk must be a full option, not mixed letters
+        chunks = [result[i : i + 2] for i in range(0, 6, 2)]
+        for c in chunks:
+            self.assertIn(c, ("ab", "cd"))
+
+    def test_group_plus_quantifier_choice_per_rep(self):
+        # Lines 353/360: '+' group with multiple options
+        result = self.engine.regexify("(x|y)+")
+        self.assertTrue(1 <= len(result) <= 3)
+        self.assertTrue(set(result) <= {"x", "y"})
+
+    def test_group_star_quantifier_choice_per_rep(self):
+        # Line 360: '*' group quantifier path
+        result = self.engine.regexify("(p|q)*")
+        self.assertTrue(0 <= len(result) <= 3)
+        self.assertTrue(set(result) <= {"p", "q"})
+
+    def test_group_question_appends_when_random_high(self):
+        # Lines 279-281: '?' group quantifier with random() > 0.5 -> append.
+        # Mock the engine's RNG (a collaborator boundary, not the logic under
+        # test) to force the > 0.5 branch deterministically.
+        with mock.patch.object(self.engine._rng, "random", return_value=0.9):
+            result = self.engine.regexify("(m)?")
+        self.assertEqual(result, "m")
+
+    def test_group_question_skips_when_random_low(self):
+        # random() <= 0.5 -> skip append branch (arc 279->284).
+        with mock.patch.object(self.engine._rng, "random", return_value=0.1):
+            result = self.engine.regexify("(m)?")
+        self.assertEqual(result, "")
+
+    def test_group_question_both_arcs(self):
+        # Drive random() above then below 0.5 across two calls on one engine so
+        # coverage registers both the append arc and the skip arc for the '?'
+        # group quantifier, closing the partial branch.
+        with mock.patch.object(self.engine._rng, "random", side_effect=[0.9, 0.1]):
+            high = self.engine.regexify("(m)?")
+            low = self.engine.regexify("(m)?")
+        self.assertEqual(high, "m")
+        self.assertEqual(low, "")
+
+    def test_group_count_quantifier_line277_direct(self):
+        # Line 277: the exact `result.append(_rng.choice(options))` inside the
+        # group '{n}' repetition. Force randint to a known rep count and choice
+        # to a fixed option for a fully deterministic assertion.
+        with (
+            mock.patch.object(self.engine._rng, "randint", return_value=2),
+            mock.patch.object(self.engine._rng, "choice", return_value="ab"),
+        ):
+            result = self.engine.regexify("(ab){2,5}")
+        self.assertEqual(result, "abab")
+
+    def test_group_star_quantifier_line277_branch(self):
+        # Line 277 via the '*' group branch (reps in 0..3). Force reps=2 and a
+        # fixed option so the append loop body executes deterministically.
+        with (
+            mock.patch.object(self.engine._rng, "randint", return_value=2),
+            mock.patch.object(self.engine._rng, "choice", return_value="zz"),
+        ):
+            result = self.engine.regexify("(zz)*")
+        self.assertEqual(result, "zzzz")
+
+
+class TestQuantifierCharPoolGap(unittest.TestCase):
+    """Close lines 353/360 char_pool branches for class/dot quantifiers."""
+
+    def setUp(self) -> None:
+        self.engine = RandomEngine(seed=42)
+
+    def test_char_class_plus_draws_from_pool(self):
+        # '[abc]+' -> char_pool set, '+' branch, rng.choice(char_pool)
+        result = self.engine.regexify("[abc]+")
+        self.assertTrue(1 <= len(result) <= 3)
+        self.assertTrue(set(result) <= {"a", "b", "c"})
+
+    def test_char_class_star_draws_from_pool(self):
+        result = self.engine.regexify("[01]*")
+        self.assertTrue(0 <= len(result) <= 3)
+        self.assertTrue(set(result) <= {"0", "1"})
+
+    def test_char_class_count_from_pool(self):
+        result = self.engine.regexify("[ab]{4}")
+        self.assertEqual(len(result), 4)
+        self.assertTrue(set(result) <= {"a", "b"})
+
+    def test_dot_with_count_quantifier(self):
+        result = self.engine.regexify(".{5}")
+        self.assertEqual(len(result), 5)
+        self.assertTrue(all(33 <= ord(c) <= 126 for c in result))
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_core_gaps_qa.py b/tests/test_core_gaps_qa.py
new file mode 100644
index 0000000..bfd949c
--- /dev/null
+++ b/tests/test_core_gaps_qa.py
@@ -0,0 +1,320 @@
+"""Meaningful coverage-gap tests for core dataforge modules.
+
+Targets behavior (not line-execution) in: providers.datetime, providers.finance,
+providers.lorem, transforms, validation, unique. Stdlib-only unittest, runs
+under pytest. Every test asserts a real contract (format, bounds, truncation,
+retry exhaustion) so removing an assertion breaks regression detection.
+"""
+
+import datetime as dt
+import re
+import string
+import unittest
+
+from dataforge import DataForge
+from dataforge import transforms
+from dataforge.validation import validate_records
+
+DIGITS = set(string.digits)
+
+
+class TestDatetimeBatchPaths(unittest.TestCase):
+    """Cover count>1 batch branches for date/time/datetime (lines 170,189,229,255)
+    and date_of_birth's age-window logic (137-140)."""
+
+    def setUp(self) -> None:
+        self.forge = DataForge(seed=42)
+
+    def test_date_batch_returns_list_of_formatted_dates(self):
+        result = self.forge.dt.date(
+            start=dt.date(2020, 1, 1), end=dt.date(2020, 12, 31), count=5
+        )
+        self.assertEqual(len(result), 5)
+        for d in result:
+            # ISO format default; must parse and fall in the requested window
+            parsed = dt.date.fromisoformat(d)
+            self.assertTrue(dt.date(2020, 1, 1) <= parsed <= dt.date(2020, 12, 31))
+
+    def test_time_batch_format_and_range(self):
+        result = self.forge.dt.time(count=4)
+        self.assertEqual(len(result), 4)
+        for t in result:
+            self.assertTrue(re.fullmatch(r"\d{2}:\d{2}:\d{2}", t), msg=t)
+
+    def test_datetime_batch(self):
+        result = self.forge.dt.datetime(
+            start=dt.date(2021, 1, 1), end=dt.date(2021, 1, 2), count=3
+        )
+        self.assertEqual(len(result), 3)
+        for x in result:
+            self.assertTrue(
+                re.fullmatch(r"\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}", x), msg=x
+            )
+
+    def test_date_of_birth_respects_age_window(self):
+        # date_of_birth(min_age, max_age) must land within [today-max_age, today-min_age]
+        dob = self.forge.dt.date_of_birth(min_age=18, max_age=30)
+        parsed = dt.date.fromisoformat(dob)
+        today = dt.date.today()
+        oldest = today.replace(year=today.year - 30)
+        youngest = today.replace(year=today.year - 18)
+        self.assertTrue(oldest <= parsed <= youngest)
+
+    def test_date_of_birth_custom_fmt_batch(self):
+        # date_of_birth non-default fmt batch path (lines 253-255)
+        result = self.forge.dt.date_of_birth(count=3, min_age=20, max_age=25, fmt="%Y")
+        self.assertEqual(len(result), 3)
+        today = dt.date.today()
+        for d in result:
+            year = int(d)
+            self.assertTrue(today.year - 25 <= year <= today.year - 20)
+
+    def test_datetime_custom_fmt_single(self):
+        # datetime non-default fmt single path (line 229)
+        x = self.forge.dt.datetime(
+            fmt="%Y", start=dt.date(2023, 1, 1), end=dt.date(2023, 12, 31)
+        )
+        self.assertEqual(x, "2023")
+
+    def test_time_default_format_contract(self):
+        # time() default path produces zero-padded HH:MM:SS in valid ranges.
+        t = self.forge.dt.time()
+        self.assertTrue(re.fullmatch(r"\d{2}:\d{2}:\d{2}", t), msg=t)
+        h, m, sec = t.split(":")
+        self.assertTrue(0 <= int(h) <= 23 and 0 <= int(m) <= 59 and 0 <= int(sec) <= 59)
+
+    def test_date_of_birth_custom_fmt_single(self):
+        # date_of_birth count==1 non-ISO fmt -> _one_date().strftime (line 254)
+        today = dt.date.today()
+        d = self.forge.dt.date_of_birth(min_age=30, max_age=35, fmt="%Y")
+        year = int(d)
+        self.assertTrue(today.year - 35 <= year <= today.year - 30)
+
+    def test_date_custom_fmt_uses_strftime_path(self):
+        # Non-default fmt -> routes through _one_date().strftime (line 170 batch)
+        result = self.forge.dt.date(
+            start=dt.date(2020, 6, 1),
+            end=dt.date(2020, 6, 30),
+            fmt="%d/%m/%Y",
+            count=4,
+        )
+        self.assertEqual(len(result), 4)
+        for d in result:
+            self.assertTrue(re.fullmatch(r"\d{2}/\d{2}/2020", d), msg=d)
+
+    def test_date_single_custom_fmt(self):
+        d = self.forge.dt.date(
+            fmt="%Y", start=dt.date(2021, 1, 1), end=dt.date(2021, 12, 31)
+        )
+        self.assertEqual(d, "2021")
+
+    def test_time_custom_fmt_uses_strftime_path(self):
+        # Non-default fmt -> _one_time().strftime (lines 187-189)
+        result = self.forge.dt.time(fmt="%H:%M", count=3)
+        self.assertEqual(len(result), 3)
+        for t in result:
+            self.assertTrue(re.fullmatch(r"\d{2}:\d{2}", t), msg=t)
+
+    def test_time_single_custom_fmt(self):
+        t = self.forge.dt.time(fmt="%H")
+        self.assertTrue(re.fullmatch(r"\d{2}", t), msg=t)
+
+    def test_datetime_custom_fmt(self):
+        result = self.forge.dt.datetime(
+            fmt="%Y", start=dt.date(2022, 1, 1), end=dt.date(2022, 12, 31), count=2
+        )
+        self.assertEqual(result, ["2022", "2022"])
+
+    def test_date_object_returns_date_type(self):
+        d = self.forge.dt.date_object()
+        self.assertIsInstance(d, dt.date)
+        batch = self.forge.dt.date_object(count=3)
+        self.assertTrue(all(isinstance(x, dt.date) for x in batch))
+
+    def test_datetime_object_returns_datetime_type(self):
+        x = self.forge.dt.datetime_object()
+        self.assertIsInstance(x, dt.datetime)
+        batch = self.forge.dt.datetime_object(count=2)
+        self.assertTrue(all(isinstance(i, dt.datetime) for i in batch))
+
+    def test_unix_timestamp_bounds(self):
+        ts = self.forge.dt.unix_timestamp(
+            start=dt.date(2020, 1, 1), end=dt.date(2020, 1, 2)
+        )
+        self.assertIsInstance(ts, int)
+        self.assertGreater(ts, 0)
+
+
+class TestFinanceCardBatches(unittest.TestCase):
+    """Cover cvv/expiry_date batch branches (296-298, 302-312) with format checks."""
+
+    def setUp(self) -> None:
+        self.forge = DataForge(seed=42)
+
+    def test_cvv_single_is_three_digits(self):
+        cvv = self.forge.finance.cvv()
+        self.assertTrue(re.fullmatch(r"\d{3}", cvv), msg=cvv)
+
+    def test_cvv_batch_all_three_digits(self):
+        result = self.forge.finance.cvv(count=10)
+        self.assertEqual(len(result), 10)
+        for c in result:
+            self.assertTrue(re.fullmatch(r"\d{3}", c), msg=c)
+
+    def test_expiry_date_single_format(self):
+        e = self.forge.finance.expiry_date()
+        m = re.fullmatch(r"(\d{2})/(\d{2})", e)
+        self.assertIsNotNone(m, msg=e)
+        self.assertTrue(1 <= int(m.group(1)) <= 12)
+        self.assertTrue(25 <= int(m.group(2)) <= 30)
+
+    def test_expiry_date_batch_format(self):
+        result = self.forge.finance.expiry_date(count=8)
+        self.assertEqual(len(result), 8)
+        for e in result:
+            m = re.fullmatch(r"(\d{2})/(\d{2})", e)
+            self.assertIsNotNone(m, msg=e)
+            self.assertTrue(1 <= int(m.group(1)) <= 12)
+
+
+class TestLoremTextTruncation(unittest.TestCase):
+    """Cover text() max_chars loop incl. the empty->fallback sentence branch (101->107)."""
+
+    def setUp(self) -> None:
+        self.forge = DataForge(seed=42)
+
+    def test_text_respects_max_chars(self):
+        result = self.forge.lorem.text(max_chars=200)
+        self.assertLessEqual(len(result), 200)
+        self.assertGreater(len(result), 0)
+
+    def test_text_very_small_max_falls_back_to_one_sentence(self):
+        # max_chars too small for even one sentence -> `parts` stays empty,
+        # hits the `else self._one_sentence(5)` fallback branch.
+        result = self.forge.lorem.text(max_chars=1)
+        self.assertGreater(len(result), 0)
+        self.assertIn(" ", result.strip())  # a 5-word sentence has spaces
+
+    def test_text_zero_max_chars_returns_fallback(self):
+        result = self.forge.lorem.text(max_chars=0)
+        self.assertGreater(len(result), 0)
+
+
+class TestTransformsEdges(unittest.TestCase):
+    """Cover camel_case empty-parts branch (88) and redact keep_end<=0 branch (184)."""
+
+    def test_camel_case_basic(self):
+        self.assertEqual(transforms.camel_case("hello world"), "helloWorld")
+
+    def test_camel_case_blank_string_returns_empty(self):
+        # "   ".strip() -> "" -> split yields no usable parts -> "" branch (line 88)
+        self.assertEqual(transforms.camel_case("   "), "")
+
+    def test_kebab_case(self):
+        self.assertEqual(transforms.kebab_case("Hello World"), "hello-world")
+
+    def test_redact_keep_end_zero_hides_tail(self):
+        # keep_end=0 -> `if keep_end > 0` False -> the tail-slice branch (line 184)
+        redact = transforms.redact(keep_start=2, keep_end=0, char="*")
+        self.assertEqual(redact("secret"), "se****")
+
+    def test_redact_keep_both_ends(self):
+        redact = transforms.redact(keep_start=1, keep_end=1, char="#")
+        self.assertEqual(redact("abcdef"), "a####f")
+
+    def test_redact_shorter_than_keep_returns_unchanged(self):
+        # keep_start+keep_end >= total -> return s unchanged (line ~183 guard)
+        redact = transforms.redact(keep_start=3, keep_end=3, char="*")
+        self.assertEqual(redact("abc"), "abc")
+
+
+class TestValidationReportAndCsv(unittest.TestCase):
+    """Cover ValidationReport.summary truncation (130-140) and validate_csv (250-258).
+
+    field_map maps column name -> known DataForge field name (e.g. "email"),
+    validated against the built-in _VALIDATORS regex registry."""
+
+    def test_validate_records_flags_invalid_email(self):
+        field_map = {"Email": "email"}
+        rows = [{"Email": "not-an-email"}, {"Email": "good@example.com"}]
+        report = validate_records(rows, field_map, None)
+        self.assertEqual(report.total_rows, 2)
+        self.assertEqual(len(report.violations), 1)
+        self.assertFalse(report.is_valid)
+
+    def test_validate_records_all_valid(self):
+        field_map = {"Email": "email"}
+        rows = [{"Email": "a@b.com"}, {"Email": "c@d.org"}]
+        report = validate_records(rows, field_map, None)
+        self.assertEqual(len(report.violations), 0)
+        self.assertTrue(report.is_valid)
+
+    def test_validate_records_empty_rows(self):
+        # `if not records` early-return branch
+        report = validate_records([], {"Email": "email"}, None)
+        self.assertEqual(report.total_rows, 0)
+        self.assertTrue(report.is_valid)
+
+    def test_summary_truncates_long_values_and_counts_overflow(self):
+        # >5 violations in one column + a >40-char value hits both the
+        # "... and N more" branch and the value-truncation branch (130-140).
+        field_map = {"Email": "email"}
+        rows = [{"Email": "x" * 100} for _ in range(8)]
+        report = validate_records(rows, field_map, None)
+        text = report.summary()
+        self.assertIn("... and 3 more", text)  # 8 viols, shows first 5
+        self.assertIn("...", text)  # long value truncated
+
+    def test_validate_csv_reads_and_validates(self):
+        import csv
+        import os
+        import tempfile
+
+        from dataforge.validation import validate_csv
+
+        with tempfile.NamedTemporaryFile(
+            "w", suffix=".csv", delete=False, newline=""
+        ) as f:
+            w = csv.writer(f)
+            w.writerow(["Email"])
+            w.writerow(["good@example.com"])
+            w.writerow(["bad"])
+            path = f.name
+        try:
+            field_map = {"Email": "email"}
+            report = validate_csv(path, field_map, None)
+            self.assertEqual(report.total_rows, 2)
+            self.assertEqual(len(report.violations), 1)
+        finally:
+            os.unlink(path)
+
+
+class TestUniqueRetryExhaustion(unittest.TestCase):
+    """Cover the RuntimeError retry-exhaustion branch (unique.py 51) and proxy paths."""
+
+    def setUp(self) -> None:
+        self.forge = DataForge(seed=42)
+
+    def test_unique_batch_exhaustion_raises_runtime_error(self):
+        # boolean() has only 2 values; requesting 5 uniques must exhaust retries
+        with self.assertRaises(RuntimeError) as ctx:
+            self.forge.unique.misc.boolean(count=5)
+        self.assertIn("unique", str(ctx.exception).lower())
+
+    def test_unique_clear_provider_allows_reuse(self):
+        names = {self.forge.unique.person.first_name() for _ in range(3)}
+        self.assertEqual(len(names), 3)
+        self.forge.unique.clear("person")
+        # After clear, the same pool is available again without exhaustion
+        again = self.forge.unique.person.first_name(count=3)
+        self.assertEqual(len(again), 3)
+
+    def test_unique_non_callable_attribute_passthrough(self):
+        # unique proxy getattr on a non-callable returns it as-is (line ~96-97)
+        proxy = self.forge.unique.person
+        # Accessing a data attribute (if any) should not wrap; use a known method
+        self.assertTrue(callable(proxy.first_name))
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_seeder_integration.py b/tests/test_seeder_integration.py
new file mode 100644
index 0000000..899f309
--- /dev/null
+++ b/tests/test_seeder_integration.py
@@ -0,0 +1,174 @@
+"""Integration tests for DatabaseSeeder against real in-memory SQLite.
+
+No mocking — each test builds a real SQLite database, introspects it, seeds it,
+and asserts the actual rows written. This is legitimate integration coverage
+(not vanity line-hitting) because assertions verify data round-trips.
+"""
+
+import unittest
+
+import sqlalchemy as sa
+
+from dataforge import DataForge
+from dataforge.seeder import DatabaseSeeder
+
+
+def _make_db(*schemas: str) -> str:
+    """Create an in-memory-ish SQLite file DB with the given CREATE TABLE DDL."""
+    # Use a shared in-memory DB via a file would break across connections, so
+    # use a single-connection in-memory database and return its URL.
+    return "sqlite:///:memory:"
+
+
+class TestDatabaseSeederIntegration(unittest.TestCase):
+    def setUp(self) -> None:
+        self.forge = DataForge(seed=42)
+        self.url = "sqlite:///:memory:"
+        # in-memory sqlite persists for the lifetime of one engine; we create
+        # the schema through the seeder's own (single) engine.
+        self.seeder = DatabaseSeeder(self.forge, self.url)
+        engine = self.seeder._get_engine()
+        self._create_users_table(engine)
+
+    def _create_users_table(self, engine) -> None:
+        with engine.begin() as conn:
+            conn.execute(
+                sa.text(
+                    """
+                    CREATE TABLE users (
+                        id INTEGER PRIMARY KEY AUTOINCREMENT,
+                        first_name VARCHAR,
+                        last_name VARCHAR,
+                        email VARCHAR,
+                        city VARCHAR
+                    )
+                    """
+                )
+            )
+
+    def test_seed_table_inserts_correct_row_count(self):
+        inserted = self.seeder.seed_table("users", count=37)
+        self.assertEqual(inserted, 37)
+        # Assert actual DB contents, not just the return value
+        engine = self.seeder._get_engine()
+        with engine.begin() as conn:
+            rows = conn.execute(sa.text("SELECT COUNT(*) FROM users")).scalar()
+            self.assertEqual(rows, 37)
+
+    def test_seed_table_maps_known_columns_to_fields(self):
+        self.seeder.seed_table("users", count=5)
+        engine = self.seeder._get_engine()
+        with engine.begin() as conn:
+            rows = conn.execute(
+                sa.text("SELECT first_name, email, city FROM users")
+            ).fetchall()
+        self.assertEqual(len(rows), 5)
+        for first, email, city in rows:
+            self.assertIsInstance(first, str) and len(first) > 0
+            self.assertIn("@", email)
+            self.assertIsInstance(city, str) and len(city) > 0
+
+    def test_seed_table_batched_inserts_all_rows(self):
+        # batch_size < count exercises the while-remaining loop
+        inserted = self.seeder.seed_table("users", count=25, batch_size=10)
+        self.assertEqual(inserted, 25)
+        engine = self.seeder._get_engine()
+        with engine.begin() as conn:
+            self.assertEqual(
+                conn.execute(sa.text("SELECT COUNT(*) FROM users")).scalar(), 25
+            )
+
+    def test_introspect_table_skips_autoincrement_pk(self):
+        mapped = self.seeder._introspect_table("users")
+        # 'id' is autoincrement PK -> excluded; others present
+        self.assertNotIn("id", mapped)
+        for col in ("first_name", "last_name", "email", "city"):
+            self.assertIn(col, mapped)
+
+    def test_introspect_table_unknown_table_raises(self):
+        with self.assertRaises(ValueError) as ctx:
+            self.seeder._introspect_table("nonexistent")
+        self.assertIn("not found", str(ctx.exception))
+
+    def test_seed_table_no_mappable_columns_raises(self):
+        engine = self.seeder._get_engine()
+        with engine.begin() as conn:
+            conn.execute(
+                sa.text("CREATE TABLE weird (id INTEGER PRIMARY KEY AUTOINCREMENT)")
+            )
+        with self.assertRaises(ValueError) as ctx:
+            self.seeder.seed_table("weird", count=1)
+        self.assertIn("could not be mapped", str(ctx.exception))
+
+    def test_field_overrides_extend_mapping(self):
+        engine = self.seeder._get_engine()
+        with engine.begin() as conn:
+            conn.execute(
+                sa.text(
+                    "CREATE TABLE custom (id INTEGER PRIMARY KEY AUTOINCREMENT, val VARCHAR)"
+                )
+            )
+        mapped = self.seeder._introspect_table("custom")
+        self.assertNotIn("val", mapped)  # 'val' not a known field
+        self.seeder.seed_table("custom", count=3, field_overrides={"val": "word"})
+        with engine.begin() as conn:
+            self.assertEqual(
+                conn.execute(sa.text("SELECT COUNT(*) FROM custom")).scalar(), 3
+            )
+
+    def test_list_tables_sorted(self):
+        tables = self.seeder.list_tables()
+        self.assertIn("users", tables)
+        self.assertEqual(tables, sorted(tables))
+
+    def test_repr_contains_url(self):
+        self.assertIn(self.url, repr(self.seeder))
+
+    def test_sqlalchemy_missing_raises_module_error(self):
+        # Simulate missing sqlalchemy by clearing cached engine and patching import
+        seeder = DatabaseSeeder(self.forge, self.url)
+        import builtins
+        import sys
+
+        real_import = builtins.__import__
+        def fake_import(name, *args, **kwargs):
+            if name.startswith("sqlalchemy"):
+                raise ModuleNotFoundError("no sqlalchemy")
+                raise ModuleNotFoundError("no sqlalchemy")
+            return real_import(name, *args, **kwargs)
+
+        builtins.__import__ = fake_import
+        try:
+            with self.assertRaises(ModuleNotFoundError):
+                seeder._get_engine()
+        finally:
+            builtins.__import__ = real_import
+
+
+class TestSeederRelational(unittest.TestCase):
+    """Seed two related tables (parent/child FK) and verify referential integrity."""
+
+    def setUp(self) -> None:
+        self.forge = DataForge(seed=7)
+        self.seeder = DatabaseSeeder(self.forge, "sqlite:///:memory:")
+        engine = self.seeder._get_engine()
+        with engine.begin() as conn:
+            conn.execute(sa.text("CREATE TABLE parent (id INTEGER PRIMARY KEY, name VARCHAR)"))
+            conn.execute(
+                sa.text(
+                    "CREATE TABLE child (id INTEGER PRIMARY KEY, parent_id INTEGER, label VARCHAR)"
+                )
+            )
+
+    def test_seed_relational_returns_counts(self):
+        spec = {
+            "parent": {"count": 3},
+            "child": {"count": 6, "parent_id": {"ref": "parent.id"}},
+        }
+        result = self.seeder.seed_relational(spec)
+        self.assertEqual(result.get("parent"), 3)
+        self.assertEqual(result.get("child"), 6)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/uv.lock b/uv.lock
index 1e9eec1..511d287 100644
--- a/uv.lock
+++ b/uv.lock
@@ -34,6 +34,105 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/f0/0a/c5ce2a48ece0ae2dd050ab28d4cd81b9efc610276a4e72f622582f5371d3/confluent_kafka-2.14.0-cp314-cp314-win_amd64.whl", hash = "sha256:578afb532ded604cb98174a14a88847367191bcbe4f52a1661f5238dc5cf75dd", size = 4290326, upload-time = "2026-04-02T11:28:36.679Z" },
 ]
 
+[[package]]
+name = "coverage"
+version = "7.16.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d1/f5/deb1a27aa20746c0278ac998c4179e272004699b2d33959ce020c5ac1615/coverage-7.16.0.tar.gz", hash = "sha256:077f0964087883176ff6ab9b074694cae29f8c708273b13ca62c183c6ed716cd", size = 945620, upload-time = "2026-08-28T21:54:37.74Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/bc/9c/8d2688694f53dc0b0f0e4783c7eb3c4bb1e79beaf1411879f6dabedf4607/coverage-7.16.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:d1c77c3579ac42798f8b7eed6d3dd258debacca32c8753fc8a1f6eaf1db644f5", size = 223194, upload-time = "2026-08-28T21:51:27.767Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/11/f002163dd688aa3fa49ac6a424b7c2705c7fcf80fba18ec9f586d77827ca/coverage-7.16.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1f81cb1554c3712e41649ed5dc98656b50b958e4da12f0f5adb681ce3db92831", size = 223553, upload-time = "2026-08-28T21:51:29.46Z" },
+    { url = "https://files.pythonhosted.org/packages/81/65/f9d469e97c4554372a710650a109004a2434dfc56f577142e5d6057fa0cc/coverage-7.16.0-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:6e701938ec9081d3e400a0c9a9a8ae0f7ca44214741daeac4454b1c6ef6dbd19", size = 255054, upload-time = "2026-08-28T21:51:31.54Z" },
+    { url = "https://files.pythonhosted.org/packages/95/29/dd89fd39af1a3b6e9a9c3eddeaf03f6376ba517d43d6cbf8b519177e2a10/coverage-7.16.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:719a3feb6220dd32ed932d4c3676d17fb8739e2643b29c0e7c3af400ff80ac44", size = 257790, upload-time = "2026-08-28T21:51:33.374Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/64/208d26cedc525d6b5db9c492cf9130784c42d9eb08d22badaa7b806005ad/coverage-7.16.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:87771ecf986cff55e87413238cd5e4f54d949c2074bd6fc1657d26a56314ee24", size = 258904, upload-time = "2026-08-28T21:51:35.096Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/98/28e2752aa9a8baee5798edade9c95602ca200f4e7eeb503eb64df42e5921/coverage-7.16.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:47d5e1fc0b321c8308a2aacee0497c435b08acaa629b7059798fdf6fc3006352", size = 261165, upload-time = "2026-08-28T21:51:36.744Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/77/fa6ae699a0ea2bc12acb38a85d96b786fea0f833c12b5756056350e0e547/coverage-7.16.0-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:01b18b8a6c9cec8d5f45550e2501426ed982cf2c35016b0acd2ba9b5d8b2fb06", size = 255416, upload-time = "2026-08-28T21:51:38.495Z" },
+    { url = "https://files.pythonhosted.org/packages/89/c8/5ee46d1de7d34cb00ba08b5c50da1971114dbc09ca9898ccc32975ec74dd/coverage-7.16.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:32c56b5b47c50635081445ac404dd08c2d591b9c837c22570aa9e182c3b42cd4", size = 256825, upload-time = "2026-08-28T21:51:40.27Z" },
+    { url = "https://files.pythonhosted.org/packages/15/f6/d59e1c0693ad48855fe20169fbf6ee5befefe5887a7fabf5f0bcb464a2dc/coverage-7.16.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:6ad3bbad240ab937512156bc944fdee63ac4dd34a7558a3094548fd4c1150c02", size = 254970, upload-time = "2026-08-28T21:51:43.136Z" },
+    { url = "https://files.pythonhosted.org/packages/df/7b/b51bbe05b3a7565927fccfb1be42b8b3c1f4ab15e53d91b303e9923969aa/coverage-7.16.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:4c1f16d5555a195295d0dc9c902612270e3dfed6a11f3bf7bc470b7b6a79ed3c", size = 259039, upload-time = "2026-08-28T21:51:44.983Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/04/d513f816456a8a43c1859abe88a37d01d7d2515b6c3e24ebb3c9b1dd44ec/coverage-7.16.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:f6c9c21a8bf0d19788f3c5f3e020c90317a0a63ef60521b376003801e21250fb", size = 254539, upload-time = "2026-08-28T21:51:46.733Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/54/5542190ceb97e0d1333a4ce0c8f95b2ef2efe790f1ad018a4b61766f849e/coverage-7.16.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:06f20145a9eb5bf1fd1dde3c0bc2af2e7c22135ab07ca6284d6ada7cc3904c4e", size = 256410, upload-time = "2026-08-28T21:51:48.363Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/28/78643f361ff6bb5b2ade90f8bfc8395fe9ca367a18c101f8991215b4c65b/coverage-7.16.0-cp312-cp312-win32.whl", hash = "sha256:916cf8d25c1ce148f7eceb1d45afc9724841200110adc4e53250391852debd91", size = 225239, upload-time = "2026-08-28T21:51:50.22Z" },
+    { url = "https://files.pythonhosted.org/packages/67/61/8e76b36c36b1a033dc933dd2480db96b04ce3be975793ce3fad122e7174d/coverage-7.16.0-cp312-cp312-win_amd64.whl", hash = "sha256:78f8b56261d608be102c62edd3a60b66bcd0b581f3f86fdcabaf8b8d95adc950", size = 225775, upload-time = "2026-08-28T21:51:51.912Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/f3/bb4787a4b81c1792ca69b502f5f730dbbb609f73fed552ab074c6b92cb8b/coverage-7.16.0-cp312-cp312-win_arm64.whl", hash = "sha256:577c2ac8c0036f6f8edd3a7783a9e67302b17771d1abf0fd2ed246e3158be51b", size = 225159, upload-time = "2026-08-28T21:51:53.667Z" },
+    { url = "https://files.pythonhosted.org/packages/54/c5/e62c87f4799d1e3647d5b2ae16ea1d12205d72fde1ea8529e13fe050f678/coverage-7.16.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:1545c52ce756b8a97007f439a220297f1cd72a2cbbcdffccdf1c1f70e74f9a42", size = 223215, upload-time = "2026-08-28T21:51:55.628Z" },
+    { url = "https://files.pythonhosted.org/packages/89/e9/5e62fda9397175fb206f75368b6e85da06d831c181b6d0f67ca073cd2f89/coverage-7.16.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:0598aadae641f30a0796b75b45c0b9c5de8619bd5cfb251bb0cc254e86e6dd13", size = 223585, upload-time = "2026-08-28T21:51:57.355Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/40/bede08621b1ba67e88c4d3336c22b52cb7911ff1fa4ef055344b6670e58a/coverage-7.16.0-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:4080ad6bad9f14690e6b2104f5e8d137ccc65a4b5427a36662090637d4bd16d5", size = 254575, upload-time = "2026-08-28T21:51:59.233Z" },
+    { url = "https://files.pythonhosted.org/packages/12/d8/ab0bdaa45dfd6b8cbf1a3ec548fdf827684b1997f9724375c5b3e89144fb/coverage-7.16.0-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:e9883a2f8206ce3af59117dc278e5d043fea06912bca3f199816129e5e2de354", size = 257172, upload-time = "2026-08-28T21:52:01.015Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/bb/135de81784bbd7dfedcab2b92b03d71d75b09b0815b42d6dabb052def5a6/coverage-7.16.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:984e5430fc6f858385009e92549955157d79335b1f3e13e1031e0f89d1284261", size = 258410, upload-time = "2026-08-28T21:52:02.76Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/72/ce44ecc062fb2e43d9447bb76154d091c2139232f20c125297c4b58f4c6a/coverage-7.16.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b1374099dd1ad0d31fbb6c95d00a56a3c5e85fb3343dca14fc12f78323a2b42a", size = 260539, upload-time = "2026-08-28T21:52:04.821Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/c4/9389c36a41e59406ca2bba493807c2294d2e5186a7e9ebcc2e63a0f2a711/coverage-7.16.0-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:34d8686bce035c8465b318a8c2890e69ba14a00801a27f4eb6bdc97c23944d87", size = 254756, upload-time = "2026-08-28T21:52:06.68Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/0f/7762447b15e01fb84263608540123c4d9941f06303265ee74d801ccbec0e/coverage-7.16.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:857fceba6ff4b507ee0ad98798a33d544a8473df0c542bf04251ee4ed5ee6292", size = 256540, upload-time = "2026-08-28T21:52:08.529Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/fa/c60dc75a8346c1dbebebc7279b19971c88f70dd575f0bc10bc0cb16f92d5/coverage-7.16.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:bbf08d951abaa1ce89e28c998361d56b952413846b459cd017f116ad4c9adbfa", size = 254508, upload-time = "2026-08-28T21:52:10.323Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/f0/4e0834f3a1fccaa8bf625a2a1d73bde0fa32577dc3249853c0dd0e7f2b20/coverage-7.16.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:1a03e78f53e4d2ab13adac19958a89322d1829913e5623d642627bf60b35da21", size = 258659, upload-time = "2026-08-28T21:52:12.124Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/ec/fe712d3a11fd6e874565a5fa5497c48b8ece561d9611da040b44cdcf8386/coverage-7.16.0-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:dcd3dafcdd78305d27c59a1006b53a4990acb89e68d8fbe0992f4f83503c827f", size = 254326, upload-time = "2026-08-28T21:52:14.181Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/78/093e12072e01034c65ff380f76c74b79dd83e44fa92b689a2154389be734/coverage-7.16.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:c1bcfe470a796fbea6234accd81d258a31574dc0b7bf569e16be757572c4de17", size = 256102, upload-time = "2026-08-28T21:52:16.003Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/c0/265176117ca5d06e3f65575842884cdda96cf213350a31e9d41c80d65854/coverage-7.16.0-cp313-cp313-win32.whl", hash = "sha256:1420370276f1694b663207b8245c3628aafb9624fe3cebf313a13d860e55ee67", size = 225250, upload-time = "2026-08-28T21:52:17.82Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/01/8a87f2c04fde322430b45d16d8f543693e9894c5b2d2ca238a287c00beca/coverage-7.16.0-cp313-cp313-win_amd64.whl", hash = "sha256:496277c8d7beed695e02c7be53516a0152e4caef8738a0feab6a638546cce449", size = 225790, upload-time = "2026-08-28T21:52:19.641Z" },
+    { url = "https://files.pythonhosted.org/packages/23/40/c21feacd9edfe7063195bf9cc84d650e9938fc6a23063e4f027199b160e1/coverage-7.16.0-cp313-cp313-win_arm64.whl", hash = "sha256:181c2906b9b3759955c1c33c51fbb91c754fbd0b82ea49e2c81061f5a052082c", size = 225180, upload-time = "2026-08-28T21:52:21.613Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/73/850675f262391b322c4c988b6cdc32cdc6629288f0fb158687b587a393a8/coverage-7.16.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:54b7fba6a74d010de34319a0419d5b65af8c00f539ad0b6f39fc6f342ab99697", size = 223258, upload-time = "2026-08-28T21:52:23.558Z" },
+    { url = "https://files.pythonhosted.org/packages/61/c1/4f54c6d47c80d1cc58ef8fe6b74e6eb50f9e2c0f6e2de6cf38dbca2937b8/coverage-7.16.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:fa4ff0b3dd52208d2b30903022d5087f82000507b504753dfeee83e4f32d6883", size = 223587, upload-time = "2026-08-28T21:52:25.627Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/be/298f2456230fb44e272a4e53a41b3f3c39f0821c242d7b7daa9787b4d6f7/coverage-7.16.0-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:35a9676bf86097f790113ebd9fb67681804ef54d40941d2f10ba68c02239e575", size = 254632, upload-time = "2026-08-28T21:52:27.689Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/9c/a1bda6439c19c4783d50df896142b67b9e7d432db36675d339a32778669d/coverage-7.16.0-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:f98d438add63546745e5e847192e3e9ab897ed6f2ca96f8281e2f5a15958ae62", size = 257139, upload-time = "2026-08-28T21:52:29.741Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/cd/cd735c9be757f97237c305f36897a5e5b348bdbc12ebed3b2b80060dd8a9/coverage-7.16.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:151855767480be14db595cbc2040f6a4db965cdfeebd354d79b0256742b029e0", size = 258484, upload-time = "2026-08-28T21:52:31.68Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/04/84b2e1e8aae9db3f549782f28ce25bba5fd6a9c7bfba3782ffe8b4cd2559/coverage-7.16.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:183613f664718b340589d7f005c7e92b4b601cffd20a8a4117cfda3e983b080f", size = 260798, upload-time = "2026-08-28T21:52:33.642Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/4f/e04cf52483619a4dc5dd6367b30c9a8ac52243567fdfacec9b11a441565c/coverage-7.16.0-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:785b114356c99c0dd5b3f57b9696cfd57b7704f4c53847df8dc88c6cc0d9bcb6", size = 254612, upload-time = "2026-08-28T21:52:35.543Z" },
+    { url = "https://files.pythonhosted.org/packages/da/33/627c4113f66bfffd43807f54dbf080c4632ecf12e4ef7a3bdd4ec38e46a2/coverage-7.16.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:30f5aee6d1d517abcdfd4f9cad027969ff79a1440a22da263f9514e31b5b66e9", size = 256495, upload-time = "2026-08-28T21:52:37.485Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/38/aaca432f4e008a88f2bc4d1459aa7016d8d1bbbe801f7e4fa3cf2746557b/coverage-7.16.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:190ffa0f5af966254c249fb3aeaca2cef389785e3e287fd577d39e134d20f8a3", size = 254454, upload-time = "2026-08-28T21:52:39.425Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/db/8430aa87ef0a508f4c17c1b8fa7e0cf80231988d9081aa36c194036592d6/coverage-7.16.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:0ccc37c00e1a5d30840902c54557e104d04aead872cedf6d2281c8725a467e06", size = 258728, upload-time = "2026-08-28T21:52:41.32Z" },
+    { url = "https://files.pythonhosted.org/packages/76/88/cd8aa8c82493ffbd291d3ef5554452fffc634c6c6098a04ac848c79c98f3/coverage-7.16.0-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:6c60cde430c0e7e3be612973af39b4cff90ec2e2defe7b2b701daea3a0ffff04", size = 254271, upload-time = "2026-08-28T21:52:43.278Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/49/fe16c811ea9314a84b48f34e4bf5a3d9013091093b285a74b2272fc863d7/coverage-7.16.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:c5297028c8df849a61b29129cadfe682f90b5b396f528eb319a57d7678eefdad", size = 255927, upload-time = "2026-08-28T21:52:45.461Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/45/d0bd410e78cfbf768acc8099b335e1d5c0d5c26103c796d2bebdee001715/coverage-7.16.0-cp314-cp314-win32.whl", hash = "sha256:136988df5bc5a48795d9c42c75c4bbda5d9a78e750a080c1233010edff93a1af", size = 225424, upload-time = "2026-08-28T21:52:47.658Z" },
+    { url = "https://files.pythonhosted.org/packages/17/78/1ce6ce4646822e9308dcdb1942eaf31bfd7da43247b8886338b0d6fe3767/coverage-7.16.0-cp314-cp314-win_amd64.whl", hash = "sha256:ce2ba5e9f1842fe09165825abfb3bc6b527c71a27bc2eb3a10f2284ced64506d", size = 225918, upload-time = "2026-08-28T21:52:49.692Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/cd/e1323fe3a7dfcdd709451a43fe708ca1dfd36a7fc07b34eb7bd1dfdfb52d/coverage-7.16.0-cp314-cp314-win_arm64.whl", hash = "sha256:a89d07e48d9baead9a15599923a02f62c6df6c3d85aa84ef34be3c9fd6aeb91f", size = 225344, upload-time = "2026-08-28T21:52:51.665Z" },
+    { url = "https://files.pythonhosted.org/packages/39/fb/1c15460d4cf915f09ae3ad3862fef4f901838991c5641b0cec545050d810/coverage-7.16.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:6e2854b62601c89a63814ad5def3b90d99c6724cc4cb977f75b725e5fca4b1e3", size = 223986, upload-time = "2026-08-28T21:52:53.572Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/73/347d2d0009ac211f79ee2a2364fd2aa19d6b9628dc22ed13a9b9386097ab/coverage-7.16.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:f093faf23df888518d273be6da65f0ec5a25b5d8b670231e4d87de07361042e7", size = 224254, upload-time = "2026-08-28T21:52:55.59Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/2f/51442e6ad9d705369596f08496021647e276d5b57311818fd4312d93509b/coverage-7.16.0-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:b7dbbbf6551eb94618e7bc76ab61cc2740a5b3d13294171bd6adb36e12346c3c", size = 265619, upload-time = "2026-08-28T21:52:57.645Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/8e/0f752276f6d13efbd019ab6d90792e20d6272c44cda039dc5c6d27b91e7f/coverage-7.16.0-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:51e7d0e311d2fba3915f971236cbdd4ad821fc7a23988221c0b33c964b0eba22", size = 267734, upload-time = "2026-08-28T21:52:59.611Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/02/4df3baef8029881c9d1a380859f2be73f90080d430def567d182e8566a35/coverage-7.16.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0bb04ee77e557d7476471969d35fbbfb5fc8a4152e9409aa5811780c36d9b23e", size = 270156, upload-time = "2026-08-28T21:53:01.658Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/30/ce10fdb74055ebbfb5c8a025d8845dc19c76e4b2c42bb5c755b56678990c/coverage-7.16.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c72c9b201dc0e8c2c8821d49858fd865010d08181bf877d2320971b6464ebfd5", size = 271279, upload-time = "2026-08-28T21:53:03.698Z" },
+    { url = "https://files.pythonhosted.org/packages/71/19/c7e1fc9504d90da848493bad4018dd235c713a80633e48c5f0a41b63d45e/coverage-7.16.0-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0fca700cae4635656668ba6e2b66a85aac9f2622d7b2bcf82e844c409eaa1313", size = 264677, upload-time = "2026-08-28T21:53:05.741Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/f3/4021519dd41583ab396c81955387f927779641f6bac26818b6918a45aafc/coverage-7.16.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:584896fb8b650e999e24ef57e9513e482c12f8e15a73ee9d4584e23c99465867", size = 267610, upload-time = "2026-08-28T21:53:07.763Z" },
+    { url = "https://files.pythonhosted.org/packages/55/fc/df65aac93938d8f506434c8e96440c1d696f6be0a6a01d3c6bfe5d49403e/coverage-7.16.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:949eae7e0f562b1518355aaef4b03523e49a6d3fea12aa3542d9e36c863f8267", size = 265217, upload-time = "2026-08-28T21:53:09.786Z" },
+    { url = "https://files.pythonhosted.org/packages/32/2d/dc9a5e62715165fcb4c715f965f411e324917c9daeddde16536e9d36ce3f/coverage-7.16.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:64f0611ee05364fc85cc3e5bc371804117a76fd337720e6017332fc7c534257a", size = 268948, upload-time = "2026-08-28T21:53:11.866Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/4e/fe73a5560f25fca52acda76fc1554f30de081793ae4de97e920f8ab161d7/coverage-7.16.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:050a291b3cfe5e0df5999ef2fa5a7aff6e2db329f069d47eb63f02bde2e7e96b", size = 264061, upload-time = "2026-08-28T21:53:13.996Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/f7/bb78cc4b97085ebbd77fa18cbc25abfab462814efa3e2363b4e50885c775/coverage-7.16.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:a336b1e2990a64f5c356a9b8380fb9c029d56c832b801255250c44d603271bfd", size = 266371, upload-time = "2026-08-28T21:53:16.233Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/ec/84b4af5cd4ad498477b3bfb2217e47b048da919451053790efda66f7383c/coverage-7.16.0-cp314-cp314t-win32.whl", hash = "sha256:058631257350b31784ed43ceb808298b6f074edf4ebca4c7ce5082e6bf873a61", size = 225736, upload-time = "2026-08-28T21:53:18.632Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/43/50fc0e6c675c3ef14895a74bab2d6120cb5d6f4b562a3d3f5046797758dc/coverage-7.16.0-cp314-cp314t-win_amd64.whl", hash = "sha256:ed35097438dfa980c1ec75bc83edf8acbe7a374d7007e571957a257fbd0e2fb3", size = 226570, upload-time = "2026-08-28T21:53:20.754Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/24/9effce7bcd3c6eeb4da3561905837509e582dcdde7a7f07d6ef2c8512f76/coverage-7.16.0-cp314-cp314t-win_arm64.whl", hash = "sha256:0466f4a5c0370461b7d8c7eb259d7d1db0b5756f13d66230b04d22a1d380ee11", size = 225879, upload-time = "2026-08-28T21:53:22.747Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/2c/318e4379106bc8047ba235e3732ddc87d1b393ac3db9776f5405ff14f322/coverage-7.16.0-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:80d7d5d744a041f08637df743ac086204ec5acbcd8432a42b00b49e607358024", size = 223257, upload-time = "2026-08-28T21:53:25.376Z" },
+    { url = "https://files.pythonhosted.org/packages/81/4d/a5c54d9144e9db6505749758ba50a28be624148873751728a59cbb72d27a/coverage-7.16.0-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:c5feffce90c3d602e149de1c477578efc34dee5f069f9764cc15808ce01ee15c", size = 223596, upload-time = "2026-08-28T21:53:27.461Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/97/38e93a10899c9315964c0a4e729b3e5867f8f46e977808f9c6fbda52525a/coverage-7.16.0-cp315-cp315-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:acadbf2f2a18d7f9c7f119ac798c00c540d7c79c93abd71ed648c87891303633", size = 254699, upload-time = "2026-08-28T21:53:29.715Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/7a/acddda030b4630f68167f3daa94b41d22071847822a70d8178d43dcf678e/coverage-7.16.0-cp315-cp315-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:4212cec9b42fd9929e70b462732fefd8b13406371871c82f3c14397499d6550b", size = 257614, upload-time = "2026-08-28T21:53:31.948Z" },
+    { url = "https://files.pythonhosted.org/packages/15/7e/225b182497c1ce6d3f0d76a3074a4dbc9f272300e92bb100df53b03de0aa/coverage-7.16.0-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1c5a43cc0ef101637ae920a9eed24cf0549ef815621eae68b3ad577ec5a7ad2f", size = 259236, upload-time = "2026-08-28T21:53:34.291Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/19/76641ddc50cb2410ebbd0ed7fe1052614d0e5612e802a2817521adb9febb/coverage-7.16.0-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c76a9b50a344261fe4a9bd20c322b48d3913cc48e8c37f78c21a596008296e68", size = 261433, upload-time = "2026-08-28T21:53:36.401Z" },
+    { url = "https://files.pythonhosted.org/packages/12/9e/5f89de8b7c2017f36b68b4e4a25940723a748b21474820bf61e8bce0891c/coverage-7.16.0-cp315-cp315-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:80cf547379ad6b1878fd03b033b51188beab4b41824c96e7839e014a4cb947be", size = 255182, upload-time = "2026-08-28T21:53:38.496Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/c1/ce94b2ec502e79775efb5efa22c741ebb0bd2be10bdd29650825ff57bdcb/coverage-7.16.0-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:4b1d09cb5d8dc2c7164450f5217e6f0717497de9c588806a0780d352abef904a", size = 257329, upload-time = "2026-08-28T21:53:40.87Z" },
+    { url = "https://files.pythonhosted.org/packages/86/8d/3f5374df3a6ca19ee5f98a6bd21dbb05f1e9d399bd9978e9821d260eab5e/coverage-7.16.0-cp315-cp315-musllinux_1_2_i686.whl", hash = "sha256:cd1e85abed2d2499c16664137ac802356316f92b4e2bf3c150bdf0c45f5dd9ae", size = 255210, upload-time = "2026-08-28T21:53:43.393Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/b8/1bc5751496d0be6fd9dde8ca547d9a8a9f07847856aba3f3ae5ac594cd81/coverage-7.16.0-cp315-cp315-musllinux_1_2_ppc64le.whl", hash = "sha256:360967a6fd77794c167529eec2d16ff8e38216110619d23acc3fd466a1648bee", size = 259442, upload-time = "2026-08-28T21:53:45.725Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/dc/8aca78e47e1e6fcc761cd28a20daf4a84bd847a7369e2701a93ccfc3d1fd/coverage-7.16.0-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:92cbc2bf4f7f67c79f1d3ca4fe8c50faddf48e852a3d07eaaf02dc014889832f", size = 254618, upload-time = "2026-08-28T21:53:48.292Z" },
+    { url = "https://files.pythonhosted.org/packages/73/fd/787842cdf6ce16ac5c1bd8a26549bab3b3f27b02500075bc540dc7853bca/coverage-7.16.0-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:cce4dc8528453128c6fae523b15f3887fbea1d4d7c9eb9639d3d4fdcbe570c73", size = 256541, upload-time = "2026-08-28T21:53:50.805Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/79/8df302cbef373dd1f3401044cdb94dfc74517e5af2af27b4d0e721557e0e/coverage-7.16.0-cp315-cp315-win32.whl", hash = "sha256:5205baea687133613dced668a3d0168ea1479349615bfc255849a7944988c889", size = 225429, upload-time = "2026-08-28T21:53:53.177Z" },
+    { url = "https://files.pythonhosted.org/packages/85/87/5bad7ac45f76b3728ca211028ee561c2ede3ba44da401129e28bb8737291/coverage-7.16.0-cp315-cp315-win_amd64.whl", hash = "sha256:4fcb5f07a9b7083bfb715115d27ce263ba2b5b89dddeee536b295ba0e3c2c627", size = 225903, upload-time = "2026-08-28T21:53:55.535Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/ea/67d84b11caf240f059ec313f616d82212df5004e8bc85802c1edfc50bb3d/coverage-7.16.0-cp315-cp315-win_arm64.whl", hash = "sha256:d568a8adcec0eda42ec23e5e65dfb8c184fc255120f9e99b484f7c869d923fb9", size = 225334, upload-time = "2026-08-28T21:53:57.769Z" },
+    { url = "https://files.pythonhosted.org/packages/65/21/a88349cce3ff720729b754916ac47e2e3646a8137552e4fa7cdd5967cc7f/coverage-7.16.0-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:3e8037e8213adf882e9d7eedd2c5c557933ab0b9632c42d98fe98ec9bcdb4025", size = 223980, upload-time = "2026-08-28T21:54:00.082Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/02/4d54abf3e6a4d8b7675921b20e91163b1064a5a9dbefebb71c05065dd136/coverage-7.16.0-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:289f2ed4d56eebf029b649e7dfc3c1153b111962a75e294cdd8e4a1598a04cc3", size = 224276, upload-time = "2026-08-28T21:54:02.381Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/39/10dbc96d95d20b9b041045d293480bd49e536180e93af62dd7662376284d/coverage-7.16.0-cp315-cp315t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:9b83f6ac575530783771c8dcf05284f7c8b5b12f1e7cb226d63445aac4497a3a", size = 265135, upload-time = "2026-08-28T21:54:04.558Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/3b/6b326544afd1a8aef3a495bbae109a7ab5baf23e04a2741d8d64e2df2ba2/coverage-7.16.0-cp315-cp315t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:2c3ff6580f2dfc5bec34717b85b2e6cf5ec993b721e7bb58a794babd525a8178", size = 268216, upload-time = "2026-08-28T21:54:06.97Z" },
+    { url = "https://files.pythonhosted.org/packages/54/34/1dc8265f3ed990690e24d5f31ff79bc9fb9b25d54f9f89bebad5a6a8b7a1/coverage-7.16.0-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:507596cee23e9968b1934fe86d799b76166541af0a293930918b1b48a5c84bd2", size = 270772, upload-time = "2026-08-28T21:54:09.234Z" },
+    { url = "https://files.pythonhosted.org/packages/66/a7/3a8463713a402b44044ec832f4a76e442ce4b3a207804303f4d1dc1a9bb4/coverage-7.16.0-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:edc2be98e6c55ccc5ff7832bb64f023a4b03dba39dfa84b850046cf08a8249b0", size = 271752, upload-time = "2026-08-28T21:54:11.701Z" },
+    { url = "https://files.pythonhosted.org/packages/25/3b/dd5e795cfbe1842f69899189089ae289a96d6a68de312960ea668542e33c/coverage-7.16.0-cp315-cp315t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:9c0690994b84a15a53bdd39e0b2fdb539b22533820623eb86ba75b93760c645b", size = 265589, upload-time = "2026-08-28T21:54:14.12Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/b6/fd90636cbd95cb018312f6ca1ca2bbd70fbe8e4ee6f3992fc36a4230364e/coverage-7.16.0-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:de24c62bf798940a14674a47489a81b79915ec4134f556d5199830e065225dd0", size = 268596, upload-time = "2026-08-28T21:54:16.303Z" },
+    { url = "https://files.pythonhosted.org/packages/91/10/ef2d59264f3b3b358cc5885ca375e6cdbda7c195e78304d5aae800a72d9d/coverage-7.16.0-cp315-cp315t-musllinux_1_2_i686.whl", hash = "sha256:69474d81f198774c9d2937599ca5da04c9e1c5de5032da23c607ce4960ce360e", size = 265072, upload-time = "2026-08-28T21:54:18.597Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/5b/400891c364c0170408d172501b340b18611800f4c42d8fbb16f9f5497c24/coverage-7.16.0-cp315-cp315t-musllinux_1_2_ppc64le.whl", hash = "sha256:72a0795cc6d34acc2b03dfeabdc82b61b72087f2737018b56ac92c1cf5446c54", size = 269768, upload-time = "2026-08-28T21:54:20.985Z" },
+    { url = "https://files.pythonhosted.org/packages/98/93/9792c80271df04d287d21ed5d662fd8fa58b1737888d817679b1ce5d2fab/coverage-7.16.0-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:d9a218d3f9c7d6916684ed5ba94f620661117a730e733cd6ef5e87accc5872eb", size = 265211, upload-time = "2026-08-28T21:54:23.344Z" },
+    { url = "https://files.pythonhosted.org/packages/81/67/5b8f827cfa6616e6bd7ba9397acfe7e3c4fd5b9fca4125511d5089f55d5a/coverage-7.16.0-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:49fa72ead28c8216f8916398a4f3c4669acb30a061822810ee20a727a1be2897", size = 267170, upload-time = "2026-08-28T21:54:25.85Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/ee/c135d2d2cb617d744bc3e13c922f2fae66964494176ddef225dc4656bd2c/coverage-7.16.0-cp315-cp315t-win32.whl", hash = "sha256:27461af9f3ed7d2cf2411eb083784f87055ebf42211789ae3a216c48609bc743", size = 225731, upload-time = "2026-08-28T21:54:28.151Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/4d/dc3d53eadf155916e183bf5dfacbfc4aa5bfb7f13b7da11c01caa7a05cbc/coverage-7.16.0-cp315-cp315t-win_amd64.whl", hash = "sha256:c5612cc20ca76abc883e50269af47c1494b42958bb63dbb9aa79729a1ab5f7d3", size = 226562, upload-time = "2026-08-28T21:54:30.42Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/00/ac9da1a60a4e84c3ad0f7db4723fd327154a8f9add210c0dcd2db3ec5156/coverage-7.16.0-cp315-cp315t-win_arm64.whl", hash = "sha256:2ddaa9e2af4760a329d80008b7a3b4762fbb0dbcb169199360f9a5179c32f2dc", size = 225872, upload-time = "2026-08-28T21:54:32.806Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/5a/234e8fadf85c3cc48cb31c247b9e8e0c7f06ece80f5b29f9b8c241f9da4c/coverage-7.16.0-py3-none-any.whl", hash = "sha256:245f7de6d023a5bba375dbec9f2e0869bfa26ac0cc639bbb7b4c814884000b73", size = 214977, upload-time = "2026-08-28T21:54:35.189Z" },
+]
+
 [[package]]
 name = "dataforge-py"
 version = "0.5.0"
@@ -61,9 +160,13 @@ tui = [
 
 [package.dev-dependencies]
 dev = [
+    { name = "hypothesis" },
     { name = "pytest" },
     { name = "pytest-asyncio" },
+    { name = "pytest-cov" },
     { name = "ruff" },
+    { name = "sqlalchemy" },
+    { name = "textual" },
 ]
 
 [package.metadata]
@@ -81,9 +184,13 @@ provides-extras = ["kafka", "rabbitmq", "tui", "db", "all"]
 
 [package.metadata.requires-dev]
 dev = [
+    { name = "hypothesis", specifier = ">=6.0" },
     { name = "pytest", specifier = ">=8.0" },
     { name = "pytest-asyncio", specifier = ">=0.24" },
+    { name = "pytest-cov", specifier = ">=5.0" },
     { name = "ruff", specifier = ">=0.15.4,<0.17" },
+    { name = "sqlalchemy", specifier = ">=2.0" },
+    { name = "textual", specifier = ">=0.40" },
 ]
 
 [[package]]
@@ -125,6 +232,78 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/29/4b/45d90626aef8e65336bed690106d1382f7a43665e2249017e9527df8823b/greenlet-3.3.2-cp314-cp314t-win_amd64.whl", hash = "sha256:c04c5e06ec3e022cbfe2cd4a846e1d4e50087444f875ff6d2c2ad8445495cf1a", size = 237086, upload-time = "2026-02-20T20:20:45.786Z" },
 ]
 
+[[package]]
+name = "hypothesis"
+version = "6.167.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "sortedcontainers" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c2/c9/8cee74c1390b2932406faaab76980f18946f258fa5a8afca17189b3bc655/hypothesis-6.167.1.tar.gz", hash = "sha256:62eefcb4d2791423626e9901c3027a6e0c5ffda2ac0b44b3c7e797ab9d2d5a4c", size = 505849, upload-time = "2026-08-30T19:53:09.05Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/53/4d/3592ca336deafbd3e9b0f47dc4c727aa32d30e765ef6370da8ecd590d388/hypothesis-6.167.1-cp310-abi3-macosx_10_12_x86_64.whl", hash = "sha256:d28118fd70e4e15ff9c308a98b312b544b6145ae45aaa3b566328c1fdee8058f", size = 785476, upload-time = "2026-08-30T19:51:02.154Z" },
+    { url = "https://files.pythonhosted.org/packages/18/bf/e33c431148994cbcb3332c6df94b833ecfb4aa6a8e51ea4b83da55ddd581/hypothesis-6.167.1-cp310-abi3-macosx_11_0_arm64.whl", hash = "sha256:e517be7f82a0a917758cc489a88b826b5371f56381fd94b4a8a09ce82d8de406", size = 781033, upload-time = "2026-08-30T19:51:27.314Z" },
+    { url = "https://files.pythonhosted.org/packages/94/a3/e0de9a82c7e790a1def0801076e0ef43110f98e95ed54a3554877d0cb66d/hypothesis-6.167.1-cp310-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:26f8cec74c4fad7aeb0852cb34c2134b16db05d878ad3946a53337dace7016f4", size = 1117814, upload-time = "2026-08-30T19:53:04.109Z" },
+    { url = "https://files.pythonhosted.org/packages/71/a4/8dd6bdc909324d1c39da1c86d65f75512ae049c159952af4cfe8feb5f8d4/hypothesis-6.167.1-cp310-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:fd202d02d129197a5e771f8a11c7d30559927284c23ec3a8bd4f37a7955964d1", size = 1141639, upload-time = "2026-08-30T19:51:50.399Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/bd/c13ed6145c360d0770415efd7d5a7e63c29905aeef52ab88004fe7e7f924/hypothesis-6.167.1-cp310-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8b1e393ab01b71f683ba2a783785871cc6b81a6e41017780c64a5bc0b99759ae", size = 1143334, upload-time = "2026-08-30T19:50:38.045Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/a8/060d79ed8504b54ced9ad16f33d674b1b98a9debe9733c02709d7dd5c71c/hypothesis-6.167.1-cp310-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8c385c7741893404306f9e5559ab3835432e85e7c153e25f854c502c410bbcbb", size = 1163345, upload-time = "2026-08-30T19:53:06.583Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/f7/6e68e2b705f729a6f7b4f41030022b1a5264c5434d3bcd917233d6801c6a/hypothesis-6.167.1-cp310-abi3-manylinux_2_31_riscv64.whl", hash = "sha256:94920ca1fae70c26b0bd3fabbeef9437ffc17a39fe85696fb9a86187d92f6dba", size = 1123029, upload-time = "2026-08-30T19:52:03.134Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/c0/d274fe37ed5ecd5ad8ed555edc1f5e2abc8e1c3be3d5404b7edd5cc353a8/hypothesis-6.167.1-cp310-abi3-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:b8d90ded2ffdc7e56b5e571993f384b52fade0a7b424e614f999cc2491789970", size = 1154003, upload-time = "2026-08-30T19:50:55.053Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/2f/2b5bb386f43fc965eb86fd69fcb2bd62c08cb6d7c6708a40dc39b3b97440/hypothesis-6.167.1-cp310-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:40cd5de7dd252942a08480639f5850594b1aca4a463e8a7f15e1fb6c2c3760c1", size = 1293729, upload-time = "2026-08-30T19:52:59.481Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/32/22436b072d79011fe81abb933edcd2476057c7b971588c5f3caf07519a88/hypothesis-6.167.1-cp310-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:b9c33f921ddc7fea93660eca408b25fe755516e22ec7ab21cb9951031f1cd608", size = 1419248, upload-time = "2026-08-30T19:50:52.903Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/3e/abf39faaff0f78112112a82316a5c9fe472574480c1ecee526734775b812/hypothesis-6.167.1-cp310-abi3-musllinux_1_2_ppc64le.whl", hash = "sha256:495989cf0a5ee03f7f9598ee9efeaabf15fd861ec52b5a9d6435849453e17e5d", size = 1274903, upload-time = "2026-08-30T19:52:27.25Z" },
+    { url = "https://files.pythonhosted.org/packages/29/83/69b89ed5692ba3aad117facfb9ce099633a22c35acc3d64829b72253ec8c/hypothesis-6.167.1-cp310-abi3-musllinux_1_2_riscv64.whl", hash = "sha256:bc73c46ce8ff93b0eb220f2b75adcbd9fcc9112078a74d3522d2532ad8069bad", size = 1294185, upload-time = "2026-08-30T19:50:35.038Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/1e/55dfcbe45c72df0a5c5b86a6b7c9365121acab69c2cc060bd55336a48c8f/hypothesis-6.167.1-cp310-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:36e83e1d7e97aaacbf6cd778e14a841344f848a674b20dfe4fe997546a6a2151", size = 1330013, upload-time = "2026-08-30T19:52:54.841Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/a6/0a36cead4ccff58bedb5d1aa2f894f7a580c317424b4fa788c6b22232b2d/hypothesis-6.167.1-cp310-abi3-win32.whl", hash = "sha256:fb4d87454d2459c2ccb541a4c61c92ce13058b91305ed3304695a409a1d886e4", size = 671942, upload-time = "2026-08-30T19:51:32.732Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/5b/360285ed42109f5ef48d98ca9ffcf71d1477130c0ff1f1a8d535c8507259/hypothesis-6.167.1-cp310-abi3-win_amd64.whl", hash = "sha256:5e35f98b427bf438a946203426b485dd5b62485f3d5a69a0e0862870a545e518", size = 678637, upload-time = "2026-08-30T19:50:33.573Z" },
+    { url = "https://files.pythonhosted.org/packages/79/2d/cc084c1a8bfa296048ec0461f0fa11731abe0097f5c2310c8d39d94c8dc4/hypothesis-6.167.1-cp310-abi3-win_arm64.whl", hash = "sha256:dd6a0808a2eb8b5b1ac06bca4244eee18ed2c0e7b105599e1662203d164317b5", size = 676657, upload-time = "2026-08-30T19:51:34.494Z" },
+    { url = "https://files.pythonhosted.org/packages/72/82/07987292cfb59c73ce6574e2912c015f678d5aa4d8c0712b78ae4415a535/hypothesis-6.167.1-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:1937ae4e23f7dde6d4202d3d08c2633bcd535a091bdf866b8799abaabcb1e6f0", size = 787050, upload-time = "2026-08-30T19:51:10.782Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/e9/0d37051bec44ec433d87da03c9a7fe389b1b58210790c1f166af249bf941/hypothesis-6.167.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1434bbd25d05aaf75c4e6829b4cad8e9931b690f840d92b747b2e6e5af575922", size = 778617, upload-time = "2026-08-30T19:50:31.939Z" },
+    { url = "https://files.pythonhosted.org/packages/13/2a/60c18a493215c22c9cfcb4574b381497bd1971eed9fb5f9831b26e73cffb/hypothesis-6.167.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:af3c09428e553b1dd2f9abbc4738377c58bf6d74cb0b8b528cc1dde3a9cdfbe8", size = 1116743, upload-time = "2026-08-30T19:50:49.293Z" },
+    { url = "https://files.pythonhosted.org/packages/12/1f/b6796f11d6502e0b1764aec99f2792ca60382b6a45e26bbe163dc5757980/hypothesis-6.167.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:04f807b85d425a7005e8a24498ca832bf5590f0d306737471d94c842569cecef", size = 1162718, upload-time = "2026-08-30T19:52:47.544Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/6c/e3cf35474b799e299fa08980b6756f500d730781686916ab65f87cbc0613/hypothesis-6.167.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:803c6a98ff66cee4caf03245bfd00e442a907264031b994a3a650dc6e4786f51", size = 1292417, upload-time = "2026-08-30T19:50:56.822Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/4c/875803c80c373a1628f8eb62f215ad23ce7b50ed61f884d6be0838ebea4a/hypothesis-6.167.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:21a7122ddf072906083e3704fe3961ecbc49d7d30a9b51bcd525d977b3afe65e", size = 1329035, upload-time = "2026-08-30T19:51:46.659Z" },
+    { url = "https://files.pythonhosted.org/packages/90/a8/a8daed3796623884471dc0ee8ed63917b1e2b979b4074bcea19a964fcd71/hypothesis-6.167.1-cp312-cp312-win_amd64.whl", hash = "sha256:a2837c60d782eb0b8a910c541264675b9d11486e186af8c82a5e2920b5fe4fe8", size = 675966, upload-time = "2026-08-30T19:51:56.58Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/44/dca7b211804f60c789aced2792b1e7803ccd8b70b79041cbb92788df5d19/hypothesis-6.167.1-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:6478d19a7887731cc2afaa1ec15f62811c9ceb6fd18e5b7563e0a18399a9528f", size = 786947, upload-time = "2026-08-30T19:51:29.165Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/6a/3cffa138492c9e3d5f98f4ff8b467273dc87af6ca3c18084272d106bde10/hypothesis-6.167.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:8f13167a4b81c93e7e051d1f02790814a6495fb79cacf3fb89560a796a2f7d00", size = 778584, upload-time = "2026-08-30T19:52:25.091Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/7d/e8039791aaca3b21557bc520a71cdb88751892f66fd1a0a459b59872e463/hypothesis-6.167.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5ef7dd225f7df7d74d1c5a905592cd8b4cd348e6be639b189a43def8b0b5dd79", size = 1116749, upload-time = "2026-08-30T19:52:38.178Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/b8/f9b8d93bd6178870f0daa868ca99915f6d9df1f99dc7291e9ce2743a6dc5/hypothesis-6.167.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7d7585429f2263d3ceeb3474bae3871024630a7a598e71eeb4b0dcf03e291623", size = 1162599, upload-time = "2026-08-30T19:52:11.72Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/0d/53d419094e6f8a7e7377c09de15ac23f842ab698ff07241f7b73e19bd559/hypothesis-6.167.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:fb9194f450417cf35f66b6c72737cc6b8f21f20567ba4d39822c64f0d1075784", size = 1292230, upload-time = "2026-08-30T19:52:49.732Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/df/cf4c482323ae4f06b5326b5bdd89cf17d8232fdb3186c9913e0b19a5fa58/hypothesis-6.167.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:c63a0d292a5dde3c0fe999892e76d8375a003ca40c0c00d763f3360f91be5b96", size = 1328899, upload-time = "2026-08-30T19:51:05.366Z" },
+    { url = "https://files.pythonhosted.org/packages/49/05/780c4b0396491d294fda69a541cb1dedb37fb9eb2e3a696e85fe19064c40/hypothesis-6.167.1-cp313-cp313-win_amd64.whl", hash = "sha256:ff07f98a0b230632bb2836b5dad3e94d85c114ae155a316afd251c58760958ae", size = 675927, upload-time = "2026-08-30T19:50:58.472Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/f1/1e602f090dcb7e38655f1f7909482742891332275fc01f241e255cdfa514/hypothesis-6.167.1-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:fcfc2a78fc1025644f889a74684b3201f4652ce8e6694c2a01af0f100d0348cf", size = 787054, upload-time = "2026-08-30T19:50:40.88Z" },
+    { url = "https://files.pythonhosted.org/packages/52/57/cfa930719c7af5a33627abba826a3fa2efa61a5f23e38d4111eace5dfe53/hypothesis-6.167.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:769bdd9aa0af08c063327730ab6dc18b7a23837a2912f2aeaab3912f11a7e3ad", size = 778721, upload-time = "2026-08-30T19:50:36.503Z" },
+    { url = "https://files.pythonhosted.org/packages/01/37/4c4bc3d319eac85bfe17515c9786bf49e57181ca8757886110d2cfb13d10/hypothesis-6.167.1-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d75d44bdead6679b6ee9a7c90d10207db865ca0c77c5212103b5ff421379f99e", size = 1116972, upload-time = "2026-08-30T19:51:52.472Z" },
+    { url = "https://files.pythonhosted.org/packages/33/45/0d61ceef2739e7b96ea1faa0f3d5aa5917c8156797993bf3acbadfcd7f0a/hypothesis-6.167.1-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:742be00d7bb53d10634e6435e5b98f51fcdbe7ed377d473ab7387d9499c87169", size = 1162776, upload-time = "2026-08-30T19:51:09.084Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/cf/756666ce2262e90fd61fec41a95548cceab94b0669381d8f0387cd89af93/hypothesis-6.167.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:b6fcdc8d03b37a902262be13112d113bb4ac87edf3b08afb47f3d1210deb038a", size = 1292748, upload-time = "2026-08-30T19:51:17.22Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/b4/87eb3c695d6c37fb44f4d49f9faa2033af496e24965658942a1706e22620/hypothesis-6.167.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:e56e7841514276c308c2bb4d033cf01860d0fc8c76e2b79ce748a9f123eaf83b", size = 1329101, upload-time = "2026-08-30T19:51:36.313Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/3b/87faa4a86533eaaa19037741fb9cdde8647f7ffdf8fd4279828ac9d81f8b/hypothesis-6.167.1-cp314-cp314-pyemscripten_2026_0_wasm32.whl", hash = "sha256:bbf4f0cad201d0b8e821e82ad828b2aec99ce6d9967779eecb2cad4d4a93debd", size = 618079, upload-time = "2026-08-30T19:52:43.226Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/46/96b7ac9605887447d267b4b3a9ecf61c6caaabf39eef667173b0cc9222b3/hypothesis-6.167.1-cp314-cp314-win_amd64.whl", hash = "sha256:3e04f6001299708b6fd4512267b189c0b029ef1e34500deb4e4c9639023598d7", size = 675812, upload-time = "2026-08-30T19:52:52.298Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/f6/0337a91c50ce4be323c3d6aa852fcf08199ffbb1072da09fbe6d602f4dfe/hypothesis-6.167.1-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:47c99256df28555ecc2aed0e22ca17cd61c63c8c44207a07b4e402cc49661fae", size = 785525, upload-time = "2026-08-30T19:51:03.637Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/08/9bb52de855169d31888c7033ee2f94b94138fde021c1af9dbc7ba5e83cd5/hypothesis-6.167.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:5d6614e88fd267bbd870e3ec02f8a5387897d2d573626a02f5ac06d81533afa6", size = 777142, upload-time = "2026-08-30T19:52:18.472Z" },
+    { url = "https://files.pythonhosted.org/packages/85/79/f1a7e088e13a641357abb9b43d75c116c2a0902711b1a25a203864b96c9b/hypothesis-6.167.1-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:27829aa89fe2e47c5c8d13b3ce31e0f53a01a98f76a4f99cfa3369ab35362f33", size = 1115311, upload-time = "2026-08-30T19:52:40.975Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/38/e28b1fc20bd3d67d43cf1aab7a15daa2a24ec01d17a153e82fcf38c882f3/hypothesis-6.167.1-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e936777d92ae27393b4a941839bbb43c1f339b5a0e394c7f3730454cdf091b3a", size = 1161238, upload-time = "2026-08-30T19:52:20.501Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/de/9b4fc7992166299e0fc5c13c8766919ae57d0fb9eed5319b7a3bad4f2f17/hypothesis-6.167.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:971ce0d8a367a37c4690b83a2e7f6ef832fa3543357eb6da0da27ba078e5088a", size = 1290974, upload-time = "2026-08-30T19:51:15.673Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/79/ca086eea02588212ab796ee4bd7fe6ed514e10d1a99967e478691608e8d9/hypothesis-6.167.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:af84ce2416be2a65bc0ea18e64d2dbb9796b7692593b5b2064d60ea1d52ec1e2", size = 1327969, upload-time = "2026-08-30T19:52:35.846Z" },
+    { url = "https://files.pythonhosted.org/packages/26/79/1875380fa30e8411553e76b3e9695aca0845f9f265523f20f879bdea2b82/hypothesis-6.167.1-cp314-cp314t-win_amd64.whl", hash = "sha256:3b596efec5bd714588e3bb269544d993c5258c979f3a26f51fadf62c215d0e68", size = 675735, upload-time = "2026-08-30T19:52:22.821Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/45/59abecd75e52b9dfb5b3eb991276f54954c44917a1c83d148cfb3580bd39/hypothesis-6.167.1-cp315-abi3.abi3t-macosx_10_12_x86_64.whl", hash = "sha256:c25c556d51d55d94988dc0a2c716d471ff19cf9632cd33f5e6db2914d802428a", size = 785097, upload-time = "2026-08-30T19:51:12.528Z" },
+    { url = "https://files.pythonhosted.org/packages/01/7c/e6d978dc9564ba70352da60c00f55f6ad7d66d99ecbf336a228978206cb4/hypothesis-6.167.1-cp315-abi3.abi3t-macosx_11_0_arm64.whl", hash = "sha256:b57e950f9d5c93ca335bc612e8fa8fb49abb187c3fc9d5e7d9966d52eb27d747", size = 776798, upload-time = "2026-08-30T19:50:47.247Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/a4/f8ecedcf96790aab69d750afe3fcbf503229d0bb4e0c32be655385a4fc8c/hypothesis-6.167.1-cp315-abi3.abi3t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0807ae8d399162827fc1c396ab4c697a41921c2a2baacfada439771e9dc2b867", size = 1115116, upload-time = "2026-08-30T19:52:16.029Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/97/8bca7c262ac4fcb1ee684c04e4ba75f26541d3a30417e3743d19912d257e/hypothesis-6.167.1-cp315-abi3.abi3t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:546fef39c7aadba74bf3e592585694a71340d1775e9b3274bb3f94106dbde4b7", size = 1137812, upload-time = "2026-08-30T19:51:25.507Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/07/9cb4a7fc2aa2b2ad063b446c378f0d7acfa5303e84afd1b1374ba23fd6f3/hypothesis-6.167.1-cp315-abi3.abi3t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a17a5618b6a5b84f17c8acb3bce37122647cf7a3e48b660a39d68a773bd627dd", size = 1140384, upload-time = "2026-08-30T19:52:05.264Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/18/813bf7efa18f11ce938a0da22a7518a54db46d4a181ebf4cb0a8061c263f/hypothesis-6.167.1-cp315-abi3.abi3t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0ff5ad833480c1e34ae902cb52fc00802b08ac6c87bd22d7e5f04fd925869608", size = 1160569, upload-time = "2026-08-30T19:51:40.099Z" },
+    { url = "https://files.pythonhosted.org/packages/52/1d/6658d9294ed33bb17da4acf06fe63b010b205ea1861f6921c38060793255/hypothesis-6.167.1-cp315-abi3.abi3t-manylinux_2_31_riscv64.whl", hash = "sha256:630eb37df80b5bc4ec6f391b13caaecc06942ff5da3aadebacf85f53bbc55757", size = 1120605, upload-time = "2026-08-30T19:53:01.848Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/81/a75821c0e879223a2635b8eded84ae874cb6c711b23e9930668008d0b13f/hypothesis-6.167.1-cp315-abi3.abi3t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:bc4e65f7c43b187f7a40964706b5ded1073e0c1839e9fb5e041d7ed973bb65fe", size = 1149479, upload-time = "2026-08-30T19:51:30.972Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/f2/c8c3faf4ec796d6dbf36b84662806696434aef38616e5a65b46188c04262/hypothesis-6.167.1-cp315-abi3.abi3t-musllinux_1_2_aarch64.whl", hash = "sha256:e849f518cbc4e76ab15f2f1473c60dd3103da8d32399187325ceb84309105976", size = 1290423, upload-time = "2026-08-30T19:50:51.114Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/e3/e0903abe7e8634cedb5414931452e82daacdd3b8b46d6348bbefcaa45f2a/hypothesis-6.167.1-cp315-abi3.abi3t-musllinux_1_2_armv7l.whl", hash = "sha256:5c5a26d4d3dca0c84e01bde41df4cabaa5a373c7393f9eef372d19fe93b07ccd", size = 1415749, upload-time = "2026-08-30T19:51:48.456Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/9b/03f09c1ecac1dfb0f4cd7fcc6dc50d9c6ea8067b295a728e242650bafe32/hypothesis-6.167.1-cp315-abi3.abi3t-musllinux_1_2_ppc64le.whl", hash = "sha256:4819adbc5911648f6bfaeb574f276add184b4b49f54731dbde46fd71256bb157", size = 1272086, upload-time = "2026-08-30T19:52:29.368Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/7c/7a63bfc0bfbaf000f71352c4faac72ff611376330a2ce2e9a1bf4668848a/hypothesis-6.167.1-cp315-abi3.abi3t-musllinux_1_2_riscv64.whl", hash = "sha256:3ad7206de9c398c8da5745b69b5ba2ef45100082eeb174656490bc4f262b112c", size = 1291553, upload-time = "2026-08-30T19:52:07.545Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/5c/8065bdab53bc81743ca68fc76ca53fc7531a5b3f01c0de4ba40467955d6a/hypothesis-6.167.1-cp315-abi3.abi3t-musllinux_1_2_x86_64.whl", hash = "sha256:96d5e8017a9508f06c8a61a6130cb0d0b4810847ed5c76923cb5cfb9952b31af", size = 1327734, upload-time = "2026-08-30T19:51:42.306Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/a0/5c15d480aea3a8e6e5c17c7cb1170171707ac643ffd319473bc194743ad8/hypothesis-6.167.1-cp315-abi3.abi3t-win32.whl", hash = "sha256:a4e4de36a397cba49d949d89cbc26135977c15f9d797caa95317962ceb5b5674", size = 669115, upload-time = "2026-08-30T19:51:14.192Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/36/4cf494bc96384189fedb7d3f272580315f2284a9f8a7f6a59796612eb76d/hypothesis-6.167.1-cp315-abi3.abi3t-win_amd64.whl", hash = "sha256:f6fe9c40ab14def363d9e7ab22863fa31652bd5e08f8495b34ff7bd0062b3f8d", size = 675438, upload-time = "2026-08-30T19:51:06.881Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/7f/db1a37e5f45be32c0e64f9ed1268eba56aeedcb2ef20d195fa60c6610347/hypothesis-6.167.1-cp315-abi3.abi3t-win_arm64.whl", hash = "sha256:627ce3bd166799a6c0ddcf1351049be5b9a772d5bce436216d42b41a935f42c0", size = 673123, upload-time = "2026-08-30T19:52:13.991Z" },
+]
+
 [[package]]
 name = "iniconfig"
 version = "2.3.0"
@@ -258,6 +437,20 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/e5/35/f8b19922b6a25bc0880171a2f1a003eaeb93657475193ab516fd87cac9da/pytest_asyncio-1.3.0-py3-none-any.whl", hash = "sha256:611e26147c7f77640e6d0a92a38ed17c3e9848063698d5c93d5aa7aa11cebff5", size = 15075, upload-time = "2025-11-10T16:07:45.537Z" },
 ]
 
+[[package]]
+name = "pytest-cov"
+version = "7.1.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "coverage" },
+    { name = "pluggy" },
+    { name = "pytest" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b1/51/a849f96e117386044471c8ec2bd6cfebacda285da9525c9106aeb28da671/pytest_cov-7.1.0.tar.gz", hash = "sha256:30674f2b5f6351aa09702a9c8c364f6a01c27aae0c1366ae8016160d1efc56b2", size = 55592, upload-time = "2026-03-21T20:11:16.284Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9d/7a/d968e294073affff457b041c2be9868a40c1c71f4a35fcc1e45e5493067b/pytest_cov-7.1.0-py3-none-any.whl", hash = "sha256:a0461110b7865f9a271aa1b51e516c9a95de9d696734a2f71e3e78f46e1d4678", size = 22876, upload-time = "2026-03-21T20:11:14.438Z" },
+]
+
 [[package]]
 name = "rich"
 version = "14.3.3"
@@ -296,6 +489,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/3e/0a/9e1be9035b37448ce2e68c978f0591da94389ade5a5abafa4cf99985d1b2/ruff-0.15.4-py3-none-win_arm64.whl", hash = "sha256:60d5177e8cfc70e51b9c5fad936c634872a74209f934c1e79107d11787ad5453", size = 10966776, upload-time = "2026-02-26T20:03:56.908Z" },
 ]
 
+[[package]]
+name = "sortedcontainers"
+version = "2.4.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e8/c4/ba2f8066cceb6f23394729afe52f3bf7adec04bf9ed2c820b39e19299111/sortedcontainers-2.4.0.tar.gz", hash = "sha256:25caa5a06cc30b6b83d11423433f65d1f9d76c4c6a0c90e3379eaa43b9bfdb88", size = 30594, upload-time = "2021-05-16T22:03:42.897Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/32/46/9cb0e58b2deb7f82b84065f37f3bffeb12413f947f9388e4cac22c4621ce/sortedcontainers-2.4.0-py2.py3-none-any.whl", hash = "sha256:a163dcaede0f1c021485e957a39245190e74249897e2ae4b2aa38595db237ee0", size = 29575, upload-time = "2021-05-16T22:03:41.177Z" },
+]
+
 [[package]]
 name = "sqlalchemy"
 version = "2.0.48"