sliceview 0.1.0__tar.gz

sliceview-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Juliano Fischer Naves
+
+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.

sliceview-0.1.0/PKG-INFO

@@ -0,0 +1,153 @@
+Metadata-Version: 2.4
+Name: sliceview
+Version: 0.1.0
+Summary: Zero-copy, composable slice views for Python sequences
+Project-URL: Homepage, https://github.com/julianofischer/sliceview
+Project-URL: Bug Tracker, https://github.com/julianofischer/sliceview/issues
+Project-URL: Discussions, https://discuss.python.org/t/slice-views-for-python-sequences/103531
+Author-email: Juliano Fischer Naves <julianofischer@gmail.com>
+License: MIT
+License-File: LICENSE
+Keywords: memory,performance,sequence,slice,view,zero-copy
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Utilities
+Requires-Python: >=3.9
+Provides-Extra: dev
+Requires-Dist: pytest-cov; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# sliceview
+
+**Zero-copy, composable slice views for Python sequences.**
+
+`sliceview` lets you work with windows into lists, tuples, strings, or any
+`Sequence` without copying the underlying data.  It is the proof-of-concept
+library accompanying the Python discussion on
+[Slice Views for Python Sequences](https://discuss.python.org/t/slice-views-for-python-sequences/103531).
+
+```python
+from sliceview import sliceview
+
+data = list(range(1_000_000))
+
+# O(1) — no copy
+window = sliceview(data)[50_000:60_000]
+
+# Compose slices — still O(1), still no copy
+every_third = sliceview(data)[::3][100:200]
+
+# In-place windowed update
+sv = sliceview(data)
+sv[0:5] = [10, 20, 30, 40, 50]
+
+# Sliding window without creating new objects
+view = sliceview(data, 0, 1000)
+for _ in range(10):
+    process(view)
+    view.advance(1000)
+```
+
+## Why?
+
+In Python today, `seq[a:b]` copies the data.  For large pipelines — text
+processing, audio, genomics, sorting algorithms — those copies dominate
+both time and memory.  `memoryview` solves this for *bytes-like* objects;
+`sliceview` targets *generic* sequences of Python objects.
+
+Inspired by Go slices, NumPy views, and `memoryview`.
+
+## Installation
+
+```bash
+pip install sliceview
+```
+
+## Features
+
+| Feature | Details |
+|---|---|
+| **Zero-copy slicing** | `sv[a:b:c]` returns a new `sliceview` in O(1) |
+| **Composable** | `sv[2:][::3][5:10]` chains correctly with no intermediate copies |
+| **Live view** | Mutations to the base are immediately visible through the view |
+| **Write-through** | `sv[i] = x` and `sv[a:b] = iterable` forward to the base |
+| **Sliding window** | `sv.advance(n)` shifts the window in-place — no new object |
+| **Any sequence** | Works with `list`, `tuple`, `str`, `array`, or your own type |
+
+## API
+
+### `sliceview(base, start=None, stop=None, step=None)`
+
+Create a view over `base`.  `start` may be a `slice` object.
+
+```python
+sv = sliceview(my_list)           # full view
+sv = sliceview(my_list, 10, 20)   # [10:20]
+sv = sliceview(my_list, slice(10, 20, 2))  # [10:20:2]
+```
+
+### Indexing and slicing
+
+```python
+sv[i]        # element access — maps to base[start + i*step]
+sv[a:b:c]    # returns a new sliceview (O(1))
+sv[i] = x    # write-through to the base
+sv[a:b] = it # slice assignment (delegates to base)
+```
+
+### `sv.advance(n) -> self`
+
+Shift the view's window forward by `n` index positions (negative to retreat).
+Returns `self` for chaining.  Useful for sliding-window algorithms:
+
+```python
+view = sliceview(samples, 0, window_size)
+while True:
+    result = process(view)
+    if view.advance(window_size)._start >= len(samples):
+        break
+```
+
+### `sv.tolist()` / `sv.copy()`
+
+Materialise the view as a new `list` (explicit copy).
+
+### `sv.base`
+
+The underlying sequence the view points into.
+
+## Semantics
+
+- **`len(sv)`** reflects the *current* base length, so appending to the base
+  is immediately visible.
+- **`sv[:]`** returns a new `sliceview` pointing at the same base — O(1).
+- **Hashing**: `sliceview` is intentionally unhashable.
+- **Equality**: compares element-wise to any `Sequence`.
+- **Immutable bases**: `sv[i] = x` raises `TypeError` if the base does not
+  support `__setitem__`.
+
+## Design notes and open questions
+
+This library implements the core proposal from the
+[Python discussion](https://discuss.python.org/t/slice-views-for-python-sequences/103531).
+Deliberately left out to keep the scope focused:
+
+- `view()` builtin shortcut (consensus in the thread was it's unnecessary)
+- `__sliceview__` dunder (motivation unclear until adoption data exists)
+- Multidimensional views (NumPy is the right tool for that)
+- ABC / Protocol additions to `collections.abc`
+
+Feedback welcome — please open an issue or join the discussion thread.
+
+## License
+
+MIT

sliceview-0.1.0/README.md

@@ -0,0 +1,125 @@
+# sliceview
+
+**Zero-copy, composable slice views for Python sequences.**
+
+`sliceview` lets you work with windows into lists, tuples, strings, or any
+`Sequence` without copying the underlying data.  It is the proof-of-concept
+library accompanying the Python discussion on
+[Slice Views for Python Sequences](https://discuss.python.org/t/slice-views-for-python-sequences/103531).
+
+```python
+from sliceview import sliceview
+
+data = list(range(1_000_000))
+
+# O(1) — no copy
+window = sliceview(data)[50_000:60_000]
+
+# Compose slices — still O(1), still no copy
+every_third = sliceview(data)[::3][100:200]
+
+# In-place windowed update
+sv = sliceview(data)
+sv[0:5] = [10, 20, 30, 40, 50]
+
+# Sliding window without creating new objects
+view = sliceview(data, 0, 1000)
+for _ in range(10):
+    process(view)
+    view.advance(1000)
+```
+
+## Why?
+
+In Python today, `seq[a:b]` copies the data.  For large pipelines — text
+processing, audio, genomics, sorting algorithms — those copies dominate
+both time and memory.  `memoryview` solves this for *bytes-like* objects;
+`sliceview` targets *generic* sequences of Python objects.
+
+Inspired by Go slices, NumPy views, and `memoryview`.
+
+## Installation
+
+```bash
+pip install sliceview
+```
+
+## Features
+
+| Feature | Details |
+|---|---|
+| **Zero-copy slicing** | `sv[a:b:c]` returns a new `sliceview` in O(1) |
+| **Composable** | `sv[2:][::3][5:10]` chains correctly with no intermediate copies |
+| **Live view** | Mutations to the base are immediately visible through the view |
+| **Write-through** | `sv[i] = x` and `sv[a:b] = iterable` forward to the base |
+| **Sliding window** | `sv.advance(n)` shifts the window in-place — no new object |
+| **Any sequence** | Works with `list`, `tuple`, `str`, `array`, or your own type |
+
+## API
+
+### `sliceview(base, start=None, stop=None, step=None)`
+
+Create a view over `base`.  `start` may be a `slice` object.
+
+```python
+sv = sliceview(my_list)           # full view
+sv = sliceview(my_list, 10, 20)   # [10:20]
+sv = sliceview(my_list, slice(10, 20, 2))  # [10:20:2]
+```
+
+### Indexing and slicing
+
+```python
+sv[i]        # element access — maps to base[start + i*step]
+sv[a:b:c]    # returns a new sliceview (O(1))
+sv[i] = x    # write-through to the base
+sv[a:b] = it # slice assignment (delegates to base)
+```
+
+### `sv.advance(n) -> self`
+
+Shift the view's window forward by `n` index positions (negative to retreat).
+Returns `self` for chaining.  Useful for sliding-window algorithms:
+
+```python
+view = sliceview(samples, 0, window_size)
+while True:
+    result = process(view)
+    if view.advance(window_size)._start >= len(samples):
+        break
+```
+
+### `sv.tolist()` / `sv.copy()`
+
+Materialise the view as a new `list` (explicit copy).
+
+### `sv.base`
+
+The underlying sequence the view points into.
+
+## Semantics
+
+- **`len(sv)`** reflects the *current* base length, so appending to the base
+  is immediately visible.
+- **`sv[:]`** returns a new `sliceview` pointing at the same base — O(1).
+- **Hashing**: `sliceview` is intentionally unhashable.
+- **Equality**: compares element-wise to any `Sequence`.
+- **Immutable bases**: `sv[i] = x` raises `TypeError` if the base does not
+  support `__setitem__`.
+
+## Design notes and open questions
+
+This library implements the core proposal from the
+[Python discussion](https://discuss.python.org/t/slice-views-for-python-sequences/103531).
+Deliberately left out to keep the scope focused:
+
+- `view()` builtin shortcut (consensus in the thread was it's unnecessary)
+- `__sliceview__` dunder (motivation unclear until adoption data exists)
+- Multidimensional views (NumPy is the right tool for that)
+- ABC / Protocol additions to `collections.abc`
+
+Feedback welcome — please open an issue or join the discussion thread.
+
+## License
+
+MIT

sliceview-0.1.0/__init__.py

@@ -0,0 +1,280 @@
+"""
+sliceview — Zero-copy slice views for Python sequences.
+
+A sliceview presents a live window into an existing sequence:
+reads and writes reflect the underlying sequence, view-to-view
+slicing composes in O(1), and no data is copied unless explicitly
+requested.
+
+Basic usage::
+
+    from sliceview import sliceview
+
+    big = list(range(1_000_000))
+
+    # O(1) window — no copy
+    window = sliceview(big)[1000:2000]
+
+    # Compose slices — still O(1)
+    every_other = sliceview(big)[::2][500:1000]
+
+    # In-place windowed update
+    sv = sliceview(big)
+    sv[0:10] = range(10, 20)
+
+    # Sliding window without creating new objects
+    view = sliceview(big, 0, 100)
+    for _ in range(10):
+        view.advance(100)
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence, Iterator
+from typing import overload, Union, Optional
+
+
+__all__ = ["sliceview"]
+__version__ = "0.1.0"
+
+
+class _OpenRange:
+    """Sentinel for a range whose stop is open (None), so it grows with the base."""
+
+    __slots__ = ("start", "step")
+
+    def __init__(self, start: int, step: int) -> None:
+        self.start = start
+        self.step = step
+
+    def resolve(self, b_len: int) -> range:
+        stop = b_len if self.step > 0 else -1
+        return range(self.start, stop, self.step)
+
+
+class sliceview(Sequence):
+    """A zero-copy, composable slice view over any :class:`collections.abc.Sequence`.
+
+    Parameters
+    ----------
+    base:
+        The underlying sequence.  Any object that implements
+        ``__len__`` and ``__getitem__`` with integer indices is accepted.
+    start, stop, step:
+        Slice parameters (same semantics as the built-in :class:`slice`).
+        *start* may alternatively be a :class:`slice` object, in which case
+        *stop* and *step* must be omitted.
+
+    Examples
+    --------
+    >>> sv = sliceview([0, 1, 2, 3, 4, 5])
+    >>> list(sv[1:4])
+    [1, 2, 3]
+    >>> list(sv[::2])
+    [0, 2, 4]
+    >>> sv2 = sv[1:][::2]   # composed — O(1), no copy
+    >>> list(sv2)
+    [1, 3, 5]
+    """
+
+    __slots__ = ("_base", "_range")
+
+    # ------------------------------------------------------------------
+    # Construction
+    # ------------------------------------------------------------------
+
+    def __init__(
+        self,
+        base: Sequence,
+        start: Union[int, slice, None] = None,
+        stop: Optional[int] = None,
+        step: Optional[int] = None,
+    ) -> None:
+        if not (hasattr(base, "__len__") and hasattr(base, "__getitem__")):
+            raise TypeError(
+                f"sliceview requires a sequence with __len__ and __getitem__, "
+                f"got {type(base).__name__!r}"
+            )
+        self._base = base
+
+        if isinstance(start, slice) and stop is None and step is None:
+            sl: slice = start
+        else:
+            sl = slice(start, stop, step)
+
+        b_len = len(base)
+        s, e, st = sl.indices(b_len)
+
+        # If the original stop was None, store an open sentinel so that the
+        # view grows when elements are appended to the base.
+        if sl.stop is None:
+            self._range = _OpenRange(s, st)
+        else:
+            self._range = range(s, e, st)
+
+    @classmethod
+    def _from_range(cls, base: Sequence, r) -> "sliceview":
+        """Internal constructor: build a view directly from a range object."""
+        sv = cls.__new__(cls)
+        sv._base = base
+        sv._range = r
+        return sv
+
+    # ------------------------------------------------------------------
+    # Core helper
+    # ------------------------------------------------------------------
+
+    def _current_range(self) -> range:
+        """Return a concrete ``range`` clamped to the current base length."""
+        r = self._range
+        if isinstance(r, _OpenRange):
+            return r.resolve(len(self._base))
+        return r
+
+    # ------------------------------------------------------------------
+    # Sequence protocol
+    # ------------------------------------------------------------------
+
+    def __len__(self) -> int:
+        return len(self._current_range())
+
+    @overload
+    def __getitem__(self, index: int) -> object: ...
+    @overload
+    def __getitem__(self, index: slice) -> "sliceview": ...
+
+    def __getitem__(self, index):
+        if isinstance(index, slice):
+            # Compose slices using Python's range slicing — O(1), exact.
+            sub = self._current_range()[index]
+            return sliceview._from_range(self._base, sub)
+
+        cr = self._current_range()
+        length = len(cr)
+        if index < 0:
+            index += length
+        if not (0 <= index < length):
+            raise IndexError("sliceview index out of range")
+        return self._base[cr[index]]
+
+    def __setitem__(self, index, value) -> None:
+        if not hasattr(self._base, "__setitem__"):
+            raise TypeError("underlying sequence is not mutable")
+
+        if isinstance(index, slice):
+            self._setslice(index, value)
+            return
+
+        cr = self._current_range()
+        length = len(cr)
+        if index < 0:
+            index += length
+        if not (0 <= index < length):
+            raise IndexError("sliceview index out of range")
+        self._base[cr[index]] = value
+
+    def __iter__(self) -> Iterator:
+        base = self._base
+        for i in self._current_range():
+            yield base[i]
+
+    def __contains__(self, item) -> bool:
+        return any(item == el for el in self)
+
+    def __reversed__(self) -> Iterator:
+        base = self._base
+        return (base[i] for i in reversed(self._current_range()))
+
+    # ------------------------------------------------------------------
+    # Equality and hashing
+    # ------------------------------------------------------------------
+
+    def __eq__(self, other) -> bool:
+        if isinstance(other, Sequence):
+            return len(self) == len(other) and all(a == b for a, b in zip(self, other))
+        return NotImplemented
+
+    __hash__ = None  # type: ignore[assignment]  # unhashable by design
+
+    # ------------------------------------------------------------------
+    # Repr
+    # ------------------------------------------------------------------
+
+    def __repr__(self) -> str:
+        cr = self._current_range()
+        return f"sliceview({self._base!r})[{cr.start}:{cr.stop}:{cr.step}]"
+
+    # ------------------------------------------------------------------
+    # Advance — sliding-window helper
+    # ------------------------------------------------------------------
+
+    def advance(self, n: int) -> "sliceview":
+        """Shift the view's window forward by *n* index positions in-place.
+
+        Returns *self* so calls can be chained.  Useful for sliding windows:
+
+        >>> data = list(range(10))
+        >>> sv = sliceview(data, 0, 3)
+        >>> list(sv)
+        [0, 1, 2]
+        >>> sv.advance(3)                    # doctest: +ELLIPSIS
+        sliceview(...)[3:6:1]
+        >>> list(sv)
+        [3, 4, 5]
+
+        Parameters
+        ----------
+        n:
+            Positions to advance (negative to retreat).
+        """
+        b_len = len(self._base)
+        cr = self._current_range()
+        new_start = max(0, min(cr.start + n, b_len))
+        delta = new_start - cr.start
+        new_stop = max(0, min(cr.stop + delta, b_len))
+        self._range = range(new_start, new_stop, cr.step)
+        return self
+
+    # ------------------------------------------------------------------
+    # tolist / copy
+    # ------------------------------------------------------------------
+
+    def tolist(self) -> list:
+        """Return a new list containing the elements covered by this view."""
+        return list(self)
+
+    def copy(self) -> list:
+        """Alias for :meth:`tolist`."""
+        return self.tolist()
+
+    # ------------------------------------------------------------------
+    # base property
+    # ------------------------------------------------------------------
+
+    @property
+    def base(self):
+        """The underlying sequence this view points into."""
+        return self._base
+
+    # ------------------------------------------------------------------
+    # Internal helpers
+    # ------------------------------------------------------------------
+
+    def _setslice(self, sl: slice, values) -> None:
+        target_range = self._current_range()[sl]
+        values = list(values)
+
+        if abs(target_range.step) != 1:
+            # Extended slice assignment must match length exactly.
+            if len(values) != len(target_range):
+                raise ValueError(
+                    f"attempt to assign sequence of size {len(values)} "
+                    f"to extended slice of size {len(target_range)}"
+                )
+            for i, v in zip(target_range, values):
+                self._base[i] = v
+        else:
+            # Step ±1: delegate to the base (allows resizing if base supports it).
+            self._base[
+                slice(target_range.start, target_range.stop, target_range.step)
+            ] = values

sliceview-0.1.0/pyproject.toml

@@ -0,0 +1,50 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "sliceview"
+version = "0.1.0"
+description = "Zero-copy, composable slice views for Python sequences"
+readme = "README.md"
+license = { text = "MIT" }
+authors = [
+    { name = "Juliano Fischer Naves", email = "julianofischer@gmail.com" }
+]
+keywords = ["slice", "view", "sequence", "zero-copy", "memory", "performance"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Libraries",
+    "Topic :: Utilities",
+]
+requires-python = ">=3.9"
+dependencies = []
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "pytest-cov",
+]
+
+[project.urls]
+Homepage = "https://github.com/julianofischer/sliceview"
+"Bug Tracker" = "https://github.com/julianofischer/sliceview/issues"
+Discussions = "https://discuss.python.org/t/slice-views-for-python-sequences/103531"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/sliceview"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "-v --tb=short"
+
+[tool.coverage.run]
+source = ["src/sliceview"]

sliceview-0.1.0/test_sliceview.py

@@ -0,0 +1,317 @@
+"""Tests for sliceview."""
+
+import pytest
+from sliceview import sliceview
+
+
+# ---------------------------------------------------------------------------
+# Construction
+# ---------------------------------------------------------------------------
+
+class TestConstruction:
+    def test_basic(self):
+        sv = sliceview([1, 2, 3])
+        assert list(sv) == [1, 2, 3]
+
+    def test_with_start_stop(self):
+        sv = sliceview([0, 1, 2, 3, 4], 1, 4)
+        assert list(sv) == [1, 2, 3]
+
+    def test_with_step(self):
+        sv = sliceview([0, 1, 2, 3, 4], 0, 5, 2)
+        assert list(sv) == [0, 2, 4]
+
+    def test_with_slice_object(self):
+        sv = sliceview([0, 1, 2, 3, 4], slice(1, 4))
+        assert list(sv) == [1, 2, 3]
+
+    def test_negative_step(self):
+        sv = sliceview([0, 1, 2, 3, 4], 4, None, -1)
+        assert list(sv) == [4, 3, 2, 1, 0]
+
+    def test_invalid_base(self):
+        with pytest.raises(TypeError):
+            sliceview(42)
+
+    def test_string_base(self):
+        sv = sliceview("hello")[1:4]
+        assert list(sv) == ["e", "l", "l"]
+
+    def test_tuple_base(self):
+        sv = sliceview((10, 20, 30, 40))[::2]
+        assert list(sv) == [10, 30]
+
+
+# ---------------------------------------------------------------------------
+# Indexing
+# ---------------------------------------------------------------------------
+
+class TestIndexing:
+    def test_positive_index(self):
+        sv = sliceview([10, 20, 30])[:]
+        assert sv[0] == 10
+        assert sv[2] == 30
+
+    def test_negative_index(self):
+        sv = sliceview([10, 20, 30])
+        assert sv[-1] == 30
+        assert sv[-3] == 10
+
+    def test_out_of_range(self):
+        sv = sliceview([1, 2, 3])
+        with pytest.raises(IndexError):
+            _ = sv[10]
+
+    def test_index_into_strided_view(self):
+        sv = sliceview(list(range(10)))[::3]
+        assert sv[0] == 0
+        assert sv[1] == 3
+        assert sv[2] == 6
+
+
+# ---------------------------------------------------------------------------
+# Slicing (composition)
+# ---------------------------------------------------------------------------
+
+class TestSlicing:
+    def test_slice_returns_sliceview(self):
+        sv = sliceview([1, 2, 3, 4, 5])
+        assert isinstance(sv[1:3], sliceview)
+
+    def test_composed_slice(self):
+        data = list(range(20))
+        sv = sliceview(data)[2:][::3][1:4]
+        assert list(sv) == [5, 8, 11]
+
+    def test_no_copy_on_slice(self):
+        data = [1, 2, 3, 4, 5]
+        sv = sliceview(data)
+        sv2 = sv[1:4]
+        assert sv2.base is data
+
+    def test_full_slice_is_same_base(self):
+        data = [1, 2, 3]
+        sv = sliceview(data)
+        assert sv[:].base is data
+
+    def test_negative_step_composition(self):
+        data = list(range(10))
+        sv = sliceview(data)[::-1][::2]
+        assert list(sv) == [9, 7, 5, 3, 1]
+
+    def test_empty_slice(self):
+        sv = sliceview([1, 2, 3])[5:10]
+        assert list(sv) == []
+        assert len(sv) == 0
+
+
+# ---------------------------------------------------------------------------
+# Length
+# ---------------------------------------------------------------------------
+
+class TestLen:
+    def test_full(self):
+        assert len(sliceview([1, 2, 3])) == 3
+
+    def test_partial(self):
+        assert len(sliceview([1, 2, 3, 4, 5])[1:4]) == 3
+
+    def test_step(self):
+        assert len(sliceview(list(range(10)))[::3]) == 4
+
+    def test_empty(self):
+        assert len(sliceview([])) == 0
+
+    def test_reflects_base_mutation(self):
+        data = [1, 2, 3, 4, 5]
+        sv = sliceview(data)
+        assert len(sv) == 5
+        data.append(6)
+        assert len(sv) == 6
+
+
+# ---------------------------------------------------------------------------
+# Mutation (write-through)
+# ---------------------------------------------------------------------------
+
+class TestMutation:
+    def test_setitem_int(self):
+        data = [1, 2, 3, 4, 5]
+        sv = sliceview(data)[1:4]
+        sv[0] = 99
+        assert data == [1, 99, 3, 4, 5]
+
+    def test_setitem_slice(self):
+        data = list(range(5))
+        sv = sliceview(data)
+        sv[1:4] = [10, 20, 30]
+        assert data == [0, 10, 20, 30, 4]
+
+    def test_setitem_strided(self):
+        data = list(range(10))
+        sv = sliceview(data)[::2]
+        sv[0] = 99
+        assert data[0] == 99
+
+    def test_setitem_extended_slice_wrong_size(self):
+        data = list(range(10))
+        sv = sliceview(data)[::2]
+        with pytest.raises(ValueError):
+            sv[0:3] = [1, 2]  # 3 slots, 2 values
+
+    def test_immutable_base_raises(self):
+        sv = sliceview((1, 2, 3))
+        with pytest.raises(TypeError):
+            sv[0] = 99
+
+
+# ---------------------------------------------------------------------------
+# Advance
+# ---------------------------------------------------------------------------
+
+class TestAdvance:
+    def test_advance_basic(self):
+        data = list(range(10))
+        sv = sliceview(data, 0, 3)
+        assert list(sv) == [0, 1, 2]
+        sv.advance(3)
+        assert list(sv) == [3, 4, 5]
+
+    def test_advance_returns_self(self):
+        sv = sliceview(list(range(10)), 0, 5)
+        assert sv.advance(5) is sv
+
+    def test_advance_past_end_clamps(self):
+        data = list(range(5))
+        sv = sliceview(data, 0, 3)
+        sv.advance(100)
+        assert list(sv) == []
+
+    def test_advance_negative(self):
+        data = list(range(10))
+        sv = sliceview(data, 5, 8)
+        sv.advance(-3)
+        assert list(sv) == [2, 3, 4]
+
+    def test_sliding_window(self):
+        data = list(range(12))
+        sv = sliceview(data, 0, 4)
+        result = []
+        for _ in range(3):
+            result.append(list(sv))
+            sv.advance(4)
+        assert result == [[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11]]
+
+
+# ---------------------------------------------------------------------------
+# Iteration
+# ---------------------------------------------------------------------------
+
+class TestIteration:
+    def test_iter(self):
+        sv = sliceview([10, 20, 30, 40])[1:3]
+        assert list(sv) == [20, 30]
+
+    def test_contains(self):
+        sv = sliceview([1, 2, 3, 4, 5])[1:4]
+        assert 2 in sv
+        assert 5 not in sv
+
+    def test_reversed(self):
+        sv = sliceview([1, 2, 3, 4, 5])
+        assert list(reversed(sv)) == [5, 4, 3, 2, 1]
+
+
+# ---------------------------------------------------------------------------
+# Equality and hashing
+# ---------------------------------------------------------------------------
+
+class TestEquality:
+    def test_equal_to_list(self):
+        sv = sliceview([1, 2, 3])
+        assert sv == [1, 2, 3]
+
+    def test_equal_to_sliceview(self):
+        data = [1, 2, 3, 4]
+        sv1 = sliceview(data)[1:3]
+        sv2 = sliceview(data)[1:3]
+        assert sv1 == sv2
+
+    def test_not_equal(self):
+        sv = sliceview([1, 2, 3])
+        assert sv != [1, 2, 4]
+
+    def test_unhashable(self):
+        sv = sliceview([1, 2, 3])
+        with pytest.raises(TypeError):
+            hash(sv)
+
+
+# ---------------------------------------------------------------------------
+# Repr
+# ---------------------------------------------------------------------------
+
+class TestRepr:
+    def test_repr_contains_slice(self):
+        sv = sliceview([1, 2, 3, 4])[1:3]
+        r = repr(sv)
+        assert "sliceview" in r
+        assert "1:3" in r
+
+    def test_repr_full(self):
+        sv = sliceview([1, 2, 3])
+        r = repr(sv)
+        assert "sliceview" in r
+
+
+# ---------------------------------------------------------------------------
+# tolist / copy
+# ---------------------------------------------------------------------------
+
+class TestCopy:
+    def test_tolist(self):
+        data = [1, 2, 3, 4, 5]
+        sv = sliceview(data)[1:4]
+        result = sv.tolist()
+        assert result == [2, 3, 4]
+        assert isinstance(result, list)
+        result[0] = 99
+        assert data[1] == 2  # original unchanged
+
+    def test_copy(self):
+        sv = sliceview([1, 2, 3])
+        assert sv.copy() == [1, 2, 3]
+
+
+# ---------------------------------------------------------------------------
+# base property
+# ---------------------------------------------------------------------------
+
+class TestBase:
+    def test_base_is_original(self):
+        data = [1, 2, 3]
+        sv = sliceview(data)
+        assert sv.base is data
+
+    def test_composed_base_is_original(self):
+        data = [1, 2, 3, 4, 5]
+        sv = sliceview(data)[1:][::2]
+        assert sv.base is data
+
+
+# ---------------------------------------------------------------------------
+# Live mutation reflection
+# ---------------------------------------------------------------------------
+
+class TestLiveMutation:
+    def test_write_through(self):
+        data = [1, 2, 3, 4, 5]
+        sv = sliceview(data)
+        data[2] = 99
+        assert sv[2] == 99
+
+    def test_append_reflected_in_len(self):
+        data = [1, 2, 3]
+        sv = sliceview(data)
+        data.append(4)
+        assert len(sv) == 4