countably 2026.5.16.56074.dev1__py3-none-any.whl

countably/__init__.py

@@ -0,0 +1,7 @@
+import importlib.metadata
+
+from ._core import NumberSequence, constant, count
+
+__version__ = importlib.metadata.version(__name__)
+
+__all__ = ["NumberSequence", "constant", "count", "__version__"]

countably/_core.py

@@ -0,0 +1,294 @@
+from __future__ import annotations
+
+import functools
+import itertools
+import operator
+import sys
+from dataclasses import dataclass
+from typing import (
+    Callable,
+    Generic,
+    Iterator,
+    Protocol,
+    TypeVar,
+    Union,
+    overload,
+    runtime_checkable,
+)
+
+Number = complex
+SeqOrNumber = Union["NumberSequence[Number]", Number]
+
+T_co = TypeVar("T_co", covariant=True, bound=Number)
+T = TypeVar("T", bound=Number)
+
+
+class _Computation(Protocol[T_co]):
+    def __len__(self) -> int: ...
+
+    def __getitem__(self, index: int) -> T_co: ...
+
+    def __iter__(self) -> Iterator[T_co]: ...
+
+
+@runtime_checkable
+class NumberSequence(Protocol[T_co]):
+    def __len__(self) -> int: ...
+
+    def __bool__(self) -> bool: ...
+
+    @overload
+    def __getitem__(self, index: int) -> T_co: ...
+
+    @overload
+    def __getitem__(self, index: slice) -> "NumberSequence[T_co]": ...
+
+    def __iter__(self) -> Iterator[T_co]: ...
+
+    def __add__(self, other: SeqOrNumber) -> "NumberSequence[Number]": ...
+
+    def __radd__(self, other: SeqOrNumber) -> "NumberSequence[Number]": ...
+
+    def __sub__(self, other: SeqOrNumber) -> "NumberSequence[Number]": ...
+
+    def __rsub__(self, other: SeqOrNumber) -> "NumberSequence[Number]": ...
+
+    def __mul__(self, other: SeqOrNumber) -> "NumberSequence[Number]": ...
+
+    def __rmul__(self, other: SeqOrNumber) -> "NumberSequence[Number]": ...
+
+    def __truediv__(self, other: SeqOrNumber) -> "NumberSequence[Number]": ...
+
+    def __rtruediv__(self, other: SeqOrNumber) -> "NumberSequence[Number]": ...
+
+    def __floordiv__(self, other: SeqOrNumber) -> "NumberSequence[Number]": ...
+
+    def __rfloordiv__(self, other: SeqOrNumber) -> "NumberSequence[Number]": ...
+
+    def __mod__(self, other: SeqOrNumber) -> "NumberSequence[Number]": ...
+
+    def __rmod__(self, other: SeqOrNumber) -> "NumberSequence[Number]": ...
+
+    def __pow__(self, other: SeqOrNumber) -> "NumberSequence[Number]": ...
+
+    def __rpow__(self, other: SeqOrNumber) -> "NumberSequence[Number]": ...
+
+    def __neg__(self) -> "NumberSequence[Number]": ...
+
+    def __pos__(self) -> "NumberSequence[Number]": ...
+
+    def __abs__(self) -> "NumberSequence[Number]": ...
+
+
+@dataclass(frozen=True, kw_only=True)
+class _Sequence(Generic[T_co]):
+    _computation: _Computation[T_co]
+
+    @functools.cached_property
+    def _cached_at(self) -> Callable[[int], T_co]:
+        return functools.lru_cache(maxsize=100)(self._computation.__getitem__)
+
+    def __len__(self) -> int:
+        return len(self._computation)
+
+    def __bool__(self) -> bool:
+        raise TypeError("NumberSequence has no boolean value")
+
+    @overload
+    def __getitem__(self, index: int) -> T_co: ...
+
+    @overload
+    def __getitem__(self, index: slice) -> "_Sequence[T_co]": ...
+
+    def __getitem__(self, index: Union[int, slice]) -> Union[T_co, "_Sequence[T_co]"]:
+        if isinstance(index, slice):
+            return _slice_sequence(self, index)
+        size = len(self)
+        position = index
+        if position < 0:
+            if size == sys.maxsize:
+                raise IndexError("negative index on infinite sequence")
+            position += size
+        if position < 0 or position >= size:
+            raise IndexError(index)
+        return self._cached_at(position)
+
+    def __iter__(self) -> Iterator[T_co]:
+        return iter(self._computation)
+
+    def __add__(self, other: SeqOrNumber) -> NumberSequence[Number]:
+        return _binop(self, other, operator.add)
+
+    def __radd__(self, other: SeqOrNumber) -> NumberSequence[Number]:
+        return _binop(other, self, operator.add)
+
+    def __sub__(self, other: SeqOrNumber) -> NumberSequence[Number]:
+        return _binop(self, other, operator.sub)
+
+    def __rsub__(self, other: SeqOrNumber) -> NumberSequence[Number]:
+        return _binop(other, self, operator.sub)
+
+    def __mul__(self, other: SeqOrNumber) -> NumberSequence[Number]:
+        return _binop(self, other, operator.mul)
+
+    def __rmul__(self, other: SeqOrNumber) -> NumberSequence[Number]:
+        return _binop(other, self, operator.mul)
+
+    def __truediv__(self, other: SeqOrNumber) -> NumberSequence[Number]:
+        return _binop(self, other, operator.truediv)
+
+    def __rtruediv__(self, other: SeqOrNumber) -> NumberSequence[Number]:
+        return _binop(other, self, operator.truediv)
+
+    def __floordiv__(self, other: SeqOrNumber) -> NumberSequence[Number]:
+        return _binop(self, other, operator.floordiv)
+
+    def __rfloordiv__(self, other: SeqOrNumber) -> NumberSequence[Number]:
+        return _binop(other, self, operator.floordiv)
+
+    def __mod__(self, other: SeqOrNumber) -> NumberSequence[Number]:
+        return _binop(self, other, operator.mod)
+
+    def __rmod__(self, other: SeqOrNumber) -> NumberSequence[Number]:
+        return _binop(other, self, operator.mod)
+
+    def __pow__(self, other: SeqOrNumber) -> NumberSequence[Number]:
+        return _binop(self, other, operator.pow)
+
+    def __rpow__(self, other: SeqOrNumber) -> NumberSequence[Number]:
+        return _binop(other, self, operator.pow)
+
+    def __neg__(self) -> NumberSequence[Number]:
+        return _unop(self, operator.neg)
+
+    def __pos__(self) -> NumberSequence[Number]:
+        return _unop(self, operator.pos)
+
+    def __abs__(self) -> NumberSequence[Number]:
+        return _unop(self, operator.abs)
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class _ConstantComputation(Generic[T]):
+    value: T
+
+    def __len__(self) -> int:
+        return sys.maxsize
+
+    def __getitem__(self, index: int) -> T:
+        return self.value
+
+    def __iter__(self) -> Iterator[T]:
+        return itertools.repeat(self.value)
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class _CountComputation:
+    def __len__(self) -> int:
+        return sys.maxsize
+
+    def __getitem__(self, index: int) -> int:
+        return index
+
+    def __iter__(self) -> Iterator[int]:
+        return itertools.count()
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class _BinOpComputation:
+    left: NumberSequence[Number]
+    right: NumberSequence[Number]
+    op: Callable[[Number, Number], Number]
+
+    def __len__(self) -> int:
+        return min(len(self.left), len(self.right))
+
+    def __getitem__(self, index: int) -> Number:
+        return self.op(self.left[index], self.right[index])
+
+    def __iter__(self) -> Iterator[Number]:
+        return map(self.op, self.left, self.right)
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class _UnaryOpComputation:
+    seq: NumberSequence[Number]
+    op: Callable[[Number], Number]
+
+    def __len__(self) -> int:
+        return len(self.seq)
+
+    def __getitem__(self, index: int) -> Number:
+        return self.op(self.seq[index])
+
+    def __iter__(self) -> Iterator[Number]:
+        return map(self.op, self.seq)
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class _SlicedComputation(Generic[T_co]):
+    source: NumberSequence[T_co]
+    start: int
+    step: int
+    length: int
+
+    def __len__(self) -> int:
+        return self.length
+
+    def __getitem__(self, index: int) -> T_co:
+        return self.source[self.start + self.step * index]
+
+    def __iter__(self) -> Iterator[T_co]:
+        stop = (
+            None if self.length == sys.maxsize else self.start + self.step * self.length
+        )
+        return itertools.islice(self.source, self.start, stop, self.step)
+
+
+def _coerce(value: SeqOrNumber) -> NumberSequence[Number]:
+    if isinstance(value, NumberSequence):
+        return value
+    return constant(value)
+
+
+def _binop(
+    left: SeqOrNumber,
+    right: SeqOrNumber,
+    op: Callable[[Number, Number], Number],
+) -> NumberSequence[Number]:
+    return _Sequence(
+        _computation=_BinOpComputation(left=_coerce(left), right=_coerce(right), op=op)
+    )
+
+
+def _unop(
+    seq: NumberSequence[Number],
+    op: Callable[[Number], Number],
+) -> NumberSequence[Number]:
+    return _Sequence(_computation=_UnaryOpComputation(seq=seq, op=op))
+
+
+def _slice_sequence(seq: NumberSequence[T_co], sl: slice) -> _Sequence[T_co]:
+    step = 1 if sl.step is None else sl.step
+    start = 0 if sl.start is None else sl.start
+    if step <= 0 or start < 0 or (sl.stop is not None and sl.stop < 0):
+        raise ValueError(f"invalid slice: {sl!r}")
+    source_len = len(seq)
+    if sl.stop is None and source_len == sys.maxsize:
+        length = sys.maxsize
+    else:
+        actual_stop = source_len if sl.stop is None else min(sl.stop, source_len)
+        length = max(0, (actual_stop - start + step - 1) // step)
+    return _Sequence(
+        _computation=_SlicedComputation(
+            source=seq, start=start, step=step, length=length
+        )
+    )
+
+
+def constant(value: T) -> NumberSequence[T]:
+    return _Sequence(_computation=_ConstantComputation(value=value))
+
+
+def count() -> NumberSequence[int]:
+    return _Sequence(_computation=_CountComputation())

countably/tests/test_arithmetic.py

@@ -0,0 +1,153 @@
+import itertools
+import sys
+import unittest
+
+from hamcrest import assert_that, calling, equal_to, raises
+
+from countably import constant, count
+
+
+def _take(seq, n):
+    return list(itertools.islice(seq, n))
+
+
+class TestAdd(unittest.TestCase):
+    def test_two_constants(self) -> None:
+        seq = constant(3) + constant(5)
+        assert_that(seq[0], equal_to(8))
+        assert_that(seq[100], equal_to(8))
+
+    def test_constant_plus_count(self) -> None:
+        seq = constant(3) + count()
+        assert_that(_take(seq, 4), equal_to([3, 4, 5, 6]))
+
+    def test_left_coerce(self) -> None:
+        seq = 3 + count()
+        assert_that(_take(seq, 4), equal_to([3, 4, 5, 6]))
+
+    def test_right_coerce(self) -> None:
+        seq = count() + 3
+        assert_that(_take(seq, 4), equal_to([3, 4, 5, 6]))
+
+
+class TestSub(unittest.TestCase):
+    def test_count_minus_one(self) -> None:
+        seq = count() - 1
+        assert_that(_take(seq, 4), equal_to([-1, 0, 1, 2]))
+
+    def test_left_coerce(self) -> None:
+        seq = 10 - count()
+        assert_that(_take(seq, 4), equal_to([10, 9, 8, 7]))
+
+
+class TestMul(unittest.TestCase):
+    def test_count_times_two(self) -> None:
+        seq = count() * 2
+        assert_that(_take(seq, 4), equal_to([0, 2, 4, 6]))
+
+    def test_left_coerce(self) -> None:
+        seq = 5 * count()
+        assert_that(_take(seq, 4), equal_to([0, 5, 10, 15]))
+
+    def test_complex_expression(self) -> None:
+        seq = 3 + 5 * count()
+        assert_that(_take(seq, 4), equal_to([3, 8, 13, 18]))
+
+
+class TestDiv(unittest.TestCase):
+    def test_truediv(self) -> None:
+        seq = (count() + 1) / 2
+        assert_that(_take(seq, 4), equal_to([0.5, 1.0, 1.5, 2.0]))
+
+    def test_truediv_left_coerce(self) -> None:
+        seq = 10 / (count() + 1)
+        assert_that(_take(seq, 4), equal_to([10.0, 5.0, 10 / 3, 2.5]))
+
+    def test_floordiv(self) -> None:
+        seq = count() // 2
+        assert_that(_take(seq, 5), equal_to([0, 0, 1, 1, 2]))
+
+    def test_floordiv_left_coerce(self) -> None:
+        seq = 10 // (count() + 1)
+        assert_that(_take(seq, 4), equal_to([10, 5, 3, 2]))
+
+
+class TestMod(unittest.TestCase):
+    def test_mod(self) -> None:
+        seq = count() % 3
+        assert_that(_take(seq, 7), equal_to([0, 1, 2, 0, 1, 2, 0]))
+
+    def test_mod_left_coerce(self) -> None:
+        seq = 10 % (count() + 1)
+        assert_that(_take(seq, 5), equal_to([0, 0, 1, 2, 0]))
+
+
+class TestPow(unittest.TestCase):
+    def test_pow(self) -> None:
+        seq = count() ** 2
+        assert_that(_take(seq, 5), equal_to([0, 1, 4, 9, 16]))
+
+    def test_pow_left_coerce(self) -> None:
+        seq = 2 ** count()
+        assert_that(_take(seq, 5), equal_to([1, 2, 4, 8, 16]))
+
+
+class TestUnary(unittest.TestCase):
+    def test_neg(self) -> None:
+        seq = -count()
+        assert_that(_take(seq, 4), equal_to([0, -1, -2, -3]))
+
+    def test_pos(self) -> None:
+        seq = +(count() - 2)
+        assert_that(_take(seq, 4), equal_to([-2, -1, 0, 1]))
+
+    def test_abs(self) -> None:
+        seq = abs(count() - 2)
+        assert_that(_take(seq, 5), equal_to([2, 1, 0, 1, 2]))
+
+    def test_unary_length_preserved(self) -> None:
+        seq = -count()[2:10]
+        assert_that(len(seq), equal_to(8))
+
+    def test_neg_index(self) -> None:
+        seq = -count()
+        assert_that(seq[5], equal_to(-5))
+
+    def test_abs_index(self) -> None:
+        seq = abs(count() - 3)
+        assert_that(seq[0], equal_to(3))
+        assert_that(seq[5], equal_to(2))
+
+
+class TestLength(unittest.TestCase):
+    def test_binop_infinite(self) -> None:
+        seq = constant(3) + count()
+        assert_that(len(seq), equal_to(sys.maxsize))
+
+    def test_binop_finite_takes_shorter(self) -> None:
+        seq = count()[0:5] + count()[0:3]
+        assert_that(len(seq), equal_to(3))
+
+    def test_binop_finite_with_infinite(self) -> None:
+        seq = count()[0:5] + count()
+        assert_that(len(seq), equal_to(5))
+
+
+class TestImmutability(unittest.TestCase):
+    def test_sequence_is_frozen(self) -> None:
+        from dataclasses import FrozenInstanceError
+
+        seq = constant(7)
+        assert_that(
+            calling(setattr).with_args(seq, "_computation", None),
+            raises(FrozenInstanceError),
+        )
+
+    def test_equality_of_expressions(self) -> None:
+        first = 3 + count()
+        second = 3 + count()
+        assert_that(first, equal_to(second))
+
+    def test_hashable(self) -> None:
+        seq = 3 + count()
+        assert_that(hash(seq), equal_to(hash(3 + count())))

countably/tests/test_coercion.py

@@ -0,0 +1,33 @@
+import itertools
+import unittest
+
+from hamcrest import assert_that, equal_to
+
+from countably import constant, count
+
+
+def _take(seq, n):
+    return list(itertools.islice(seq, n))
+
+
+class TestCoercion(unittest.TestCase):
+    def test_int_on_left_matches_explicit_constant(self) -> None:
+        assert_that(3 + count(), equal_to(constant(3) + count()))
+
+    def test_int_on_right_matches_explicit_constant(self) -> None:
+        assert_that(count() + 3, equal_to(count() + constant(3)))
+
+    def test_float_coerces(self) -> None:
+        seq = 0.5 + count()
+        assert_that(_take(seq, 3), equal_to([0.5, 1.5, 2.5]))
+
+    def test_complex_coerces(self) -> None:
+        seq = 1j + count()
+        assert_that(_take(seq, 3), equal_to([1j, 1 + 1j, 2 + 1j]))
+
+    def test_chained_coercion(self) -> None:
+        seq = 3 + 5 * count()
+        assert_that(_take(seq, 4), equal_to([3, 8, 13, 18]))
+
+    def test_coerced_value_at_index(self) -> None:
+        assert_that((10 - count())[3], equal_to(7))

countably/tests/test_primitives.py

@@ -0,0 +1,87 @@
+import itertools
+import operator
+import sys
+import unittest
+
+from hamcrest import assert_that, calling, equal_to, raises
+
+from countably import NumberSequence, constant, count
+
+
+class TestConstant(unittest.TestCase):
+    def test_value_at_zero(self) -> None:
+        seq = constant(7)
+        assert_that(seq[0], equal_to(7))
+
+    def test_value_at_large_index(self) -> None:
+        seq = constant(7)
+        assert_that(seq[10_000], equal_to(7))
+
+    def test_is_sequence(self) -> None:
+        assert_that(isinstance(constant(7), NumberSequence), equal_to(True))
+
+    def test_length_is_maxsize(self) -> None:
+        assert_that(len(constant(7)), equal_to(sys.maxsize))
+
+    def test_equality(self) -> None:
+        assert_that(constant(7), equal_to(constant(7)))
+
+    def test_iter(self) -> None:
+        values = list(itertools.islice(constant(7), 4))
+        assert_that(values, equal_to([7, 7, 7, 7]))
+
+
+class TestCount(unittest.TestCase):
+    def test_value_at_zero(self) -> None:
+        assert_that(count()[0], equal_to(0))
+
+    def test_value_at_index(self) -> None:
+        assert_that(count()[42], equal_to(42))
+
+    def test_length_is_maxsize(self) -> None:
+        assert_that(len(count()), equal_to(sys.maxsize))
+
+    def test_is_sequence(self) -> None:
+        assert_that(isinstance(count(), NumberSequence), equal_to(True))
+
+    def test_equality(self) -> None:
+        assert_that(count(), equal_to(count()))
+
+    def test_iter(self) -> None:
+        values = list(itertools.islice(count(), 5))
+        assert_that(values, equal_to([0, 1, 2, 3, 4]))
+
+
+class TestBoolFails(unittest.TestCase):
+    def test_bool_constant_raises(self) -> None:
+        assert_that(calling(bool).with_args(constant(7)), raises(TypeError))
+
+    def test_bool_count_raises(self) -> None:
+        assert_that(calling(bool).with_args(count()), raises(TypeError))
+
+    def test_bool_expression_raises(self) -> None:
+        assert_that(calling(bool).with_args(3 + count()), raises(TypeError))
+
+
+class TestIndexBounds(unittest.TestCase):
+    def test_negative_index_on_infinite_raises(self) -> None:
+        assert_that(
+            calling(operator.getitem).with_args(count(), -1),
+            raises(IndexError),
+        )
+
+    def test_out_of_range_finite_raises(self) -> None:
+        assert_that(
+            calling(operator.getitem).with_args(count()[0:3], 3),
+            raises(IndexError),
+        )
+
+    def test_finite_negative_index_works(self) -> None:
+        seq = count()[2:10]
+        assert_that(seq[-1], equal_to(9))
+
+    def test_finite_negative_out_of_range_raises(self) -> None:
+        assert_that(
+            calling(operator.getitem).with_args(count()[2:5], -4),
+            raises(IndexError),
+        )

countably/tests/test_slicing.py

@@ -0,0 +1,140 @@
+import itertools
+import operator
+import sys
+import unittest
+
+from hamcrest import assert_that, calling, equal_to, raises
+
+from countably import constant, count
+
+
+def _take(seq, n):
+    return list(itertools.islice(seq, n))
+
+
+class TestInfiniteSlice(unittest.TestCase):
+    def test_default_slice(self) -> None:
+        seq = count()[:]
+        assert_that(_take(seq, 4), equal_to([0, 1, 2, 3]))
+        assert_that(len(seq), equal_to(sys.maxsize))
+
+    def test_start_only(self) -> None:
+        seq = count()[3:]
+        assert_that(_take(seq, 4), equal_to([3, 4, 5, 6]))
+        assert_that(len(seq), equal_to(sys.maxsize))
+
+    def test_step_only(self) -> None:
+        seq = count()[::2]
+        assert_that(_take(seq, 4), equal_to([0, 2, 4, 6]))
+        assert_that(len(seq), equal_to(sys.maxsize))
+
+    def test_start_and_step(self) -> None:
+        seq = count()[2::3]
+        assert_that(_take(seq, 4), equal_to([2, 5, 8, 11]))
+        assert_that(len(seq), equal_to(sys.maxsize))
+
+
+class TestFiniteSlice(unittest.TestCase):
+    def test_start_stop(self) -> None:
+        seq = count()[2:7]
+        assert_that(len(seq), equal_to(5))
+        assert_that(list(seq), equal_to([2, 3, 4, 5, 6]))
+
+    def test_start_stop_step(self) -> None:
+        seq = count()[2:10:3]
+        assert_that(len(seq), equal_to(3))
+        assert_that(list(seq), equal_to([2, 5, 8]))
+
+    def test_stop_smaller_than_start(self) -> None:
+        seq = count()[5:3]
+        assert_that(len(seq), equal_to(0))
+        assert_that(list(seq), equal_to([]))
+
+    def test_stop_at_boundary(self) -> None:
+        seq = count()[2:11:3]
+        assert_that(len(seq), equal_to(3))
+        assert_that(list(seq), equal_to([2, 5, 8]))
+
+    def test_stop_at_next_boundary(self) -> None:
+        seq = count()[2:12:3]
+        assert_that(len(seq), equal_to(4))
+        assert_that(list(seq), equal_to([2, 5, 8, 11]))
+
+    def test_finite_iter(self) -> None:
+        seq = count()[0:3]
+        assert_that(list(seq), equal_to([0, 1, 2]))
+
+
+class TestSliceOfSlice(unittest.TestCase):
+    def test_finite_of_finite(self) -> None:
+        seq = count()[2:20:3][1:4]
+        assert_that(list(seq), equal_to([5, 8, 11]))
+
+    def test_infinite_of_infinite(self) -> None:
+        seq = count()[2::3][1::2]
+        assert_that(_take(seq, 4), equal_to([5, 11, 17, 23]))
+
+
+class TestArithmeticBetweenSlices(unittest.TestCase):
+    def test_finite_plus_finite_shortest_wins(self) -> None:
+        left = count()[2:10]
+        right = count()[3:8]
+        combined = left + right
+        assert_that(len(combined), equal_to(5))
+        assert_that(list(combined), equal_to([5, 7, 9, 11, 13]))
+
+    def test_finite_plus_infinite_finite_wins(self) -> None:
+        seq = count()[0:4] + count()
+        assert_that(len(seq), equal_to(4))
+        assert_that(list(seq), equal_to([0, 2, 4, 6]))
+
+    def test_infinite_plus_infinite_infinite(self) -> None:
+        seq = count()[::2] + count()[::3]
+        assert_that(len(seq), equal_to(sys.maxsize))
+        assert_that(_take(seq, 4), equal_to([0, 5, 10, 15]))
+
+
+class TestSliceErrors(unittest.TestCase):
+    def test_zero_step_raises(self) -> None:
+        assert_that(
+            calling(operator.getitem).with_args(count(), slice(0, 10, 0)),
+            raises(ValueError),
+        )
+
+    def test_negative_step_raises(self) -> None:
+        assert_that(
+            calling(operator.getitem).with_args(count(), slice(None, None, -1)),
+            raises(ValueError),
+        )
+
+    def test_negative_start_raises(self) -> None:
+        assert_that(
+            calling(operator.getitem).with_args(count(), slice(-1, None, None)),
+            raises(ValueError),
+        )
+
+    def test_negative_stop_raises(self) -> None:
+        assert_that(
+            calling(operator.getitem).with_args(count(), slice(0, -1, None)),
+            raises(ValueError),
+        )
+
+
+class TestSliceOfConstant(unittest.TestCase):
+    def test_infinite_slice(self) -> None:
+        seq = constant(5)[2::3]
+        assert_that(_take(seq, 4), equal_to([5, 5, 5, 5]))
+
+    def test_finite_slice(self) -> None:
+        seq = constant(5)[2:5]
+        assert_that(list(seq), equal_to([5, 5, 5]))
+
+
+class TestFiniteSliceLength(unittest.TestCase):
+    def test_finite_slice_real_len(self) -> None:
+        seq = count()[2:10]
+        assert_that(len(seq), equal_to(8))
+
+    def test_infinite_slice_maxsize_len(self) -> None:
+        seq = count()[2::3]
+        assert_that(len(seq), equal_to(sys.maxsize))

countably/tests/test_version.py

@@ -0,0 +1,9 @@
+import unittest
+from hamcrest import assert_that, contains_string
+
+from countably import __version__
+
+
+class TestVersion(unittest.TestCase):
+    def test_has_dot(self) -> None:
+        assert_that(__version__, contains_string("."))

countably-2026.5.16.56074.dev1.dist-info/METADATA

@@ -0,0 +1,41 @@
+Metadata-Version: 2.4
+Name: countably
+Version: 2026.5.16.56074.dev1
+Summary: Infinite number sequences
+Author-email: Moshe Zadka <moshez@zadka.club>
+License: Permission is hereby granted, free of charge, to any person obtaining a
+        copy of this software and associated documentation files (the "Software"),
+        to deal in the Software without restriction, including without limitation the
+        rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is furnished
+        to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+        INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+        PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+        HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+        CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
+        OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/moshez/countably
+Description-Content-Type: text/x-rst
+Provides-Extra: tests
+Requires-Dist: virtue; extra == "tests"
+Requires-Dist: pyhamcrest; extra == "tests"
+Requires-Dist: coverage; extra == "tests"
+Provides-Extra: mypy
+Requires-Dist: mypy; extra == "mypy"
+Provides-Extra: lint
+Requires-Dist: flake8; extra == "lint"
+Requires-Dist: black; extra == "lint"
+Requires-Dist: stolid; extra == "lint"
+Provides-Extra: docs
+Requires-Dist: sphinx; extra == "docs"
+
+countably
+========================
+
+Stuff

countably-2026.5.16.56074.dev1.dist-info/RECORD

@@ -0,0 +1,13 @@
+countably/__init__.py,sha256=kukhO1HaKvUqTEIPZ-fgpL-sx1WKUYZzxS7IP0wZLjs,196
+countably/_core.py,sha256=Jd06DVTmevuv-Y20UJlz9UThWa4bsj0UfyetaWVkCpM,8853
+countably/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+countably/tests/test_arithmetic.py,sha256=ZJe7jaVsD8XGZbd46SUI8f9brO4BRzenXBSa_cuTljQ,4543
+countably/tests/test_coercion.py,sha256=1pfAu6RcP0XFKZj45U1KsTSRqgT48DBjrhsCiLGzLNk,999
+countably/tests/test_primitives.py,sha256=GWixRWdGgSb7bKB61qXggIyBzq0RL8sHEPkjhawieus,2726
+countably/tests/test_slicing.py,sha256=oXFCmtd8sHpTS3Vt0y8pYVA6cdqK-5vcII1q2Xi82rs,4489
+countably/tests/test_version.py,sha256=3vebXGHF_cHyL9T9_xEgomFpYHGu7OhZCojlYBJ3SQM,232
+countably-2026.5.16.56074.dev1.dist-info/METADATA,sha256=dacQpJ5Q_UagYj2WCn-_8pDKOgMIslLvueN4MY11ckc,1852
+countably-2026.5.16.56074.dev1.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+countably-2026.5.16.56074.dev1.dist-info/entry_points.txt,sha256=nh1ojdfUM_YnrSmnSUIf3k_p1bb6cHF6TOYRRmOTKhw,33
+countably-2026.5.16.56074.dev1.dist-info/top_level.txt,sha256=mMlnfD_QFjgGEy1lC7pkT5K55QHhsqVpAGoWBu4VjX4,10
+countably-2026.5.16.56074.dev1.dist-info/RECORD,,

countably-2026.5.16.56074.dev1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

countably-2026.5.16.56074.dev1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[gather]
+placeholder = countably

countably-2026.5.16.56074.dev1.dist-info/top_level.txt

@@ -0,0 +1 @@
+countably