From a9875e2c7948f47d560bb9cfb1991ce5f5289c34 Mon Sep 17 00:00:00 2001 From: CoprDistGit Date: Wed, 10 May 2023 08:29:05 +0000 Subject: automatic import of python-sspipe --- python-sspipe.spec | 513 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 513 insertions(+) create mode 100644 python-sspipe.spec (limited to 'python-sspipe.spec') diff --git a/python-sspipe.spec b/python-sspipe.spec new file mode 100644 index 0000000..0b82fcd --- /dev/null +++ b/python-sspipe.spec @@ -0,0 +1,513 @@ +%global _empty_manifest_terminate_build 0 +Name: python-sspipe +Version: 0.1.17 +Release: 1 +Summary: Simple Smart Pipe Operator +License: MIT License +URL: https://sspipe.github.io/ +Source0: https://mirrors.nju.edu.cn/pypi/web/packages/d4/d1/89b35880c8f25d01a1802322567fd831fdd5b7d62ec3649df85bf3e3e05e/sspipe-0.1.17.tar.gz +BuildArch: noarch + +Requires: python3-pipe +Requires: python3-check-manifest +Requires: python3-coverage + +%description + + +[![Downloads](http://pepy.tech/badge/sspipe)](http://pepy.tech/project/sspipe) +[![Build Status](https://circleci.com/gh/sspipe/sspipe.svg?style=svg)](https://app.circleci.com/pipelines/github/sspipe/sspipe) +[![PyPI](https://badge.fury.io/py/sspipe.svg)](http://pypi.org/project/sspipe) + +# Simple Smart Pipe + +SSPipe is a python productivity-tool for rapid data manipulation in python. + +It helps you break up any complicated expression into a sequence of +simple transformations, increasing human-readability and decreasing the +need for matching parentheses! + +As an example, here is a single line code for reading students' data +from 'data.csv', reporting those in the class 'A19' whose score is more +than the average class score into 'report.csv': + +```python +from sspipe import p, px +import pandas as pd + +pd.read_csv('data.csv') | px[px['class'] == 'A19'] | px[px.score > px.score.mean()].to_csv('report.csv') +``` + +As another example, here is a single line code for plotting +sin(x) for points in range(0, 2*pi) where cos(x) is less than 0 in red color: + +```python +from sspipe import p, px +import numpy as np +import matplotlib.pyplot as plt + +np.linspace(0, 2*np.pi, 100) | px[np.cos(px) < 0] | p(plt.plot, px, np.sin(px), 'r') + +# The single-line code above is equivalent to the following code without SSPipe: +# X = np.linspace(0, 2*np.pi, 100) +# X = X[np.cos(X) < 0] +# plt.plot(X, np.sin(X), 'r') +``` + +If you're familiar with +[`|` operator](https://en.wikipedia.org/wiki/Pipeline_(Unix)) +of Unix, or +[`%>%` operator](https://cran.r-project.org/web/packages/magrittr/vignettes/magrittr.html) +of R's magrittr, `sspipe` provides the same functionality in python. + +### Installation and Usage +Install sspipe using pip: +```bash +pip install --upgrade sspipe +``` +Then import it in your scripts. + +```python +from sspipe import p, px +``` + +The whole functionality +of this library is exposed by two objects `p` (as a wrapper for functions to +be called on the piped object) and `px` (as a placeholder for piped object). + +### Examples + +| Description | Python expression using `p` and `px` | Equivalent python code | +| --- |:--- |:--- | +| Simple
function call | `"hello world!" \| p(print)` | `X = "hello world!"`
`print(X)` | +| Function call
with extra args | `"hello" \| p(print, "world", end='!')` | `X = "hello"`
`print(X, "world", end='!')` | +| Explicitly positioning
piped argument
with `px` placeholder | `"world" \| p(print, "hello", px, "!")` | `X = "world"`
`print("hello", X, "!")` | +| Chaining pipes | `5 \| px + 2 \| px ** 5 + px \| p(print)` | `X = 5`
`X = X + 2`
`X = X ** 5 + X`
`print(X)` | +| Tailored behavior
for builtin `map`
and `filter` | `(`
` range(5)`
` \| p(filter, px % 2 == 0)`
` \| p(map, px + 10)`
` \| p(list) \| p(print)`
`)` | `X = range(5)`
`X = filter((lambda x:x%2==0),X)`
`X = map((lambda x: x + 10), X)`
`X = list(X)`
`print(X)` | +| NumPy expressions | `range(10) \| np.sin(px)+1 \| p(plt.plot)` | `X = range(10)`
`X = np.sin(X) + 1`
`plt.plot(X)` | +| Pandas support | `people_df \| px.loc[px.age > 10, 'name']` | `X = people_df`
`X.loc[X.age > 10, 'name']` | +| Assignment | `people_df['name'] \|= px.str.upper()` | `X = people_df['name']`
`X = X.str.upper()`
`people_df['name'] = X` | +| Pipe as variable | `to_upper = px.strip().upper()`
`to_underscore = px.replace(' ', '_')`
`normalize = to_upper \| to_underscore`
`" ab cde " \| normalize \| p(print)` | `_f1 = lambda x: x.strip().upper()`
`_f2 = lambda x: x.replace(' ','_')`
`_f3 = lambda x: _f2(_f1(x))`
`X = " ab cde "`
`X = _f3(X)`
`print(X)` | +| Builtin
Data Structures | `2 \| p({px-1: p([px, p((px+1, 4))])})` | `X = 2`
`X = {X-1: [X, (X+1, 4)]}` | + +### How it works + +The expression `p(func, *args, **kwargs)` returns a `Pipe` object that overloads +`__or__` and `__ror__` operators. This object keeps `func` and `args` and `kwargs` until +evaluation of `x | `, when `Pipe.__ror__` is called by python. Then it will evaluate +`func(x, *args, **kwargs)` and return the result. + +The `px` object is simply `p(lambda x: x)`. + +Please notice that SSPipe does not wrap piped objects. On the other hand, it just wraps transforming functions. Therefore, when a variable like `x` is not an instance of `Pipe` class, after python evaluates `y = x | p(func)`, the resulting variable `y` has absolutely no trace of Pipe. Thus, it will be exactly the same object as if we have originally evaluated `y = func(x)`. + +### Common Gotchas + +* Incompatibility with `dict.items`, `dict.keys` and `dict.values`: + + The objects returned by dict.keys(), dict.values() and dict.items() are + called [view objects](https://docs.python.org/3.3/library/stdtypes.html#dict-views). + Python does not allow classes to override the `|` operator on these types. As a workaround, + the `/` operator has been implemented for view objects. Example: + ```python3 + # WRONG ERRONEOUS CODE: + {1: 2, 3: 4}.items() | p(list) | p(print) + + # CORRECT CODE (With / operator): + {1: 2, 3: 4}.items() / p(list) | p(print) + ``` + +### Compatibility with JulienPalard/Pipe + +This library is inspired by, and depends on, the intelligent and concise work of + [JulienPalard/Pipe](https://github.com/JulienPalard/Pipe). If you want + a single `pipe.py` script or a lightweight library that implements core + functionality and logic of SSPipe, Pipe is perfect. + +SSPipe is focused on facilitating usage of pipes, by integration with + popular libraries and introducing `px` concept and overriding python + operators to make pipe a first-class citizen. + + Every existing pipe implemented by JulienPalard/Pipe + library is accessible through `p.` and is compatible with SSPipe. + SSPipe does not implement any specific pipe function and delegates +implementation and naming of pipe functions to JulienPalard/Pipe. + +For example, JulienPalard/Pipe's [example](https://github.com/JulienPalard/Pipe#introduction) +for solving "Find the sum of all the even-valued terms in Fibonacci which do not exceed four million." +can be re-written using sspipe: + +```python +def fib(): + a, b = 0, 1 + while True: + yield a + a, b = b, a + b + +from sspipe import p, px + +euler2 = (fib() | p.where(lambda x: x % 2 == 0) + | p.take_while(lambda x: x < 4000000) + | p.add()) +``` + +You can also pass `px` shorthands to JulienPalard/Pipe API: +```python +euler2 = (fib() | p.where(px % 2 == 0) + | p.take_while(px < 4000000) + | p.add()) +``` + + + + +%package -n python3-sspipe +Summary: Simple Smart Pipe Operator +Provides: python-sspipe +BuildRequires: python3-devel +BuildRequires: python3-setuptools +BuildRequires: python3-pip +%description -n python3-sspipe + + +[![Downloads](http://pepy.tech/badge/sspipe)](http://pepy.tech/project/sspipe) +[![Build Status](https://circleci.com/gh/sspipe/sspipe.svg?style=svg)](https://app.circleci.com/pipelines/github/sspipe/sspipe) +[![PyPI](https://badge.fury.io/py/sspipe.svg)](http://pypi.org/project/sspipe) + +# Simple Smart Pipe + +SSPipe is a python productivity-tool for rapid data manipulation in python. + +It helps you break up any complicated expression into a sequence of +simple transformations, increasing human-readability and decreasing the +need for matching parentheses! + +As an example, here is a single line code for reading students' data +from 'data.csv', reporting those in the class 'A19' whose score is more +than the average class score into 'report.csv': + +```python +from sspipe import p, px +import pandas as pd + +pd.read_csv('data.csv') | px[px['class'] == 'A19'] | px[px.score > px.score.mean()].to_csv('report.csv') +``` + +As another example, here is a single line code for plotting +sin(x) for points in range(0, 2*pi) where cos(x) is less than 0 in red color: + +```python +from sspipe import p, px +import numpy as np +import matplotlib.pyplot as plt + +np.linspace(0, 2*np.pi, 100) | px[np.cos(px) < 0] | p(plt.plot, px, np.sin(px), 'r') + +# The single-line code above is equivalent to the following code without SSPipe: +# X = np.linspace(0, 2*np.pi, 100) +# X = X[np.cos(X) < 0] +# plt.plot(X, np.sin(X), 'r') +``` + +If you're familiar with +[`|` operator](https://en.wikipedia.org/wiki/Pipeline_(Unix)) +of Unix, or +[`%>%` operator](https://cran.r-project.org/web/packages/magrittr/vignettes/magrittr.html) +of R's magrittr, `sspipe` provides the same functionality in python. + +### Installation and Usage +Install sspipe using pip: +```bash +pip install --upgrade sspipe +``` +Then import it in your scripts. + +```python +from sspipe import p, px +``` + +The whole functionality +of this library is exposed by two objects `p` (as a wrapper for functions to +be called on the piped object) and `px` (as a placeholder for piped object). + +### Examples + +| Description | Python expression using `p` and `px` | Equivalent python code | +| --- |:--- |:--- | +| Simple
function call | `"hello world!" \| p(print)` | `X = "hello world!"`
`print(X)` | +| Function call
with extra args | `"hello" \| p(print, "world", end='!')` | `X = "hello"`
`print(X, "world", end='!')` | +| Explicitly positioning
piped argument
with `px` placeholder | `"world" \| p(print, "hello", px, "!")` | `X = "world"`
`print("hello", X, "!")` | +| Chaining pipes | `5 \| px + 2 \| px ** 5 + px \| p(print)` | `X = 5`
`X = X + 2`
`X = X ** 5 + X`
`print(X)` | +| Tailored behavior
for builtin `map`
and `filter` | `(`
` range(5)`
` \| p(filter, px % 2 == 0)`
` \| p(map, px + 10)`
` \| p(list) \| p(print)`
`)` | `X = range(5)`
`X = filter((lambda x:x%2==0),X)`
`X = map((lambda x: x + 10), X)`
`X = list(X)`
`print(X)` | +| NumPy expressions | `range(10) \| np.sin(px)+1 \| p(plt.plot)` | `X = range(10)`
`X = np.sin(X) + 1`
`plt.plot(X)` | +| Pandas support | `people_df \| px.loc[px.age > 10, 'name']` | `X = people_df`
`X.loc[X.age > 10, 'name']` | +| Assignment | `people_df['name'] \|= px.str.upper()` | `X = people_df['name']`
`X = X.str.upper()`
`people_df['name'] = X` | +| Pipe as variable | `to_upper = px.strip().upper()`
`to_underscore = px.replace(' ', '_')`
`normalize = to_upper \| to_underscore`
`" ab cde " \| normalize \| p(print)` | `_f1 = lambda x: x.strip().upper()`
`_f2 = lambda x: x.replace(' ','_')`
`_f3 = lambda x: _f2(_f1(x))`
`X = " ab cde "`
`X = _f3(X)`
`print(X)` | +| Builtin
Data Structures | `2 \| p({px-1: p([px, p((px+1, 4))])})` | `X = 2`
`X = {X-1: [X, (X+1, 4)]}` | + +### How it works + +The expression `p(func, *args, **kwargs)` returns a `Pipe` object that overloads +`__or__` and `__ror__` operators. This object keeps `func` and `args` and `kwargs` until +evaluation of `x | `, when `Pipe.__ror__` is called by python. Then it will evaluate +`func(x, *args, **kwargs)` and return the result. + +The `px` object is simply `p(lambda x: x)`. + +Please notice that SSPipe does not wrap piped objects. On the other hand, it just wraps transforming functions. Therefore, when a variable like `x` is not an instance of `Pipe` class, after python evaluates `y = x | p(func)`, the resulting variable `y` has absolutely no trace of Pipe. Thus, it will be exactly the same object as if we have originally evaluated `y = func(x)`. + +### Common Gotchas + +* Incompatibility with `dict.items`, `dict.keys` and `dict.values`: + + The objects returned by dict.keys(), dict.values() and dict.items() are + called [view objects](https://docs.python.org/3.3/library/stdtypes.html#dict-views). + Python does not allow classes to override the `|` operator on these types. As a workaround, + the `/` operator has been implemented for view objects. Example: + ```python3 + # WRONG ERRONEOUS CODE: + {1: 2, 3: 4}.items() | p(list) | p(print) + + # CORRECT CODE (With / operator): + {1: 2, 3: 4}.items() / p(list) | p(print) + ``` + +### Compatibility with JulienPalard/Pipe + +This library is inspired by, and depends on, the intelligent and concise work of + [JulienPalard/Pipe](https://github.com/JulienPalard/Pipe). If you want + a single `pipe.py` script or a lightweight library that implements core + functionality and logic of SSPipe, Pipe is perfect. + +SSPipe is focused on facilitating usage of pipes, by integration with + popular libraries and introducing `px` concept and overriding python + operators to make pipe a first-class citizen. + + Every existing pipe implemented by JulienPalard/Pipe + library is accessible through `p.` and is compatible with SSPipe. + SSPipe does not implement any specific pipe function and delegates +implementation and naming of pipe functions to JulienPalard/Pipe. + +For example, JulienPalard/Pipe's [example](https://github.com/JulienPalard/Pipe#introduction) +for solving "Find the sum of all the even-valued terms in Fibonacci which do not exceed four million." +can be re-written using sspipe: + +```python +def fib(): + a, b = 0, 1 + while True: + yield a + a, b = b, a + b + +from sspipe import p, px + +euler2 = (fib() | p.where(lambda x: x % 2 == 0) + | p.take_while(lambda x: x < 4000000) + | p.add()) +``` + +You can also pass `px` shorthands to JulienPalard/Pipe API: +```python +euler2 = (fib() | p.where(px % 2 == 0) + | p.take_while(px < 4000000) + | p.add()) +``` + + + + +%package help +Summary: Development documents and examples for sspipe +Provides: python3-sspipe-doc +%description help + + +[![Downloads](http://pepy.tech/badge/sspipe)](http://pepy.tech/project/sspipe) +[![Build Status](https://circleci.com/gh/sspipe/sspipe.svg?style=svg)](https://app.circleci.com/pipelines/github/sspipe/sspipe) +[![PyPI](https://badge.fury.io/py/sspipe.svg)](http://pypi.org/project/sspipe) + +# Simple Smart Pipe + +SSPipe is a python productivity-tool for rapid data manipulation in python. + +It helps you break up any complicated expression into a sequence of +simple transformations, increasing human-readability and decreasing the +need for matching parentheses! + +As an example, here is a single line code for reading students' data +from 'data.csv', reporting those in the class 'A19' whose score is more +than the average class score into 'report.csv': + +```python +from sspipe import p, px +import pandas as pd + +pd.read_csv('data.csv') | px[px['class'] == 'A19'] | px[px.score > px.score.mean()].to_csv('report.csv') +``` + +As another example, here is a single line code for plotting +sin(x) for points in range(0, 2*pi) where cos(x) is less than 0 in red color: + +```python +from sspipe import p, px +import numpy as np +import matplotlib.pyplot as plt + +np.linspace(0, 2*np.pi, 100) | px[np.cos(px) < 0] | p(plt.plot, px, np.sin(px), 'r') + +# The single-line code above is equivalent to the following code without SSPipe: +# X = np.linspace(0, 2*np.pi, 100) +# X = X[np.cos(X) < 0] +# plt.plot(X, np.sin(X), 'r') +``` + +If you're familiar with +[`|` operator](https://en.wikipedia.org/wiki/Pipeline_(Unix)) +of Unix, or +[`%>%` operator](https://cran.r-project.org/web/packages/magrittr/vignettes/magrittr.html) +of R's magrittr, `sspipe` provides the same functionality in python. + +### Installation and Usage +Install sspipe using pip: +```bash +pip install --upgrade sspipe +``` +Then import it in your scripts. + +```python +from sspipe import p, px +``` + +The whole functionality +of this library is exposed by two objects `p` (as a wrapper for functions to +be called on the piped object) and `px` (as a placeholder for piped object). + +### Examples + +| Description | Python expression using `p` and `px` | Equivalent python code | +| --- |:--- |:--- | +| Simple
function call | `"hello world!" \| p(print)` | `X = "hello world!"`
`print(X)` | +| Function call
with extra args | `"hello" \| p(print, "world", end='!')` | `X = "hello"`
`print(X, "world", end='!')` | +| Explicitly positioning
piped argument
with `px` placeholder | `"world" \| p(print, "hello", px, "!")` | `X = "world"`
`print("hello", X, "!")` | +| Chaining pipes | `5 \| px + 2 \| px ** 5 + px \| p(print)` | `X = 5`
`X = X + 2`
`X = X ** 5 + X`
`print(X)` | +| Tailored behavior
for builtin `map`
and `filter` | `(`
` range(5)`
` \| p(filter, px % 2 == 0)`
` \| p(map, px + 10)`
` \| p(list) \| p(print)`
`)` | `X = range(5)`
`X = filter((lambda x:x%2==0),X)`
`X = map((lambda x: x + 10), X)`
`X = list(X)`
`print(X)` | +| NumPy expressions | `range(10) \| np.sin(px)+1 \| p(plt.plot)` | `X = range(10)`
`X = np.sin(X) + 1`
`plt.plot(X)` | +| Pandas support | `people_df \| px.loc[px.age > 10, 'name']` | `X = people_df`
`X.loc[X.age > 10, 'name']` | +| Assignment | `people_df['name'] \|= px.str.upper()` | `X = people_df['name']`
`X = X.str.upper()`
`people_df['name'] = X` | +| Pipe as variable | `to_upper = px.strip().upper()`
`to_underscore = px.replace(' ', '_')`
`normalize = to_upper \| to_underscore`
`" ab cde " \| normalize \| p(print)` | `_f1 = lambda x: x.strip().upper()`
`_f2 = lambda x: x.replace(' ','_')`
`_f3 = lambda x: _f2(_f1(x))`
`X = " ab cde "`
`X = _f3(X)`
`print(X)` | +| Builtin
Data Structures | `2 \| p({px-1: p([px, p((px+1, 4))])})` | `X = 2`
`X = {X-1: [X, (X+1, 4)]}` | + +### How it works + +The expression `p(func, *args, **kwargs)` returns a `Pipe` object that overloads +`__or__` and `__ror__` operators. This object keeps `func` and `args` and `kwargs` until +evaluation of `x | `, when `Pipe.__ror__` is called by python. Then it will evaluate +`func(x, *args, **kwargs)` and return the result. + +The `px` object is simply `p(lambda x: x)`. + +Please notice that SSPipe does not wrap piped objects. On the other hand, it just wraps transforming functions. Therefore, when a variable like `x` is not an instance of `Pipe` class, after python evaluates `y = x | p(func)`, the resulting variable `y` has absolutely no trace of Pipe. Thus, it will be exactly the same object as if we have originally evaluated `y = func(x)`. + +### Common Gotchas + +* Incompatibility with `dict.items`, `dict.keys` and `dict.values`: + + The objects returned by dict.keys(), dict.values() and dict.items() are + called [view objects](https://docs.python.org/3.3/library/stdtypes.html#dict-views). + Python does not allow classes to override the `|` operator on these types. As a workaround, + the `/` operator has been implemented for view objects. Example: + ```python3 + # WRONG ERRONEOUS CODE: + {1: 2, 3: 4}.items() | p(list) | p(print) + + # CORRECT CODE (With / operator): + {1: 2, 3: 4}.items() / p(list) | p(print) + ``` + +### Compatibility with JulienPalard/Pipe + +This library is inspired by, and depends on, the intelligent and concise work of + [JulienPalard/Pipe](https://github.com/JulienPalard/Pipe). If you want + a single `pipe.py` script or a lightweight library that implements core + functionality and logic of SSPipe, Pipe is perfect. + +SSPipe is focused on facilitating usage of pipes, by integration with + popular libraries and introducing `px` concept and overriding python + operators to make pipe a first-class citizen. + + Every existing pipe implemented by JulienPalard/Pipe + library is accessible through `p.` and is compatible with SSPipe. + SSPipe does not implement any specific pipe function and delegates +implementation and naming of pipe functions to JulienPalard/Pipe. + +For example, JulienPalard/Pipe's [example](https://github.com/JulienPalard/Pipe#introduction) +for solving "Find the sum of all the even-valued terms in Fibonacci which do not exceed four million." +can be re-written using sspipe: + +```python +def fib(): + a, b = 0, 1 + while True: + yield a + a, b = b, a + b + +from sspipe import p, px + +euler2 = (fib() | p.where(lambda x: x % 2 == 0) + | p.take_while(lambda x: x < 4000000) + | p.add()) +``` + +You can also pass `px` shorthands to JulienPalard/Pipe API: +```python +euler2 = (fib() | p.where(px % 2 == 0) + | p.take_while(px < 4000000) + | p.add()) +``` + + + + +%prep +%autosetup -n sspipe-0.1.17 + +%build +%py3_build + +%install +%py3_install +install -d -m755 %{buildroot}/%{_pkgdocdir} +if [ -d doc ]; then cp -arf doc %{buildroot}/%{_pkgdocdir}; fi +if [ -d docs ]; then cp -arf docs %{buildroot}/%{_pkgdocdir}; fi +if [ -d example ]; then cp -arf example %{buildroot}/%{_pkgdocdir}; fi +if [ -d examples ]; then cp -arf examples %{buildroot}/%{_pkgdocdir}; fi +pushd %{buildroot} +if [ -d usr/lib ]; then + find usr/lib -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/lib64 ]; then + find usr/lib64 -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/bin ]; then + find usr/bin -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/sbin ]; then + find usr/sbin -type f -printf "/%h/%f\n" >> filelist.lst +fi +touch doclist.lst +if [ -d usr/share/man ]; then + find usr/share/man -type f -printf "/%h/%f.gz\n" >> doclist.lst +fi +popd +mv %{buildroot}/filelist.lst . +mv %{buildroot}/doclist.lst . + +%files -n python3-sspipe -f filelist.lst +%dir %{python3_sitelib}/* + +%files help -f doclist.lst +%{_docdir}/* + +%changelog +* Wed May 10 2023 Python_Bot - 0.1.17-1 +- Package Spec generated -- cgit v1.2.3