tomlrange 0.2.1__tar.gz → 0.2.2__tar.gz

{tomlrange-0.2.1 → tomlrange-0.2.2}/.github/workflows/bump-version.yml

@@ -95,25 +95,14 @@ jobs:
             exit 1
           fi
 
-          python3 -c '
-          import os, pathlib, re, sys
-          path = pathlib.Path("src/tomlrange/__init__.py")
-          text = path.read_text()
-          ver = os.environ["NEW_VER"]
-          new, n = re.subn(r"__version__ = \"[^\"]+\"", f"__version__ = \"{ver}\"", text, count=1)
-          if n != 1:
-              sys.exit("did not replace src/tomlrange/__init__.py __version__")
-          path.write_text(new)
-          '
-
           git checkout -b "bump/v${NEW_VER}"
 
-          git add pyproject.toml src/tomlrange/__init__.py
+          git add pyproject.toml
           if ! git diff --quiet -- uv.lock; then
             git add uv.lock
           fi
           if git diff --cached --quiet; then
-            echo "uv version did not change pyproject.toml, __init__.py, or uv.lock" >&2
+            echo "uv version did not change pyproject.toml or uv.lock" >&2
             exit 1
           fi
 

tomlrange-0.2.2/.github/workflows/ci.yml

@@ -0,0 +1,26 @@
+name: CI
+
+on:
+  push:
+  pull_request:
+  workflow_dispatch:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7
+        with:
+          persist-credentials: false
+      - uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
+      - run: uv sync --group dev
+      - run: uv run ruff check
+      - run: uv run ruff format --check
+      - run: uv run pytest

{tomlrange-0.2.1 → tomlrange-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: tomlrange
-Version: 0.2.1
+Version: 0.2.2
 Summary: Parse and validate { from, to } tables from decoded TOML.
 Project-URL: Homepage, https://github.com/yyolk/tomlrange
 Project-URL: Repository, https://github.com/yyolk/tomlrange
@@ -129,6 +129,10 @@ On a list, `overlap=` is `"reject"` (default), `"allow"`, or `"merge"`.
 Reject treats a shared endpoint as overlap (`1–4` and `4–6` fail).
 Adjacent integers (`1–4` then `5–8`) are fine; `merge()` will coalesce them.
 
+`list()`, `len()`, `width`, and `as_range()` are int-only — they raise
+`TypeError` (`"{name} width is only defined for int"`). Membership,
+`as_tuple()`, and `as_table()` work for any ordered `typ`.
+
 Errors carry a path:
 
 ```
@@ -142,6 +146,7 @@ months_ranges[1].to: 13 is above month 12
 - Not a two-element array (`[1, 12]`). After TOML decode that is a list, not a table.
 - Not wrap-around (`from = 11, to = 2`). Write two spans.
 - Not `step`. A range table is a closed interval.
+- Not iteration over a non-int domain. Walk dates or strings yourself.
 
 ## Install
 

{tomlrange-0.2.1 → tomlrange-0.2.2}/README.md

@@ -89,6 +89,10 @@ On a list, `overlap=` is `"reject"` (default), `"allow"`, or `"merge"`.
 Reject treats a shared endpoint as overlap (`1–4` and `4–6` fail).
 Adjacent integers (`1–4` then `5–8`) are fine; `merge()` will coalesce them.
 
+`list()`, `len()`, `width`, and `as_range()` are int-only — they raise
+`TypeError` (`"{name} width is only defined for int"`). Membership,
+`as_tuple()`, and `as_table()` work for any ordered `typ`.
+
 Errors carry a path:
 
 ```
@@ -102,6 +106,7 @@ months_ranges[1].to: 13 is above month 12
 - Not a two-element array (`[1, 12]`). After TOML decode that is a list, not a table.
 - Not wrap-around (`from = 11, to = 2`). Write two spans.
 - Not `step`. A range table is a closed interval.
+- Not iteration over a non-int domain. Walk dates or strings yourself.
 
 ## Install
 

{tomlrange-0.2.1 → tomlrange-0.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tomlrange"
-version = "0.2.1"
+version = "0.2.2"
 description = "Parse and validate { from, to } tables from decoded TOML."
 readme = "README.md"
 license = { file = "LICENSE" }

{tomlrange-0.2.1 → tomlrange-0.2.2}/src/tomlrange/__init__.py

@@ -1,9 +1,16 @@
 """Parse and validate `{ from = …, to = … }` tables from decoded TOML."""
 
+from importlib.metadata import PackageNotFoundError, version
+
 from tomlrange.bound import Bound, Bounds
 from tomlrange.domain import Domain, Spec
 from tomlrange.error import TomlRangeError
 
+try:
+    __version__ = version("tomlrange")
+except PackageNotFoundError:
+    __version__ = "unknown"
+
 __all__ = [
     "Bound",
     "Bounds",
@@ -11,4 +18,3 @@ __all__ = [
     "Spec",
     "TomlRangeError",
 ]
-__version__ = "0.2.1"

{tomlrange-0.2.1 → tomlrange-0.2.2}/src/tomlrange/bound.py

@@ -10,10 +10,15 @@ if TYPE_CHECKING:
     from tomlrange.paths import Overlap
 
 
-def _as_table(raw: Any, *, path: str) -> Mapping[str, Any]:
+def _as_table(raw: Any, *, path: str, keys: tuple[str, str]) -> Mapping[str, Any]:
     if isinstance(raw, Mapping):
         return raw
-    raise TomlRangeError(path, "expected a table { from = …, to = … }", raw)
+    start_key, stop_key = keys
+    raise TomlRangeError(
+        path,
+        f"expected a table {{ {start_key} = …, {stop_key} = … }}",
+        raw,
+    )
 
 
 @dataclass(frozen=True, slots=True)
@@ -26,8 +31,8 @@ class Bound[T]:
 
     @classmethod
     def parse(cls, raw: Any, domain: Domain[T], *, path: str = ".") -> Bound[T]:
-        table = _as_table(raw, path=path)
         start_key, stop_key = domain.keys
+        table = _as_table(raw, path=path, keys=domain.keys)
         extra = set(table) - {start_key, stop_key}
         if extra:
             raise TomlRangeError(
@@ -51,16 +56,18 @@ class Bound[T]:
             )
         return cls(start, stop, domain)
 
-    @property
-    def width(self) -> int:
+    def _require_int(self) -> None:
         if type(self.start) is not int or type(self.stop) is not int:
             raise TypeError(f"{self.domain.name} width is only defined for int")
-        return self.stop - self.start + 1
+
+    @property
+    def width(self) -> int:
+        self._require_int()
+        return self.stop - self.start + 1  # type: ignore[operator]
 
     def as_range(self) -> range:
-        if type(self.start) is not int or type(self.stop) is not int:
-            raise TypeError(f"{self.domain.name} as_range() is only defined for int")
-        return range(self.start, self.stop + 1)
+        self._require_int()
+        return range(self.start, self.stop + 1)  # type: ignore[arg-type]
 
     def as_tuple(self) -> tuple[T, T]:
         return (self.start, self.stop)
@@ -75,9 +82,11 @@ class Bound[T]:
         return self.start <= item <= self.stop  # type: ignore[operator]
 
     def __iter__(self) -> Iterator[T]:
+        self._require_int()
         yield from self.as_range()  # type: ignore[misc]
 
     def __len__(self) -> int:
+        self._require_int()
         return self.width
 
     def overlaps(self, other: Bound[T]) -> bool:
@@ -148,6 +157,10 @@ class Bounds[T]:
     def merge(self) -> Bounds[T]:
         return Bounds(_coalesce(self.spans, self.domain), self.domain)
 
+    def _require_int(self) -> None:
+        if self.domain.typ is not int:
+            raise TypeError(f"{self.domain.name} width is only defined for int")
+
     def covers(self, item: object) -> bool:
         return any(item in span for span in self.spans)
 
@@ -155,6 +168,7 @@ class Bounds[T]:
         return self.covers(item)
 
     def __iter__(self) -> Iterator[T]:
+        self._require_int()
         seen: set[T] = set()
         for span in self.spans:
             for item in span:
@@ -164,6 +178,7 @@ class Bounds[T]:
                 yield item
 
     def __len__(self) -> int:
+        self._require_int()
         return sum(1 for _ in self)
 
     def __repr__(self) -> str:

{tomlrange-0.2.1 → tomlrange-0.2.2}/src/tomlrange/domain.py

@@ -65,7 +65,7 @@ class Domain[T]:
         return raw
 
     def bound(self, raw: Any, *, path: str = ".") -> Bound[T]:
-        from tomlrange.bound import Bound
+        from tomlrange.bound import Bound  # cycle: Domain ↔ Bound
 
         return Bound.parse(raw, self, path=path)
 
@@ -76,12 +76,12 @@ class Domain[T]:
         path: str = ".",
         overlap: Overlap = "reject",
     ) -> Bounds[T]:
-        from tomlrange.bound import Bounds
+        from tomlrange.bound import Bounds  # cycle: Domain ↔ Bound
 
         return Bounds.parse(raw, self, path=path, overlap=overlap)
 
     def full(self) -> Bound[T]:
-        from tomlrange.bound import Bound
+        from tomlrange.bound import Bound  # cycle: Domain ↔ Bound
 
         if self.lo is None or self.hi is None:
             raise TomlRangeError(".", f"{self.name} domain has no closed lo/hi")
@@ -130,7 +130,7 @@ class Spec:
 
     @classmethod
     def parse(cls, raw: Any, *, path: str = ".") -> Bound[Any]:
-        from tomlrange.bound import Bound
+        from tomlrange.bound import Bound  # cycle: Domain ↔ Bound
 
         return Bound.parse(raw, cls.domain, path=path)
 
@@ -142,7 +142,7 @@ class Spec:
         path: str = ".",
         overlap: Overlap | None = None,
     ) -> Bounds[Any]:
-        from tomlrange.bound import Bounds
+        from tomlrange.bound import Bounds  # cycle: Domain ↔ Bound
 
         return Bounds.parse(
             raw,

{tomlrange-0.2.1 → tomlrange-0.2.2}/tests/test_tomlrange.py

@@ -122,6 +122,31 @@ def test_custom_keys() -> None:
         hours.bound({"from": 7, "to": 16})
     with pytest.raises(TomlRangeError, match="must have keys"):
         hours.bound({"start": 7})
+    with pytest.raises(
+        TomlRangeError, match=r"expected a table \{ start = …, end = … \}"
+    ):
+        hours.bound([7, 16])
+
+
+def test_int_only_iteration() -> None:
+    labels = Domain(str, name="label")
+    bound = labels.bound({"from": "a", "to": "c"})
+    assert bound.as_tuple() == ("a", "c")
+    assert "b" in bound
+    with pytest.raises(TypeError, match="label width is only defined for int"):
+        list(bound)
+    with pytest.raises(TypeError, match="label width is only defined for int"):
+        len(bound)
+    with pytest.raises(TypeError, match="label width is only defined for int"):
+        _ = bound.width
+    with pytest.raises(TypeError, match="label width is only defined for int"):
+        bound.as_range()
+    spans = labels.bounds([{"from": "a", "to": "b"}, {"from": "d", "to": "e"}])
+    assert "a" in spans
+    with pytest.raises(TypeError, match="label width is only defined for int"):
+        list(spans)
+    with pytest.raises(TypeError, match="label width is only defined for int"):
+        len(spans)
 
 
 def test_error_paths() -> None:
@@ -131,3 +156,80 @@ def test_error_paths() -> None:
             path="months_ranges",
         )
     assert exc.value.path == "months_ranges[1].to"
+
+
+def test_open_int_domain_parse() -> None:
+    open_int = Domain(int, name="n")
+    bound = open_int.bound({"from": -3, "to": 99})
+    assert bound.as_tuple() == (-3, 99)
+    assert -3 in bound
+    assert 99 in bound
+
+
+def test_full_requires_closed_lo_hi() -> None:
+    open_int = Domain(int, name="n")
+    with pytest.raises(TomlRangeError, match="n domain has no closed lo/hi"):
+        open_int.full()
+    half = Domain(int, lo=1, name="n")
+    with pytest.raises(TomlRangeError, match="n domain has no closed lo/hi"):
+        half.full()
+
+    class Open(Spec):
+        typ = int
+        name = "open"
+
+    with pytest.raises(TomlRangeError, match="open domain has no closed lo/hi"):
+        Open.full()
+
+
+def test_bounds_empty_list() -> None:
+    empty = MONTH.bounds([])
+    assert empty.spans == ()
+    assert list(empty) == []
+
+
+def test_unknown_overlap_policy() -> None:
+    with pytest.raises(ValueError, match="unknown overlap policy 'bogus'"):
+        MONTH.bounds([{"from": 1, "to": 2}], overlap="bogus")
+
+
+def test_float_domain_parse() -> None:
+    ratio = Domain(float, lo=0.0, hi=1.0, name="ratio")
+    bound = ratio.bound({"from": 0.25, "to": 0.75})
+    assert bound.as_tuple() == (0.25, 0.75)
+    assert 0.5 in bound
+    assert bound.as_table() == {"from": 0.25, "to": 0.75}
+
+
+def test_spec_name_suffix_stripping() -> None:
+    class MonthBounds(Spec):
+        typ = int
+        lo = 1
+        hi = 12
+
+    class MonthRange(Spec):
+        typ = int
+        lo = 1
+        hi = 12
+
+    class MonthSpec(Spec):
+        typ = int
+        lo = 1
+        hi = 12
+
+    assert MonthBounds.domain.name == "month"
+    assert MonthRange.domain.name == "month"
+    assert MonthSpec.domain.name == "month"
+
+
+def test_spec_overlap_class_default() -> None:
+    class AllowingMonth(Spec):
+        typ = int
+        lo = 1
+        hi = 12
+        overlap = "allow"
+
+    raw = [{"from": 1, "to": 4}, {"from": 4, "to": 6}]
+    allowed = AllowingMonth.parse_many(raw)
+    assert list(allowed) == [1, 2, 3, 4, 5, 6]
+    assert len(allowed.spans) == 2

{tomlrange-0.2.1 → tomlrange-0.2.2}/uv.lock

@@ -198,7 +198,7 @@ wheels = [
 
 [[package]]
 name = "tomlrange"
-version = "0.2.1"
+version = "0.2.2"
 source = { editable = "." }
 
 [package.dev-dependencies]