Various simplifications, use comprehensions, helps typing. (#193)

* Various simplifications

* inline

* simplify

* revert `if not initial`

* revert inline if else

* revert next() instead of a loop

Author: artemisart

functional/io.py

@@ -65,8 +65,7 @@ def __iter__(self):
             errors=self.errors,
             newline=self.newline,
         ) as file_content:
-            for line in file_content:
-                yield line
+            yield from file_content
 
     def read(self):
         # pylint: disable=no-member
@@ -148,14 +147,12 @@ def __iter__(self):
                     errors=self.errors,
                     newline=self.newline,
                 ) as file_content:
-                    for line in file_content:
-                        yield line
+                    yield from file_content
         else:
             with gzip.open(
                 self.path, mode=self.mode, compresslevel=self.compresslevel
             ) as file_content:
-                for line in file_content:
-                    yield line
+                yield from file_content
 
     def read(self):
         with gzip.GzipFile(self.path, compresslevel=self.compresslevel) as gz_file:
@@ -204,8 +201,7 @@ def __iter__(self):
             errors=self.errors,
             newline=self.newline,
         ) as file_content:
-            for line in file_content:
-                yield line
+            yield from file_content
 
     def read(self):
         with bz2.open(
@@ -265,8 +261,7 @@ def __iter__(self):
             errors=self.errors,
             newline=self.newline,
         ) as file_content:
-            for line in file_content:
-                yield line
+            yield from file_content
 
     def read(self):
         with lzma.open(
@@ -290,14 +285,12 @@ def read(self):
 def get_read_function(filename: str, disable_compression: bool):
     if disable_compression:
         return ReusableFile
-    else:
-        with open(filename, "rb") as f:
-            start_bytes = f.read(N_COMPRESSION_CHECK_BYTES)
-            for cls in COMPRESSION_CLASSES:
-                if cls.is_compressed(start_bytes):
-                    return cls
-
-            return ReusableFile
+    with open(filename, "rb") as f:
+        start_bytes = f.read(N_COMPRESSION_CHECK_BYTES)
+        for cls in COMPRESSION_CLASSES:
+            if cls.is_compressed(start_bytes):
+                return cls
+        return ReusableFile
 
 
 def universal_write_open(

functional/pipeline.py

@@ -195,12 +195,9 @@ def _transform(self, *transforms):
         :param transform: transform to apply or list of transforms to apply
         :return: transformed sequence
         """
-        sequence = None
+        sequence = self
         for transform in transforms:
-            if sequence:
-                sequence = Sequence(sequence, transform=transform, no_wrap=self.no_wrap)
-            else:
-                sequence = Sequence(self, transform=transform, no_wrap=self.no_wrap)
+            sequence = Sequence(sequence, transform=transform, no_wrap=self.no_wrap)
         return sequence
 
     @property
@@ -631,11 +628,7 @@ def count(self, func):
         :param func: predicate to count elements on
         :return: count of elements that satisfy predicate
         """
-        n = 0
-        for element in self:
-            if func(element):
-                n += 1
-        return n
+        return sum(bool(func(element)) for element in self)
 
     def len(self):
         """
@@ -726,10 +719,7 @@ def exists(self, func):
         :param func: existence check function
         :return: True if any element satisfies func
         """
-        for element in self:
-            if func(element):
-                return True
-        return False
+        return any(func(element) for element in self)
 
     def for_all(self, func):
         """
@@ -744,10 +734,7 @@ def for_all(self, func):
         :param func: function to check truth value of all elements with
         :return: True if all elements make func evaluate to True
         """
-        for element in self:
-            if not func(element):
-                return False
-        return True
+        return all(func(element) for element in self)
 
     def max(self):
         """
@@ -872,10 +859,7 @@ def find(self, func):
         :param func: function to find with
         :return: first element to satisfy func or None
         """
-        for element in self:
-            if func(element):
-                return element
-        return None
+        return next((element for element in self if func(element)), None)
 
     def flatten(self):
         """
@@ -1479,9 +1463,7 @@ def to_dict(self, default=None):
             value and used for collections.defaultdict
         :return: dictionary from sequence of (Key, Value) elements
         """
-        dictionary = {}
-        for e in self.sequence:
-            dictionary[e[0]] = e[1]
+        dictionary = dict(self.sequence)
         if default is None:
             return dictionary
         else:
@@ -1882,6 +1864,7 @@ def make_set(it):
     """
     if func is None:
         return partial(extend, aslist=aslist, final=final, name=name, parallel=parallel)
+    assert func is not None  # this is for mypy
 
     @wraps(func)
     def wrapper(self, *args, **kwargs):

functional/test/test_functional.py

@@ -65,7 +65,7 @@ def test_repr(self):
         self.assertEqual(repr(l), repr(self.seq(l)))
 
     def test_lineage_name(self):
-        f = lambda x: x
+        f = lambda x: x  # noqa: E731
         self.assertEqual(f.__name__, name(f))
         f = "test"
         self.assertEqual("test", name(f))
@@ -294,9 +294,8 @@ def test_drop_right(self):
 
     def test_drop_while(self):
         l = [1, 2, 3, 4, 5, 6, 7, 8]
-        f = lambda x: x < 4
         expect = [4, 5, 6, 7, 8]
-        result = self.seq(l).drop_while(f)
+        result = self.seq(l).drop_while(lambda x: x < 4)
         self.assertIteratorEqual(expect, result)
         self.assert_type(result)
 
@@ -311,9 +310,8 @@ def test_take(self):
 
     def test_take_while(self):
         l = [1, 2, 3, 4, 5, 6, 7, 8]
-        f = lambda x: x < 4
         expect = [1, 2, 3]
-        result = self.seq(l).take_while(f)
+        result = self.seq(l).take_while(lambda x: x < 4)
         self.assertIteratorEqual(result, expect)
         self.assert_type(result)
 
@@ -342,18 +340,16 @@ def test_symmetric_difference(self):
         self.assertSetEqual(result.set(), set(expect))
 
     def test_map(self):
-        f = lambda x: x * 2
         l = [1, 2, 0, 5]
         expect = [2, 4, 0, 10]
-        result = self.seq(l).map(f)
+        result = self.seq(l).map(lambda x: x * 2)
         self.assertIteratorEqual(expect, result)
         self.assert_type(result)
 
     def test_select(self):
-        f = lambda x: x * 2
         l = [1, 2, 0, 5]
         expect = [2, 4, 0, 10]
-        result = self.seq(l).select(f)
+        result = self.seq(l).select(lambda x: x * 2)
         self.assertIteratorEqual(expect, result)
         self.assert_type(result)
 
@@ -369,16 +365,17 @@ def test_starmap(self):
         self.assert_type(result)
 
     def test_filter(self):
-        f = lambda x: x > 0
         l = [0, -1, 5, 10]
         expect = [5, 10]
         s = self.seq(l)
-        result = s.filter(f)
+        result = s.filter(lambda x: x > 0)
         self.assertIteratorEqual(expect, result)
         self.assert_type(result)
 
     def test_where(self):
-        f = lambda x: x > 0
+        def f(x):
+            return x > 0
+
         l = [0, -1, 5, 10]
         expect = [5, 10]
         s = self.seq(l)
@@ -1013,7 +1010,7 @@ def test_cache(self):
         if self.seq is pseq:
             raise self.skipTest("pseq doesn't support functions with side-effects")
         calls = []
-        func = lambda x: calls.append(x)
+        func = calls.append
         result = self.seq(1, 2, 3).map(func).cache().map(lambda x: x).to_list()
         self.assertEqual(len(calls), 3)
         self.assertEqual(result, [None, None, None])

functional/util.py

@@ -1,5 +1,5 @@
-import collections
 import math
+from collections.abc import Iterable
 from functools import reduce
 from itertools import chain, count, islice, takewhile
 from multiprocessing import Pool, cpu_count
@@ -49,7 +49,7 @@ def is_namedtuple(val):
     bases = val_type.__bases__
     if len(bases) != 1 or bases[0] != tuple:
         return False
-    fields = getattr(val_type, "_fields", None)
+    fields = getattr(val_type, "_fields")
     return all(isinstance(n, str) for n in fields)
 
 
@@ -69,7 +69,7 @@ def identity(arg):
 
 def is_iterable(val):
     """
-    Check if val is not a list, but is a collections.Iterable type. This is used to determine
+    Check if val is not a list, but is a Iterable type. This is used to determine
     when list() should be called on val
 
     >>> l = [1, 2]
@@ -79,19 +79,15 @@ def is_iterable(val):
     True
 
     :param val: value to check
-    :return: True if it is not a list, but is a collections.Iterable
+    :return: True if it is not a list, but is a Iterable
     """
-    if isinstance(val, list):
-        return False
-    return isinstance(val, collections.abc.Iterable)
+    return not isinstance(val, list) and isinstance(val, Iterable)
 
 
-def is_tabulatable(val):
-    if is_primitive(val):
-        return False
-    if is_iterable(val) or is_namedtuple(val) or isinstance(val, list):
-        return True
-    return False
+def is_tabulatable(val: object) -> bool:
+    return not is_primitive(val) and (
+        is_iterable(val) or is_namedtuple(val) or isinstance(val, list)
+    )
 
 
 def split_every(parts, iterable):
@@ -117,7 +113,7 @@ def unpack(packed):
     """
     func, args = serializer.loads(packed)
     result = func(*args)
-    if isinstance(result, collections.abc.Iterable):
+    if isinstance(result, Iterable):
         return list(result)
     return None
 
@@ -164,8 +160,7 @@ def lazy_parallelize(func, result, processes=None, partition_size=None):
     with Pool(processes=processes) as pool:
         partitions = split_every(partition_size, iter(result))
         packed_partitions = (pack(func, (partition,)) for partition in partitions)
-        for pool_result in pool.imap(unpack, packed_partitions):
-            yield pool_result
+        yield from pool.imap(unpack, packed_partitions)
 
 
 def compute_partition_size(result, processes):