diff --git a/CHANGELOG.md b/CHANGELOG.md index 7cf6d96..8013b8f 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,20 @@ +## 0.5.0 (2022-10-11) + +### Changes + +- Functions taking `Predicate[T]` have been updated to accept `Optional[Predicate[T]]`. + Passing `None` as an argument is identical to passing `bool`. + + There are three functions which do not accept `None`, though: + - `drop_while` + - `skip_while` + - `take_while` + + This choice is motivated by the fact that it does not make much sense to `do_while(None)`. + ## 0.4.0 (2022-10-08) ### Changes diff --git a/README.md b/README.md index f6bfe15..d6adc72 100644 --- a/README.md +++ b/README.md @@ -48,7 +48,7 @@ Or by directly specifying it in the configuration like so: ```toml [tool.poetry.dependencies] -iters = "^0.4.0" +iters = "^0.5.0" ``` Alternatively, you can add it directly from the source: diff --git a/iters/__init__.py b/iters/__init__.py index 32c8ea2..aa83c15 100644 --- a/iters/__init__.py +++ b/iters/__init__.py @@ -11,7 +11,7 @@ __title__ = "iters" __author__ = "nekitdev" __license__ = "MIT" -__version__ = "0.4.0" +__version__ = "0.5.0" from iters.async_iters import ( AsyncIter, diff --git a/iters/async_iters.py b/iters/async_iters.py index f6eab85..670ab88 100644 --- a/iters/async_iters.py +++ b/iters/async_iters.py @@ -1273,7 +1273,7 @@ async def all_unique_fast_by(self, key: Unary[T, Q]) -> bool: async def all_unique_fast_by_await(self, key: AsyncUnary[T, Q]) -> bool: return await async_all_unique_fast_await(self.iterator, key) - def remove(self, predicate: Predicate[T]) -> AsyncIter[T]: + def remove(self, predicate: Optional[Predicate[T]]) -> AsyncIter[T]: return self.create(async_remove(predicate, self.iterator)) def remove_await(self, predicate: AsyncPredicate[T]) -> AsyncIter[T]: @@ -1288,13 +1288,13 @@ def remove_duplicates_by(self, key: Unary[T, U]) -> AsyncIter[T]: def remove_duplicates_by_await(self, key: AsyncUnary[T, U]) -> AsyncIter[T]: return self.create(async_remove_duplicates_await(self.iterator, key)) - def filter(self, predicate: Predicate[T]) -> AsyncIter[T]: + def filter(self, predicate: Optional[Predicate[T]]) -> AsyncIter[T]: return self.create(async_filter(predicate, self.iterator)) def filter_await(self, predicate: AsyncPredicate[T]) -> AsyncIter[T]: return self.create(async_filter_await(predicate, self.iterator)) - def filter_false(self, predicate: Predicate[T]) -> AsyncIter[T]: + def filter_false(self, predicate: Optional[Predicate[T]]) -> AsyncIter[T]: return self.create(async_filter_false(predicate, self.iterator)) def filter_false_await(self, predicate: AsyncPredicate[T]) -> AsyncIter[T]: @@ -1311,19 +1311,19 @@ def filter_except_await( def compress(self, selectors: AnySelectors) -> AsyncIter[T]: return self.create(async_compress(self.iterator, selectors)) - def position_all(self, predicate: Predicate[T]) -> AsyncIter[int]: + def position_all(self, predicate: Optional[Predicate[T]]) -> AsyncIter[int]: return self.create(async_position_all(predicate, self.iterator)) def position_all_await(self, predicate: AsyncPredicate[T]) -> AsyncIter[int]: return self.create(async_position_all_await(predicate, self.iterator)) - async def position(self, predicate: Predicate[T]) -> int: + async def position(self, predicate: Optional[Predicate[T]]) -> int: return await async_position(predicate, self.iterator) - async def position_or(self, predicate: Predicate[T], default: V) -> Union[int, V]: + async def position_or(self, predicate: Optional[Predicate[T]], default: V) -> Union[int, V]: return await async_position(predicate, self.iterator, default) - async def position_or_none(self, predicate: Predicate[T]) -> Optional[int]: + async def position_or_none(self, predicate: Optional[Predicate[T]]) -> Optional[int]: return await self.position_or(predicate, None) async def position_await(self, predicate: AsyncPredicate[T]) -> int: @@ -1335,19 +1335,19 @@ async def position_await_or(self, predicate: AsyncPredicate[T], default: V) -> U async def position_await_or_none(self, predicate: AsyncPredicate[T]) -> Optional[int]: return await self.position_await_or(predicate, None) - def find_all(self, predicate: Predicate[T]) -> AsyncIter[T]: + def find_all(self, predicate: Optional[Predicate[T]]) -> AsyncIter[T]: return self.create(async_find_all(predicate, self.iterator)) def find_all_await(self, predicate: AsyncPredicate[T]) -> AsyncIter[T]: return self.create(async_find_all_await(predicate, self.iterator)) - async def find(self, predicate: Predicate[T]) -> T: + async def find(self, predicate: Optional[Predicate[T]]) -> T: return await async_find(predicate, self.iterator) - async def find_or(self, predicate: Predicate[T], default: V) -> Union[T, V]: + async def find_or(self, predicate: Optional[Predicate[T]], default: V) -> Union[T, V]: return await async_find(predicate, self.iterator, default) # type: ignore # strange - async def find_or_none(self, predicate: Predicate[T]) -> Optional[T]: + async def find_or_none(self, predicate: Optional[Predicate[T]]) -> Optional[T]: return await self.find_or(predicate, None) async def find_await(self, predicate: AsyncPredicate[T]) -> T: @@ -1359,13 +1359,13 @@ async def find_await_or(self, predicate: AsyncPredicate[T], default: V) -> Union async def find_await_or_none(self, predicate: AsyncPredicate[T]) -> Optional[T]: return await self.find_await_or(predicate, None) - async def find_or_first(self, predicate: Predicate[T]) -> T: + async def find_or_first(self, predicate: Optional[Predicate[T]]) -> T: return await async_find_or_first(predicate, self.iterator) - async def find_or_first_or(self, predicate: Predicate[T], default: V) -> Union[T, V]: + async def find_or_first_or(self, predicate: Optional[Predicate[T]], default: V) -> Union[T, V]: return await async_find_or_first(predicate, self.iterator, default) # type: ignore # strange - async def find_or_first_or_none(self, predicate: Predicate[T]) -> Optional[T]: + async def find_or_first_or_none(self, predicate: Optional[Predicate[T]]) -> Optional[T]: return await self.find_or_first_or(predicate, None) async def find_or_first_await(self, predicate: AsyncPredicate[T]) -> T: @@ -1377,13 +1377,13 @@ async def find_or_first_await_or(self, predicate: AsyncPredicate[T], default: V) async def find_or_first_await_or_none(self, predicate: AsyncPredicate[T]) -> Optional[T]: return await self.find_or_first_await_or(predicate, None) - async def find_or_last(self, predicate: Predicate[T]) -> T: + async def find_or_last(self, predicate: Optional[Predicate[T]]) -> T: return await async_find_or_last(predicate, self.iterator) - async def find_or_last_or(self, predicate: Predicate[T], default: V) -> Union[T, V]: + async def find_or_last_or(self, predicate: Optional[Predicate[T]], default: V) -> Union[T, V]: return await async_find_or_last(predicate, self.iterator, default) # type: ignore # strange - async def find_or_last_or_none(self, predicate: Predicate[T]) -> Optional[T]: + async def find_or_last_or_none(self, predicate: Optional[Predicate[T]]) -> Optional[T]: return await self.find_or_last_or(predicate, None) async def find_or_last_await(self, predicate: AsyncPredicate[T]) -> T: @@ -1555,13 +1555,13 @@ def flat_map(self, function: Unary[T, AnyIterable[U]]) -> AsyncIter[U]: def flat_map_await(self, function: AsyncUnary[T, AnyIterable[U]]) -> AsyncIter[U]: return self.create(async_flat_map_await(function, self.iterator)) - def filter_map(self, predicate: Predicate[T], function: Unary[T, U]) -> AsyncIter[U]: + def filter_map(self, predicate: Optional[Predicate[T]], function: Unary[T, U]) -> AsyncIter[U]: return self.create(async_filter_map(predicate, function, self.iterator)) def filter_await_map(self, predicate: AsyncPredicate[T], function: Unary[T, U]) -> AsyncIter[U]: return self.create(async_filter_await_map(predicate, function, self.iterator)) - def filter_map_await(self, predicate: Predicate[T], function: AsyncUnary[T, U]) -> AsyncIter[U]: + def filter_map_await(self, predicate: Optional[Predicate[T]], function: AsyncUnary[T, U]) -> AsyncIter[U]: return self.create(async_filter_map_await(predicate, function, self.iterator)) def filter_await_map_await( @@ -1569,7 +1569,7 @@ def filter_await_map_await( ) -> AsyncIter[U]: return self.create(async_filter_await_map_await(predicate, function, self.iterator)) - def filter_false_map(self, predicate: Predicate[T], function: Unary[T, U]) -> AsyncIter[U]: + def filter_false_map(self, predicate: Optional[Predicate[T]], function: Unary[T, U]) -> AsyncIter[U]: return self.create(async_filter_false_map(predicate, function, self.iterator)) def filter_false_await_map( @@ -1578,7 +1578,7 @@ def filter_false_await_map( return self.create(async_filter_false_await_map(predicate, function, self.iterator)) def filter_false_map_await( - self, predicate: Predicate[T], function: AsyncUnary[T, U] + self, predicate: Optional[Predicate[T]], function: AsyncUnary[T, U] ) -> AsyncIter[U]: return self.create(async_filter_false_map_await(predicate, function, self.iterator)) @@ -2784,7 +2784,7 @@ def unique_by(self, key: Unary[T, V]) -> AsyncIter[T]: def unique_by_await(self, key: AsyncUnary[T, V]) -> AsyncIter[T]: return self.create(async_unique_await(self.iterator, key)) - def partition(self, predicate: Predicate[T]) -> Tuple[AsyncIter[T], AsyncIter[T]]: + def partition(self, predicate: Optional[Predicate[T]]) -> Tuple[AsyncIter[T], AsyncIter[T]]: true, false = async_partition(predicate, self.iterator) return (self.create(true), self.create(false)) @@ -2794,11 +2794,13 @@ def partition_await(self, predicate: AsyncPredicate[T]) -> Tuple[AsyncIter[T], A return (self.create(true), self.create(false)) - def partition_unsafe(self, predicate: Predicate[T]) -> Tuple[AsyncIter[T], AsyncIter[T]]: + def partition_unsafe(self, predicate: Optional[Predicate[T]]) -> Tuple[AsyncIter[T], AsyncIter[T]]: true, false = async_partition_unsafe(predicate, self.iterator) return (self.create(true), self.create(false)) + partition_infinite = partition_unsafe + def partition_unsafe_await( self, predicate: AsyncPredicate[T] ) -> Tuple[AsyncIter[T], AsyncIter[T]]: @@ -2806,7 +2808,7 @@ def partition_unsafe_await( return (self.create(true), self.create(false)) - partition_infinite = partition_unsafe + partition_infinite_await = partition_unsafe_await def copy(self) -> AsyncIter[T]: iterator, result = async_copy(self.iterator) diff --git a/iters/async_utils.py b/iters/async_utils.py index ea4d4a7..6e7ca20 100644 --- a/iters/async_utils.py +++ b/iters/async_utils.py @@ -2681,13 +2681,13 @@ async def async_find_await( @overload -async def async_find_or_first(predicate: Predicate[T], iterable: AnyIterable[T]) -> T: +async def async_find_or_first(predicate: Optional[Predicate[T]], iterable: AnyIterable[T]) -> T: ... # pragma: overload @overload async def async_find_or_first( - predicate: Predicate[T], iterable: AnyIterable[T], default: U + predicate: Optional[Predicate[T]], iterable: AnyIterable[T], default: U ) -> Union[T, U]: ... # pragma: overload @@ -4649,21 +4649,14 @@ async def async_cycle(iterable: AnyIterable[T]) -> AsyncIterator[T]: async def async_drop_while( - predicate: Optional[Predicate[T]], iterable: AnyIterable[T] + predicate: Predicate[T], iterable: AnyIterable[T] ) -> AsyncIterator[T]: iterator = async_iter(iterable) - if predicate is None: - async for item in iterator: - if not item: - yield item - break - - else: - async for item in iterator: - if not predicate(item): - yield item - break + async for item in iterator: + if not predicate(item): + yield item + break async for item in iterator: yield item @@ -4690,25 +4683,14 @@ async def async_drop_while_await( async def async_take_while( - predicate: Optional[Predicate[T]], iterable: AnyIterable[T] + predicate: Predicate[T], iterable: AnyIterable[T] ) -> AsyncIterator[T]: - iterator = async_iter(iterable) - - if predicate is None: - async for item in iterator: - if item: - yield item - - else: - break - - else: - async for item in iterator: - if predicate(item): - yield item + async for item in async_iter(iterable): + if predicate(item): + yield item - else: - break + else: + break async def async_take_while_await( diff --git a/iters/iters.py b/iters/iters.py index c322f86..8cec5d9 100644 --- a/iters/iters.py +++ b/iters/iters.py @@ -1164,7 +1164,7 @@ def all_unique_fast(self: Iter[Q]) -> bool: def all_unique_fast_by(self, key: Unary[T, Q]) -> bool: return all_unique_fast(self.iterator, key) - def remove(self, predicate: Predicate[T]) -> Iter[T]: + def remove(self, predicate: Optional[Predicate[T]]) -> Iter[T]: return self.create(remove(predicate, self.iterator)) def remove_duplicates(self) -> Iter[T]: @@ -1173,10 +1173,10 @@ def remove_duplicates(self) -> Iter[T]: def remove_duplicates_by(self, key: Unary[T, U]) -> Iter[T]: return self.create(remove_duplicates(self.iterator, key)) - def filter(self, predicate: Predicate[T]) -> Iter[T]: + def filter(self, predicate: Optional[Predicate[T]]) -> Iter[T]: return self.create(filter(predicate, self.iterator)) - def filter_false(self, predicate: Predicate[T]) -> Iter[T]: + def filter_false(self, predicate: Optional[Predicate[T]]) -> Iter[T]: return self.create(filter_false(predicate, self.iterator)) def filter_except(self, validate: Unary[T, Any], *errors: AnyExceptionType) -> Iter[T]: @@ -1185,46 +1185,46 @@ def filter_except(self, validate: Unary[T, Any], *errors: AnyExceptionType) -> I def compress(self, selectors: Selectors) -> Iter[T]: return self.create(compress(self.iterator, selectors)) - def position_all(self, predicate: Predicate[T]) -> Iter[int]: + def position_all(self, predicate: Optional[Predicate[T]]) -> Iter[int]: return self.create(position_all(predicate, self.iterator)) - def position(self, predicate: Predicate[T]) -> int: + def position(self, predicate: Optional[Predicate[T]]) -> int: return position(predicate, self.iterator) - def position_or(self, predicate: Predicate[T], default: V) -> Union[int, V]: + def position_or(self, predicate: Optional[Predicate[T]], default: V) -> Union[int, V]: return position(predicate, self.iterator, default) - def position_or_none(self, predicate: Predicate[T]) -> Optional[int]: + def position_or_none(self, predicate: Optional[Predicate[T]]) -> Optional[int]: return self.position_or(predicate, None) - def find_all(self, predicate: Predicate[T]) -> Iter[T]: + def find_all(self, predicate: Optional[Predicate[T]]) -> Iter[T]: return self.create(find_all(predicate, self.iterator)) - def find(self, predicate: Predicate[T]) -> T: + def find(self, predicate: Optional[Predicate[T]]) -> T: return find(predicate, self.iterator) - def find_or(self, predicate: Predicate[T], default: V) -> Union[T, V]: + def find_or(self, predicate: Optional[Predicate[T]], default: V) -> Union[T, V]: return find(predicate, self.iterator, default) # type: ignore # strange - def find_or_none(self, predicate: Predicate[T]) -> Optional[T]: + def find_or_none(self, predicate: Optional[Predicate[T]]) -> Optional[T]: return self.find_or(predicate, None) - def find_or_first(self, predicate: Predicate[T]) -> T: + def find_or_first(self, predicate: Optional[Predicate[T]]) -> T: return find_or_first(predicate, self.iterator) - def find_or_first_or(self, predicate: Predicate[T], default: V) -> Union[T, V]: + def find_or_first_or(self, predicate: Optional[Predicate[T]], default: V) -> Union[T, V]: return find_or_first(predicate, self.iterator, default) # type: ignore # strange - def find_or_first_or_none(self, predicate: Predicate[T]) -> Optional[T]: + def find_or_first_or_none(self, predicate: Optional[Predicate[T]]) -> Optional[T]: return self.find_or_first_or(predicate, None) - def find_or_last(self, predicate: Predicate[T]) -> T: + def find_or_last(self, predicate: Optional[Predicate[T]]) -> T: return find_or_last(predicate, self.iterator) - def find_or_last_or(self, predicate: Predicate[T], default: V) -> Union[T, V]: + def find_or_last_or(self, predicate: Optional[Predicate[T]], default: V) -> Union[T, V]: return find_or_last(predicate, self.iterator, default) # type: ignore # strange - def find_or_last_or_none(self, predicate: Predicate[T]) -> Optional[T]: + def find_or_last_or_none(self, predicate: Optional[Predicate[T]]) -> Optional[T]: return self.find_or_last_or(predicate, None) def contains(self, item: V) -> bool: @@ -1328,10 +1328,10 @@ def map_except(self, function: Unary[T, U], *errors: AnyExceptionType) -> Iter[U def flat_map(self, function: Unary[T, Iterable[U]]) -> Iter[U]: return self.create(flat_map(function, self.iterator)) - def filter_map(self, predicate: Predicate[T], function: Unary[T, U]) -> Iter[U]: + def filter_map(self, predicate: Optional[Predicate[T]], function: Unary[T, U]) -> Iter[U]: return self.create(filter_map(predicate, function, self.iterator)) - def filter_false_map(self, predicate: Predicate[T], function: Unary[T, U]) -> Iter[U]: + def filter_false_map(self, predicate: Optional[Predicate[T]], function: Unary[T, U]) -> Iter[U]: return self.create(filter_false_map(predicate, function, self.iterator)) def flatten(self: Iter[Iterable[U]]) -> Iter[U]: diff --git a/iters/utils.py b/iters/utils.py index cd09bc0..8cd950d 100644 --- a/iters/utils.py +++ b/iters/utils.py @@ -947,7 +947,7 @@ def filter_false_map( def partition_unsafe( - predicate: Predicate[T], iterable: Iterable[T] + predicate: Optional[Predicate[T]], iterable: Iterable[T] ) -> Tuple[Iterator[T], Iterator[T]]: for_true, for_false = copy_unsafe(iterable) @@ -957,7 +957,7 @@ def partition_unsafe( partition_infinite = partition_unsafe -def partition(predicate: Predicate[T], iterable: Iterable[T]) -> Tuple[Iterator[T], Iterator[T]]: +def partition(predicate: Optional[Predicate[T]], iterable: Iterable[T]) -> Tuple[Iterator[T], Iterator[T]]: for_true, for_false = copy(iterable) return filter(predicate, for_true), filter_false(predicate, for_false) @@ -1251,7 +1251,7 @@ def all_equal(iterable: Iterable[T], key: Optional[Unary[T, U]] = None) -> bool: return next(groups, marker) is marker or next(groups, marker) is marker -def remove(predicate: Predicate[T], iterable: Iterable[T]) -> Iterator[T]: +def remove(predicate: Optional[Predicate[T]], iterable: Iterable[T]) -> Iterator[T]: return filter_false(predicate, iterable) @@ -1491,26 +1491,32 @@ def interleave_longest(*iterables: Iterable[T]) -> Iterator[T]: return (item for item in iterator if item is not marker) # type: ignore -def position_all(predicate: Predicate[T], iterable: Iterable[T]) -> Iterator[int]: - for index, item in enumerate(iterable): - if predicate(item): - yield index +def position_all(predicate: Optional[Predicate[T]], iterable: Iterable[T]) -> Iterator[int]: + if predicate is None: + for index, item in enumerate(iterable): + if item: + yield index + + else: + for index, item in enumerate(iterable): + if predicate(item): + yield index POSITION_NO_MATCH = "position() has not found any matches" @overload -def position(predicate: Predicate[T], iterable: Iterable[T]) -> int: +def position(predicate: Optional[Predicate[T]], iterable: Iterable[T]) -> int: ... # pragma: overload @overload -def position(predicate: Predicate[T], iterable: Iterable[T], default: U) -> Union[int, U]: +def position(predicate: Optional[Predicate[T]], iterable: Iterable[T], default: U) -> Union[int, U]: ... # pragma: overload -def position(predicate: Predicate[T], iterable: Iterable[T], default: Any = no_default) -> Any: +def position(predicate: Optional[Predicate[T]], iterable: Iterable[T], default: Any = no_default) -> Any: index = next(position_all(predicate, iterable), None) if index is None: @@ -1522,7 +1528,7 @@ def position(predicate: Predicate[T], iterable: Iterable[T], default: Any = no_d return index -def find_all(predicate: Predicate[T], iterable: Iterable[T]) -> Iterator[T]: +def find_all(predicate: Optional[Predicate[T]], iterable: Iterable[T]) -> Iterator[T]: return filter(predicate, iterable) @@ -1531,21 +1537,27 @@ def find_all(predicate: Predicate[T], iterable: Iterable[T]) -> Iterator[T]: @overload -def find(predicate: Predicate[T], iterable: Iterable[T]) -> T: +def find(predicate: Optional[Predicate[T]], iterable: Iterable[T]) -> T: ... # pragma: overload @overload -def find(predicate: Predicate[T], iterable: Iterable[T], default: U) -> Union[T, U]: +def find(predicate: Optional[Predicate[T]], iterable: Iterable[T], default: U) -> Union[T, U]: ... # pragma: overload -def find(predicate: Predicate[Any], iterable: Iterable[Any], default: Any = no_default) -> Any: +def find(predicate: Optional[Predicate[Any]], iterable: Iterable[Any], default: Any = no_default) -> Any: item = marker - for item in iterable: - if predicate(item): - return item + if predicate is None: + for item in iterable: + if item: + return item + + else: + for item in iterable: + if predicate(item): + return item if default is no_default: raise ValueError(FIND_ON_EMPTY if item is marker else FIND_NO_MATCH) @@ -1557,17 +1569,17 @@ def find(predicate: Predicate[Any], iterable: Iterable[Any], default: Any = no_d @overload -def find_or_first(predicate: Predicate[T], iterable: Iterable[T]) -> T: +def find_or_first(predicate: Optional[Predicate[T]], iterable: Iterable[T]) -> T: ... # pragma: overload @overload -def find_or_first(predicate: Predicate[T], iterable: Iterable[T], default: U) -> Union[T, U]: +def find_or_first(predicate: Optional[Predicate[T]], iterable: Iterable[T], default: U) -> Union[T, U]: ... # pragma: overload def find_or_first( - predicate: Predicate[Any], iterable: Iterable[Any], default: Any = no_default + predicate: Optional[Predicate[Any]], iterable: Iterable[Any], default: Any = no_default ) -> Any: iterator = iter(iterable) @@ -1579,9 +1591,17 @@ def find_or_first( first = default - for item in prepend(first, iterator): - if predicate(item): - return item + iterator = prepend(first, iterator) + + if predicate is None: + for item in iterator: + if item: + return item + + else: + for item in iterator: + if predicate(item): + return item return first @@ -1590,23 +1610,29 @@ def find_or_first( @overload -def find_or_last(predicate: Predicate[T], iterable: Iterable[T]) -> T: +def find_or_last(predicate: Optional[Predicate[T]], iterable: Iterable[T]) -> T: ... # pragma: overload @overload -def find_or_last(predicate: Predicate[T], iterable: Iterable[T], default: U) -> Union[T, U]: +def find_or_last(predicate: Optional[Predicate[T]], iterable: Iterable[T], default: U) -> Union[T, U]: ... # pragma: overload def find_or_last( - predicate: Predicate[Any], iterable: Iterable[Any], default: Any = no_default + predicate: Optional[Predicate[Any]], iterable: Iterable[Any], default: Any = no_default ) -> Any: item = marker - for item in iterable: - if predicate(item): - return item + if predicate is None: + for item in iterable: + if item: + return item + + else: + for item in iterable: + if predicate(item): + return item if item is marker: if default is no_default: diff --git a/pyproject.toml b/pyproject.toml index 5b1ef00..82c894f 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [tool.poetry] name = "iters" -version = "0.4.0" +version = "0.5.0" description = "Composable external iteration." authors = ["nekitdev"] license = "MIT" @@ -131,7 +131,7 @@ warn_unused_ignores = false # compatibility [tool.changelogging] name = "iters" -version = "0.4.0" +version = "0.5.0" url = "https://github.com/nekitdev/iters" directory = "changes" output = "CHANGELOG.md"