pipe21 1.22.0__tar.gz → 1.23.0__tar.gz

{pipe21-1.22.0 → pipe21-1.23.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pipe21
-Version: 1.22.0
+Version: 1.23.0
 Summary: simple functional pipes
 Author-email: Alexander Rodionov <tandav@tandav.me>
 Project-URL: source, https://github.com/tandav/pipe21
@@ -11,13 +11,9 @@ Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 Provides-Extra: dev
 Requires-Dist: bumpver; extra == "dev"
-Requires-Dist: black; extra == "dev"
-Requires-Dist: autopep8; extra == "dev"
 Requires-Dist: pre-commit; extra == "dev"
 Requires-Dist: hypothesis; extra == "dev"
 Requires-Dist: pytest; extra == "dev"
-Requires-Dist: pytest-cov; extra == "dev"
-Requires-Dist: coveralls; extra == "dev"
 Requires-Dist: mkdocs; extra == "dev"
 Requires-Dist: mkdocs-material; extra == "dev"
 

{pipe21-1.22.0 → pipe21-1.23.0}/pipe21.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pipe21
-Version: 1.22.0
+Version: 1.23.0
 Summary: simple functional pipes
 Author-email: Alexander Rodionov <tandav@tandav.me>
 Project-URL: source, https://github.com/tandav/pipe21
@@ -11,13 +11,9 @@ Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 Provides-Extra: dev
 Requires-Dist: bumpver; extra == "dev"
-Requires-Dist: black; extra == "dev"
-Requires-Dist: autopep8; extra == "dev"
 Requires-Dist: pre-commit; extra == "dev"
 Requires-Dist: hypothesis; extra == "dev"
 Requires-Dist: pytest; extra == "dev"
-Requires-Dist: pytest-cov; extra == "dev"
-Requires-Dist: coveralls; extra == "dev"
 Requires-Dist: mkdocs; extra == "dev"
 Requires-Dist: mkdocs-material; extra == "dev"
 

{pipe21-1.22.0 → pipe21-1.23.0}/pipe21.egg-info/requires.txt

@@ -1,12 +1,8 @@
 
 [dev]
 bumpver
-black
-autopep8
 pre-commit
 hypothesis
 pytest
-pytest-cov
-coveralls
 mkdocs
 mkdocs-material

pipe21-1.23.0/pipe21.py

@@ -0,0 +1,90 @@
+import functools
+import itertools
+import operator
+import re
+import sys
+
+__version__ = '1.23.0'
+
+
+class B:
+    def __init__(self, f=None, *args, **kw):
+        self.f = f
+        self.args = args
+        self.kw = kw
+
+
+class Pipe         (B): __ror__ = lambda self, x: self.f(x, *self.args, **self.kw)
+class Map          (B): __ror__ = lambda self, it: (self.f(x) for x in it)
+class Filter       (B): __ror__ = lambda self, it: (x for x in it if self.f(x))
+class Reduce       (B): __ror__ = lambda self, it: functools.reduce(self.f, it, *self.args)
+class MapKeys      (B): __ror__ = lambda self, it: ((self.f(k), v) for k, v in it)
+class MapValues    (B): __ror__ = lambda self, it: ((k, self.f(v)) for k, v in it)
+class FilterFalse  (B): __ror__ = lambda self, it: itertools.filterfalse(self.f, it)
+class FilterKeys   (B): __ror__ = lambda self, it: (kv for kv in it if (self.f or bool)(kv[0]))
+class FilterValues (B): __ror__ = lambda self, it: (kv for kv in it if (self.f or bool)(kv[1]))
+class FlatMap      (B): __ror__ = lambda self, it: itertools.chain.from_iterable(self.f(x) for x in it)
+class FlatMapValues(B): __ror__ = lambda self, it: ((k, v) for k, vs in it for v in self.f(vs))
+class KeyBy        (B): __ror__ = lambda self, it: ((self.f(x), x) for x in it)
+class ValueBy      (B): __ror__ = lambda self, it: ((x, self.f(x)) for x in it)
+class Append       (B): __ror__ = lambda self, it: ((*x, self.f(x)) for x in it)
+class Keys         (B): __ror__ = lambda self, it: (k for k, v in it)
+class Values       (B): __ror__ = lambda self, it: (v for k, v in it)
+class SwapKV       (B): __ror__ = lambda self, it: it | Map(operator.itemgetter(1, 0))
+class Grep         (B): __ror__ = lambda self, it: it | (FilterFalse if self.kw.get('v', False) else Filter)(re.compile(self.f, flags=re.IGNORECASE if self.kw.get('i', False) else 0).search)
+class IterLines    (B): __ror__ = lambda self, f: (x.strip() if self.kw.get('strip', True) else x for x in open(f))
+class Count        (B): __ror__ = lambda self, it: sum(1 for _ in it)
+class Slice        (B): __ror__ = lambda self, it: itertools.islice(it, self.f, *self.args)
+class Take         (B): __ror__ = lambda self, it: it | Slice(self.f) | Pipe(list)
+class Sorted       (B): __ror__ = lambda self, it: sorted(it, **self.kw)
+class GroupBy      (B): __ror__ = lambda self, it: itertools.groupby(sorted(it, key=self.f), key=self.f)
+class ReduceByKey  (B): __ror__ = lambda self, it: it | GroupBy(lambda kv: kv[0]) | MapValues(lambda kv: kv | Values() | Reduce(self.f)) | Pipe(list)
+class Apply        (B): __ror__ = lambda self, x: x | Exec(self.f, x)
+class StarPipe     (B): __ror__ = lambda self, x: self.f(*x)
+class StarMap      (B): __ror__ = lambda self, x: itertools.starmap(self.f, x)
+class StarFlatMap  (B): __ror__ = lambda self, x: itertools.starmap(self.f, x) | Pipe(itertools.chain.from_iterable)
+class MapApply     (B): __ror__ = lambda self, it: (x | Apply(self.f) for x in it)
+class Switch       (B): __ror__ = lambda self, x: next((v(x) for k, v in self.f if k(x)), x)
+class MapSwitch    (B): __ror__ = lambda self, it: (x | Switch(self.f) for x in it)
+class YieldIf      (B): __ror__ = lambda self, it: ((self.f or (lambda y: y))(x) for x in it if self.kw.get('key', bool)(x))
+class Join         (B): __ror__ = lambda self, it: it | FlatMap(lambda x: ((x, y) for y in self.f if self.kw.get('key', operator.eq)(x, y)))
+
+
+class GetItem        (B): __ror__ = lambda self, x: operator.getitem(x, self.f)
+class SetItem        (B): __ror__ = lambda self, x: x | Exec(operator.setitem, x, self.f, self.args[0])
+class DelItem        (B): __ror__ = lambda self, x: x | Exec(operator.delitem, x, self.f)
+class GetAttr        (B): __ror__ = lambda self, x: getattr(x, self.f)
+class SetAttr        (B): __ror__ = lambda self, x: x | Exec(setattr, x, self.f, self.args[0])
+class DelAttr        (B): __ror__ = lambda self, x: x | Exec(delattr, x, self.f)
+class MapGetItem     (B): __ror__ = lambda self, it: (kv | GetItem(self.f) for kv in it)
+class MapSetItem     (B): __ror__ = lambda self, it: (kv | SetItem(self.f, self.args[0]) for kv in it)
+class MapDelItem     (B): __ror__ = lambda self, it: (kv | DelItem(self.f) for kv in it)
+class MapGetAttr     (B): __ror__ = lambda self, it: (kv | GetAttr(self.f) for kv in it)
+class MapSetAttr     (B): __ror__ = lambda self, it: (kv | SetAttr(self.f, self.args[0]) for kv in it)
+class MapDelAttr     (B): __ror__ = lambda self, it: (kv | DelAttr(self.f) for kv in it)
+class MethodCaller   (B): __ror__ = lambda self, x: operator.methodcaller(self.f, *self.args, **self.kw)(x)
+class MapMethodCaller(B): __ror__ = lambda self, it: (x | MethodCaller(self.f, *self.args, **self.kw) for x in it)
+
+
+class Unique(B):
+    def __ror__(self, it):
+        key = self.f or (lambda x: x)
+        seen = set()
+        for item in it:
+            k = key(item)
+            if k in seen:
+                continue
+            seen.add(k)
+            yield item
+
+
+class Exec(B):
+    def __ror__(self, x):
+        self.f(*self.args, **self.kw)
+        return x
+
+
+if sys.version_info >= (3, 12):  # pragma: no cover
+    class Chunked(B): __ror__ = lambda self, it: itertools.batched(it, self.f)  # pylint: disable=no-member
+else:  # pragma: no cover
+    class Chunked(B): __ror__ = lambda self, it: iter(functools.partial(lambda n, i: tuple(i | Take(n)), self.f, iter(it)), ())

{pipe21-1.22.0 → pipe21-1.23.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pipe21"
-version = "1.22.0"
+version = "1.23.0"
 authors = [
     {name = "Alexander Rodionov", email = "tandav@tandav.me"},
 ]
@@ -12,13 +12,13 @@ dependencies = []
 [project.optional-dependencies]
 dev = [
     "bumpver",
-    "black",
-    "autopep8",
+#    "black",
+#    "autopep8",
     "pre-commit",
     "hypothesis",
     "pytest",
-    "pytest-cov",
-    "coveralls",
+#    "pytest-cov",
+#    "coveralls",
     "mkdocs",
     "mkdocs-material",
 ]
@@ -38,7 +38,7 @@ build-backend = "setuptools.build_meta"
 # ==============================================================================
 
 [tool.bumpver]
-current_version = "v1.22.0"
+current_version = "v1.23.0"
 version_pattern = "vMAJOR.MINOR.PATCH"
 commit_message = "bump version {old_version} -> {new_version}"
 commit = true
@@ -104,6 +104,7 @@ ignore = [
     "ARG005", # Unused lambda argument
     "PTH123", # `open()` should be replaced by `Path.open()`
     "N812", # lowercase imported as non lowercase
+    "SIM115",
 ]
 
 [tool.ruff.per-file-ignores]
@@ -138,6 +139,7 @@ disable = [
     "unused-wildcard-import",
     "keyword-arg-before-vararg",
     "too-few-public-methods",
+    "consider-using-with",
 ]
 
 [tool.pylint-per-file-ignores]

pipe21-1.22.0/pipe21.py

@@ -1,83 +0,0 @@
-import functools
-import itertools
-import operator
-import re
-
-__version__ = '1.22.0'
-
-
-class B:
-    def __init__(self, f=None, *args, **kw):
-        self.f = f
-        self.args = args
-        self.kw = kw
-
-
-class Pipe         (B): __ror__ = lambda self, x: self.f(x, *self.args, **self.kw)
-class Map          (B): __ror__ = lambda self, it: map(self.f, it)
-class Filter       (B): __ror__ = lambda self, it: filter(self.f, it)
-class Reduce       (B): __ror__ = lambda self, it: functools.reduce(self.f, it, *self.args)
-class MapKeys      (B): __ror__ = lambda self, it: it | Map(lambda kv: (self.f(kv[0]), kv[1]))
-class MapValues    (B): __ror__ = lambda self, it: it | Map(lambda kv: (kv[0], self.f(kv[1])))
-class FilterFalse  (B): __ror__ = lambda self, it: itertools.filterfalse(self.f, it)
-class FilterKeys   (B): __ror__ = lambda self, it: it | Filter(lambda kv: kv[0] | Pipe(self.f or bool))
-class FilterValues (B): __ror__ = lambda self, it: it | Filter(lambda kv: kv[1] | Pipe(self.f or bool))
-class FlatMap      (B): __ror__ = lambda self, it: it | Map(self.f) | Pipe(itertools.chain.from_iterable)
-class FlatMapValues(B): __ror__ = lambda self, it: it | FlatMap(lambda kv: ((kv[0], x) for x in self.f(kv[1])))
-class KeyBy        (B): __ror__ = lambda self, it: it | Map(lambda x: (self.f(x), x))
-class ValueBy      (B): __ror__ = lambda self, it: it | Map(lambda x: (x, self.f(x)))
-class Append       (B): __ror__ = lambda self, it: it | Map(lambda x: (*x, self.f(x)))
-class Keys         (B): __ror__ = lambda self, it: it | Map(lambda kv: kv[0])
-class Values       (B): __ror__ = lambda self, it: it | Map(lambda kv: kv[1])
-class Grep         (B): __ror__ = lambda self, it: it | (FilterFalse if self.kw.get('v', False) else Filter)(re.compile(self.f, flags=re.I if self.kw.get('i', False) else 0).search)
-class IterLines    (B): __ror__ = lambda self, p: p | Pipe(open) | Pipe(lambda t: t | Map(str.strip) if self.kw.get('strip', True) else t)
-class Count        (B): __ror__ = lambda self, it: sum(1 for _ in it)
-class Slice        (B): __ror__ = lambda self, it: itertools.islice(it, self.f, *self.args)
-class Take         (B): __ror__ = lambda self, it: it | Slice(self.f) | Pipe(tuple)
-class Chunked      (B): __ror__ = lambda self, it: iter(functools.partial(lambda n, i: i | Take(n), self.f, iter(it)), ())
-class Sorted       (B): __ror__ = lambda self, it: sorted(it, **self.kw)
-class GroupBy      (B): __ror__ = lambda self, it: it | Sorted(key=self.f) | Pipe(itertools.groupby, key=self.f)
-class ReduceByKey  (B): __ror__ = lambda self, it: it | GroupBy(lambda kv: kv[0]) | MapValues(lambda kv: kv | Values() | Reduce(self.f)) | Pipe(list)
-class Apply        (B): __ror__ = lambda self, x: x | Exec(self.f, x)
-class StarPipe     (B): __ror__ = lambda self, x: self.f(*x)
-class StarMap      (B): __ror__ = lambda self, x: itertools.starmap(self.f, x)
-class StarFlatMap  (B): __ror__ = lambda self, x: x | StarMap(self.f) | Pipe(itertools.chain.from_iterable)
-class MapApply     (B): __ror__ = lambda self, it: it | Map(lambda x: x | Apply(self.f))
-class Switch       (B): __ror__ = lambda self, x: self.f | FilterKeys(lambda p: p(x)) | Values() | Map(lambda f: f(x)) | Pipe(next, x)
-class MapSwitch    (B): __ror__ = lambda self, it: it | Map(lambda x: x | Switch(self.f))
-class YieldIf      (B): __ror__ = lambda self, it: ((self.f or (lambda y: y))(x) for x in it if self.kw.get('key', bool)(x))
-class Join         (B): __ror__ = lambda self, it: it | FlatMap(lambda x: ((x, y) for y in self.f if self.kw.get('key', operator.eq)(x, y)))
-
-
-class GetItem        (B): __ror__ = lambda self, x: operator.getitem(x, self.f)
-class SetItem        (B): __ror__ = lambda self, x: x | Exec(operator.setitem, x, self.f, self.args[0])
-class DelItem        (B): __ror__ = lambda self, x: x | Exec(operator.delitem, x, self.f)
-class GetAttr        (B): __ror__ = lambda self, x: getattr(x, self.f)
-class SetAttr        (B): __ror__ = lambda self, x: x | Exec(setattr, x, self.f, self.args[0])
-class DelAttr        (B): __ror__ = lambda self, x: x | Exec(delattr, x, self.f)
-class MapGetItem     (B): __ror__ = lambda self, it: it | Map(lambda kv: kv | GetItem(self.f))
-class MapSetItem     (B): __ror__ = lambda self, it: it | Map(lambda kv: kv | SetItem(self.f, self.args[0]))
-class MapDelItem     (B): __ror__ = lambda self, it: it | Map(lambda kv: kv | DelItem(self.f))
-class MapGetAttr     (B): __ror__ = lambda self, it: it | Map(lambda kv: kv | GetAttr(self.f))
-class MapSetAttr     (B): __ror__ = lambda self, it: it | Map(lambda kv: kv | SetAttr(self.f, self.args[0]))
-class MapDelAttr     (B): __ror__ = lambda self, it: it | Map(lambda kv: kv | DelAttr(self.f))
-class MethodCaller   (B): __ror__ = lambda self, x: operator.methodcaller(self.f, *self.args, **self.kw)(x)
-class MapMethodCaller(B): __ror__ = lambda self, it: it | Map(lambda x: x | MethodCaller(self.f, *self.args, **self.kw))
-
-
-class Unique(B):
-    def __ror__(self, it):
-        key = self.f or (lambda x: x)
-        seen = set()
-        for item in it:
-            k = key(item)
-            if k in seen:
-                continue
-            seen.add(k)
-            yield item
-
-
-class Exec(B):
-    def __ror__(self, x):
-        self.f(*self.args, **self.kw)
-        return x