add range(), increase to 0.0.4

as well as add some class comment strings

Author: cleoold

setup.py

@@ -5,7 +5,7 @@
 
 setup(
     name='types-linq',
-    version='v0.0.3',
+    version='v0.0.4',
     url='https://github.com/cleoold/types-linq',
     license='GNU General Public License v3',
     author='cleoold',

tests/test_usage.py

@@ -1,5 +1,6 @@
 import math
 from typing import Generic, Iterable, List, NamedTuple, Sequence, Tuple, TypeVar, cast
+from _pytest.python_api import raises
 
 import pytest
 
@@ -815,6 +816,31 @@ def test_no_mutate(self):
         assert en2.to_list() == [8, 7, 10]
 
 
+class TestRangeMethod:
+    def test_range(self):
+        ints = Enumerable.range(0, 6)
+        assert ints.to_list() == [0, 1, 2, 3, 4, 5]
+        ints2 = Enumerable.range(1, 10).select(lambda x: x * x)
+        assert ints2.to_list() == [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
+
+    def test_no_elem(self):
+        ints = Enumerable.range(5, 0)
+        assert ints.to_list() == []
+
+    def test_1_elem(self):
+        ints = Enumerable.range(9, 1)
+        assert ints.to_list() == [9]
+
+    def test_invalid(self):
+        with pytest.raises(ValueError):
+            Enumerable.range(99, -1)
+
+    def test_no_end(self):
+        ints = Enumerable.range(77, None)
+        lst = ints.take(100).to_list()
+        assert lst == [*range(77, 177)]
+
+
 class TestSelectMethod:
     def test_select(self):
         gen_func = lambda: (i for i in range(4))

types_linq/enumerable.py

@@ -1,5 +1,5 @@
 from __future__ import annotations
-from typing import Any, Callable, Container, Dict, Iterable, Iterator, List, NoReturn, Reversible, Sequence, Set, Sized, TYPE_CHECKING, Tuple, Type, Generic, Union
+from typing import Any, Callable, Container, Dict, Iterable, Iterator, List, NoReturn, Optional, Reversible, Sequence, Set, Sized, TYPE_CHECKING, Tuple, Type, Generic, Union
 
 if TYPE_CHECKING:
     from .lookup import Lookup
@@ -521,6 +521,23 @@ def inner():
             yield from self
         return Enumerable(inner)
 
+    @staticmethod
+    def range(start: int, count: Optional[int]) -> Enumerable[int]:
+        if count is not None:
+            if count < 0:
+                raise ValueError('count must be nonnegative')
+            def inner(curr=start, cnt=count):
+                while cnt > 0:
+                    yield curr
+                    curr += 1
+                    cnt -= 1
+        else:
+            def inner(curr=start):
+                while True:
+                    yield curr
+                    curr += 1
+        return Enumerable(inner)
+
     def reverse(self) -> Enumerable[TSource_co]:
         return Enumerable(lambda: self._reversed_impl(fallback=True))
 

types_linq/enumerable.pyi

@@ -1,4 +1,4 @@
-from typing import Callable, Dict, Generic, Iterable, Iterator, List, Sequence, Set, Tuple, Type, Union, overload
+from typing import Callable, Dict, Generic, Iterable, Iterator, List, Optional, Sequence, Set, Tuple, Type, Union, overload
 
 from .lookup import Lookup
 from .grouping import Grouping
@@ -19,6 +19,9 @@ from .more_typing import (
 
 
 class Enumerable(Sequence[TSource_co], Generic[TSource_co]):
+    '''
+    Provides a set of helper methods for querying iterable objects.
+    '''
 
     @overload
     def __init__(self, iterable: Iterable[TSource_co]):
@@ -468,6 +471,15 @@ class Enumerable(Sequence[TSource_co], Generic[TSource_co]):
         Adds a value to the beginning of the sequence.
         '''
 
+    # count: Optional[int] is nonstandard behavior
+    @staticmethod
+    def range(start: int, count: Optional[int]) -> Enumerable[int]:
+        '''
+        Generates a sequence of `count` integral numbers from `start`, incrementing each by one.
+
+        If `count` is `None`, the sequence is infinite.
+        '''
+
     # @@@ TODO
 
     def reverse(self) -> Enumerable[TSource_co]:

types_linq/grouping.py

@@ -12,6 +12,9 @@
 # kind of respect IGrouping's covariant type parameters if the method _append()
 # is really treated as an internal method
 class Grouping(Enumerable[TValue_co], Generic[TKey_co, TValue_co]):
+    '''
+    Represents a collection of objects that have a common key.
+    '''
 
     _key: TKey_co
     _values: List[TValue_co]

types_linq/lookup.py

@@ -16,7 +16,7 @@
 # weird.
 class Lookup(Enumerable[Grouping[TKey_co, TValue_co]]):
     '''
-    A lookup is a one-to-many dictionary.
+    A lookup is a one-to-many dictionary. It maps keys to Enumerable sequences of values.
     '''
 
     _groupings: Dict[TKey_co, Grouping[TKey_co, TValue_co]]

types_linq/ordered_enumerable.pyi

@@ -11,6 +11,9 @@ from .more_typing import (
 
 
 class OrderedEnumerable(Enumerable[TSource_co], Generic[TSource_co, TKey]):
+    '''
+    Represents a sorted Enumerable sequence that is sorted by some key.
+    '''
 
     def __init__(self, *args): ...