diff options
Diffstat (limited to 'python-pyfunctional.spec')
| -rw-r--r-- | python-pyfunctional.spec | 510 |
1 files changed, 510 insertions, 0 deletions
diff --git a/python-pyfunctional.spec b/python-pyfunctional.spec new file mode 100644 index 0000000..8cb7607 --- /dev/null +++ b/python-pyfunctional.spec @@ -0,0 +1,510 @@ +%global _empty_manifest_terminate_build 0 +Name: python-pyfunctional +Version: 1.4.3 +Release: 1 +Summary: Package for creating data pipelines with chain functional programming +License: MIT +URL: https://github.com/EntilZha/PyFunctional +Source0: https://mirrors.nju.edu.cn/pypi/web/packages/65/b8/134bf0187d5db42641e93a23c90e0ea20dcda2a8c148147ccc07ecde56e4/PyFunctional-1.4.3.tar.gz +BuildArch: noarch + +Requires: python3-dill +Requires: python3-tabulate +Requires: python3-pandas + +%description +`map(func)/select(func)` | Maps `func` onto elements of sequence | transformation +`starmap(func)/smap(func)` | Apply `func` to sequence with `itertools.starmap` | transformation +`filter(func)/where(func)` | Filters elements of sequence to only those where `func(element)` is `True` | transformation +`filter_not(func)` | Filters elements of sequence to only those where `func(element)` is `False` | transformation +`flatten()` | Flattens sequence of lists to a single sequence | transformation +`flat_map(func)` | `func` must return an iterable. Maps `func` to each element, then merges the result to one flat sequence | transformation +`group_by(func)` | Groups sequence into `(key, value)` pairs where `key=func(element)` and `value` is from the original sequence | transformation +`group_by_key()` | Groups sequence of `(key, value)` pairs by `key` | transformation +`reduce_by_key(func)` | Reduces list of `(key, value)` pairs using `func` | transformation +`count_by_key()` | Counts occurrences of each `key` in list of `(key, value)` pairs | transformation +`count_by_value()` | Counts occurrence of each value in a list | transformation +`union(other)` | Union of unique elements in sequence and `other` | transformation +`intersection(other)` | Intersection of unique elements in sequence and `other` | transformation +`difference(other)` | New sequence with unique elements present in sequence but not in `other` | transformation +`symmetric_difference(other)` | New sequence with unique elements present in sequence or `other`, but not both | transformation +`distinct()` | Returns distinct elements of sequence. Elements must be hashable | transformation +`distinct_by(func)` | Returns distinct elements of sequence using `func` as a key | transformation +`drop(n)` | Drop the first `n` elements of the sequence | transformation +`drop_right(n)` | Drop the last `n` elements of the sequence | transformation +`drop_while(func)` | Drop elements while `func` evaluates to `True`, then returns the rest | transformation +`take(n)` | Returns sequence of first `n` elements | transformation +`take_while(func)` | Take elements while `func` evaluates to `True`, then drops the rest | transformation +`init()` | Returns sequence without the last element | transformation +`tail()` | Returns sequence without the first element | transformation +`inits()` | Returns consecutive inits of sequence | transformation +`tails()` | Returns consecutive tails of sequence | transformation +`zip(other)` | Zips the sequence with `other` | transformation +`zip_with_index(start=0)` | Zips the sequence with the index starting at `start` on the right side | transformation +`enumerate(start=0)` | Zips the sequence with the index starting at `start` on the left side | transformation +`cartesian(*iterables, repeat=1)` | Returns cartesian product from itertools.product | transformation +`inner_join(other)` | Returns inner join of sequence with other. Must be a sequence of `(key, value)` pairs | transformation +`outer_join(other)` | Returns outer join of sequence with other. Must be a sequence of `(key, value)` pairs | transformation +`left_join(other)` | Returns left join of sequence with other. Must be a sequence of `(key, value)` pairs | transformation +`right_join(other)` | Returns right join of sequence with other. Must be a sequence of `(key, value)` pairs | transformation +`join(other, join_type='inner')` | Returns join of sequence with other as specified by `join_type`. Must be a sequence of `(key, value)` pairs | transformation +`partition(func)` | Partitions the sequence into elements which satisfy `func(element)` and those that don't | transformation +`grouped(size)` | Partitions the elements into groups of size `size` | transformation +`sorted(key=None, reverse=False)/order_by(func)` | Returns elements sorted according to python `sorted` | transformation +`reverse()` | Returns the reversed sequence | transformation +`slice(start, until)` | Sequence starting at `start` and including elements up to `until` | transformation +`head()` / `first()` | Returns first element in sequence | action +`head_option()` | Returns first element in sequence or `None` if its empty | action +`last()` | Returns last element in sequence | action +`last_option()` | Returns last element in sequence or `None` if its empty | action +`len()` / `size()` | Returns length of sequence | action +`count(func)` | Returns count of elements in sequence where `func(element)` is True | action +`empty()` | Returns `True` if the sequence has zero length | action +`non_empty()` | Returns `True` if sequence has non-zero length | action +`all()` | Returns `True` if all elements in sequence are truthy | action +`exists(func)` | Returns `True` if `func(element)` for any element in the sequence is `True` | action +`for_all(func)` | Returns `True` if `func(element)` is `True` for all elements in the sequence | action +`find(func)` | Returns the element that first evaluates `func(element)` to `True` | action +`any()` | Returns `True` if any element in sequence is truthy | action +`max()` | Returns maximal element in sequence | action +`min()` | Returns minimal element in sequence | action +`max_by(func)` | Returns element with maximal value `func(element)` | action +`min_by(func)` | Returns element with minimal value `func(element)` | action +`sum()/sum(projection)` | Returns the sum of elements possibly using a projection | action +`product()/product(projection)` | Returns the product of elements possibly using a projection | action +`average()/average(projection)` | Returns the average of elements possibly using a projection | action +`aggregate(func)/aggregate(seed, func)/aggregate(seed, func, result_map)` | Aggregate using `func` starting with `seed` or first element of list then apply `result_map` to the result | action +`fold_left(zero_value, func)` | Reduces element from left to right using `func` and initial value `zero_value` | action +`fold_right(zero_value, func)` | Reduces element from right to left using `func` and initial value `zero_value` | action +`make_string(separator)` | Returns string with `separator` between each `str(element)` | action +`dict(default=None)` / `to_dict(default=None)` | Converts a sequence of `(Key, Value)` pairs to a `dictionary`. If `default` is not None, it must be a value or zero argument callable which will be used to create a `collections.defaultdict` | action +`list()` / `to_list()` | Converts sequence to a list | action +`set() / to_set()` | Converts sequence to a set | action +`to_file(path)` | Saves the sequence to a file at path with each element on a newline | action +`to_csv(path)` | Saves the sequence to a csv file at path with each element representing a row | action +`to_jsonl(path)` | Saves the sequence to a jsonl file with each element being transformed to json and printed to a new line | action +`to_json(path)` | Saves the sequence to a json file. The contents depend on if the json root is an array or dictionary | action +`to_sqlite3(conn, tablename_or_query, *args, **kwargs)` | Save the sequence to a SQLite3 db. The target table must be created in advance. | action +`to_pandas(columns=None)` | Converts the sequence to a pandas DataFrame | action +`cache()` | Forces evaluation of sequence immediately and caches the result | action +`for_each(func)` | Executes `func` on each element of the sequence | action +### Lazy Execution +Whenever possible, `PyFunctional` will compute lazily. This is accomplished by tracking the list +of transformations that have been applied to the sequence and only evaluating them when an action is +called. In `PyFunctional` this is called tracking lineage. This is also responsible for the +ability for `PyFunctional` to cache results of computation to prevent expensive re-computation. +This is predominantly done to preserve sensible behavior and used sparingly. For example, calling +`size()` will cache the underlying sequence. If this was not done and the input was an iterator, +then further calls would operate on an expired iterator since it was used to compute the length. +Similarly, `repr` also caches since it is most often used during interactive sessions where its +undesirable to keep recomputing the same value. Below are some examples of inspecting lineage. +```python +def times_2(x): + print(x) + return 2 * x +elements = seq(1, 1, 2, 3, 4).map(times_2).distinct() +elements._lineage +# Lineage: sequence -> map(times_2) -> distinct +l_elements = elements.to_list() +# Prints: 1 +# Prints: 1 +# Prints: 2 +# Prints: 3 +# Prints: 4 +elements._lineage +# Lineage: sequence -> map(times_2) -> distinct -> cache +l_elements = elements.to_list() +# The cached result is returned so times_2 is not called and nothing is printed +``` +Files are given special treatment if opened through the `seq.open` and related APIs. +`functional.util.ReusableFile` implements a wrapper around the standard python file to support +multiple iteration over a single file object while correctly handling iteration termination and +file closing. +## Road Map Idea +* SQL based query planner and interpreter +* `_` lambda operator +## Contributing and Bug Fixes +Any contributions or bug reports are welcome. Thus far, there is a 100% acceptance rate for pull +requests and contributors have offered valuable feedback and critique on code. It is great to hear +from users of the package, especially what it is used for, what works well, and what could be +improved. +To contribute, create a fork of `PyFunctional`, make your changes, then make sure that they pass. +In order to be merged, all pull requests must: +* Pass all the unit tests +* Pass all the pylint tests, or ignore warnings with explanation of why its correct to do so +* Not significantly reduce covrage without a good reason [coveralls.io](coveralls.io/github/EntilZha/PyFunctional)) +* Edit the `CHANGELOG.md` file in the `Next Release` heading with changes +## Contact +[Gitter for chat](https://gitter.im/EntilZha/PyFunctional) +## Supported Python Versions +* `PyFunctional` 1.4 and above supports and is tested against Python 3.6, Python 3.7, and PyPy3 +* `PyFunctional` 1.4 and above does not support python 2.7 +* `PyFunctional` 1.4 and above works in Python 3.5, but is not tested against it +* `PyFunctional` 1.4 and above partially works in 3.8, parallel processing currently has issues, but other feature work fine +* `PyFunctional` 1.3 and below supports and was tested against Python 2.7, Python 3.5, Python 3.6, PyPy2, and PyPy3 +## Changelog +[Changelog](https://github.com/EntilZha/PyFunctional/blob/master/CHANGELOG.md) +## About me +To learn more about me (the author) visit my webpage at +[pedro.ai](https://www.pedro.ai). +I created `PyFunctional` while using Python extensivel, and finding that I missed the +ease of use for manipulating data that Spark RDDs and Scala collections have. The project takes the +best ideas from these APIs as well as LINQ to provide an easy way to manipulate data when using +Scala is not an option or PySpark is overkill. +## Contributors +These people have generously contributed their time to improving `PyFunctional` +* [versae](https://github.com/versae) +* [adrian17](https://github.com/adrian17) +* [lucidfrontier45](https://github.com/lucidfrontier45) +* [Digenis](https://github.com/Digenis) +* [ChuyuHsu](https://github.com/ChuyuHsu) +* [jsemric](https://github.com/jsemric) + +%package -n python3-pyfunctional +Summary: Package for creating data pipelines with chain functional programming +Provides: python-pyfunctional +BuildRequires: python3-devel +BuildRequires: python3-setuptools +BuildRequires: python3-pip +%description -n python3-pyfunctional +`map(func)/select(func)` | Maps `func` onto elements of sequence | transformation +`starmap(func)/smap(func)` | Apply `func` to sequence with `itertools.starmap` | transformation +`filter(func)/where(func)` | Filters elements of sequence to only those where `func(element)` is `True` | transformation +`filter_not(func)` | Filters elements of sequence to only those where `func(element)` is `False` | transformation +`flatten()` | Flattens sequence of lists to a single sequence | transformation +`flat_map(func)` | `func` must return an iterable. Maps `func` to each element, then merges the result to one flat sequence | transformation +`group_by(func)` | Groups sequence into `(key, value)` pairs where `key=func(element)` and `value` is from the original sequence | transformation +`group_by_key()` | Groups sequence of `(key, value)` pairs by `key` | transformation +`reduce_by_key(func)` | Reduces list of `(key, value)` pairs using `func` | transformation +`count_by_key()` | Counts occurrences of each `key` in list of `(key, value)` pairs | transformation +`count_by_value()` | Counts occurrence of each value in a list | transformation +`union(other)` | Union of unique elements in sequence and `other` | transformation +`intersection(other)` | Intersection of unique elements in sequence and `other` | transformation +`difference(other)` | New sequence with unique elements present in sequence but not in `other` | transformation +`symmetric_difference(other)` | New sequence with unique elements present in sequence or `other`, but not both | transformation +`distinct()` | Returns distinct elements of sequence. Elements must be hashable | transformation +`distinct_by(func)` | Returns distinct elements of sequence using `func` as a key | transformation +`drop(n)` | Drop the first `n` elements of the sequence | transformation +`drop_right(n)` | Drop the last `n` elements of the sequence | transformation +`drop_while(func)` | Drop elements while `func` evaluates to `True`, then returns the rest | transformation +`take(n)` | Returns sequence of first `n` elements | transformation +`take_while(func)` | Take elements while `func` evaluates to `True`, then drops the rest | transformation +`init()` | Returns sequence without the last element | transformation +`tail()` | Returns sequence without the first element | transformation +`inits()` | Returns consecutive inits of sequence | transformation +`tails()` | Returns consecutive tails of sequence | transformation +`zip(other)` | Zips the sequence with `other` | transformation +`zip_with_index(start=0)` | Zips the sequence with the index starting at `start` on the right side | transformation +`enumerate(start=0)` | Zips the sequence with the index starting at `start` on the left side | transformation +`cartesian(*iterables, repeat=1)` | Returns cartesian product from itertools.product | transformation +`inner_join(other)` | Returns inner join of sequence with other. Must be a sequence of `(key, value)` pairs | transformation +`outer_join(other)` | Returns outer join of sequence with other. Must be a sequence of `(key, value)` pairs | transformation +`left_join(other)` | Returns left join of sequence with other. Must be a sequence of `(key, value)` pairs | transformation +`right_join(other)` | Returns right join of sequence with other. Must be a sequence of `(key, value)` pairs | transformation +`join(other, join_type='inner')` | Returns join of sequence with other as specified by `join_type`. Must be a sequence of `(key, value)` pairs | transformation +`partition(func)` | Partitions the sequence into elements which satisfy `func(element)` and those that don't | transformation +`grouped(size)` | Partitions the elements into groups of size `size` | transformation +`sorted(key=None, reverse=False)/order_by(func)` | Returns elements sorted according to python `sorted` | transformation +`reverse()` | Returns the reversed sequence | transformation +`slice(start, until)` | Sequence starting at `start` and including elements up to `until` | transformation +`head()` / `first()` | Returns first element in sequence | action +`head_option()` | Returns first element in sequence or `None` if its empty | action +`last()` | Returns last element in sequence | action +`last_option()` | Returns last element in sequence or `None` if its empty | action +`len()` / `size()` | Returns length of sequence | action +`count(func)` | Returns count of elements in sequence where `func(element)` is True | action +`empty()` | Returns `True` if the sequence has zero length | action +`non_empty()` | Returns `True` if sequence has non-zero length | action +`all()` | Returns `True` if all elements in sequence are truthy | action +`exists(func)` | Returns `True` if `func(element)` for any element in the sequence is `True` | action +`for_all(func)` | Returns `True` if `func(element)` is `True` for all elements in the sequence | action +`find(func)` | Returns the element that first evaluates `func(element)` to `True` | action +`any()` | Returns `True` if any element in sequence is truthy | action +`max()` | Returns maximal element in sequence | action +`min()` | Returns minimal element in sequence | action +`max_by(func)` | Returns element with maximal value `func(element)` | action +`min_by(func)` | Returns element with minimal value `func(element)` | action +`sum()/sum(projection)` | Returns the sum of elements possibly using a projection | action +`product()/product(projection)` | Returns the product of elements possibly using a projection | action +`average()/average(projection)` | Returns the average of elements possibly using a projection | action +`aggregate(func)/aggregate(seed, func)/aggregate(seed, func, result_map)` | Aggregate using `func` starting with `seed` or first element of list then apply `result_map` to the result | action +`fold_left(zero_value, func)` | Reduces element from left to right using `func` and initial value `zero_value` | action +`fold_right(zero_value, func)` | Reduces element from right to left using `func` and initial value `zero_value` | action +`make_string(separator)` | Returns string with `separator` between each `str(element)` | action +`dict(default=None)` / `to_dict(default=None)` | Converts a sequence of `(Key, Value)` pairs to a `dictionary`. If `default` is not None, it must be a value or zero argument callable which will be used to create a `collections.defaultdict` | action +`list()` / `to_list()` | Converts sequence to a list | action +`set() / to_set()` | Converts sequence to a set | action +`to_file(path)` | Saves the sequence to a file at path with each element on a newline | action +`to_csv(path)` | Saves the sequence to a csv file at path with each element representing a row | action +`to_jsonl(path)` | Saves the sequence to a jsonl file with each element being transformed to json and printed to a new line | action +`to_json(path)` | Saves the sequence to a json file. The contents depend on if the json root is an array or dictionary | action +`to_sqlite3(conn, tablename_or_query, *args, **kwargs)` | Save the sequence to a SQLite3 db. The target table must be created in advance. | action +`to_pandas(columns=None)` | Converts the sequence to a pandas DataFrame | action +`cache()` | Forces evaluation of sequence immediately and caches the result | action +`for_each(func)` | Executes `func` on each element of the sequence | action +### Lazy Execution +Whenever possible, `PyFunctional` will compute lazily. This is accomplished by tracking the list +of transformations that have been applied to the sequence and only evaluating them when an action is +called. In `PyFunctional` this is called tracking lineage. This is also responsible for the +ability for `PyFunctional` to cache results of computation to prevent expensive re-computation. +This is predominantly done to preserve sensible behavior and used sparingly. For example, calling +`size()` will cache the underlying sequence. If this was not done and the input was an iterator, +then further calls would operate on an expired iterator since it was used to compute the length. +Similarly, `repr` also caches since it is most often used during interactive sessions where its +undesirable to keep recomputing the same value. Below are some examples of inspecting lineage. +```python +def times_2(x): + print(x) + return 2 * x +elements = seq(1, 1, 2, 3, 4).map(times_2).distinct() +elements._lineage +# Lineage: sequence -> map(times_2) -> distinct +l_elements = elements.to_list() +# Prints: 1 +# Prints: 1 +# Prints: 2 +# Prints: 3 +# Prints: 4 +elements._lineage +# Lineage: sequence -> map(times_2) -> distinct -> cache +l_elements = elements.to_list() +# The cached result is returned so times_2 is not called and nothing is printed +``` +Files are given special treatment if opened through the `seq.open` and related APIs. +`functional.util.ReusableFile` implements a wrapper around the standard python file to support +multiple iteration over a single file object while correctly handling iteration termination and +file closing. +## Road Map Idea +* SQL based query planner and interpreter +* `_` lambda operator +## Contributing and Bug Fixes +Any contributions or bug reports are welcome. Thus far, there is a 100% acceptance rate for pull +requests and contributors have offered valuable feedback and critique on code. It is great to hear +from users of the package, especially what it is used for, what works well, and what could be +improved. +To contribute, create a fork of `PyFunctional`, make your changes, then make sure that they pass. +In order to be merged, all pull requests must: +* Pass all the unit tests +* Pass all the pylint tests, or ignore warnings with explanation of why its correct to do so +* Not significantly reduce covrage without a good reason [coveralls.io](coveralls.io/github/EntilZha/PyFunctional)) +* Edit the `CHANGELOG.md` file in the `Next Release` heading with changes +## Contact +[Gitter for chat](https://gitter.im/EntilZha/PyFunctional) +## Supported Python Versions +* `PyFunctional` 1.4 and above supports and is tested against Python 3.6, Python 3.7, and PyPy3 +* `PyFunctional` 1.4 and above does not support python 2.7 +* `PyFunctional` 1.4 and above works in Python 3.5, but is not tested against it +* `PyFunctional` 1.4 and above partially works in 3.8, parallel processing currently has issues, but other feature work fine +* `PyFunctional` 1.3 and below supports and was tested against Python 2.7, Python 3.5, Python 3.6, PyPy2, and PyPy3 +## Changelog +[Changelog](https://github.com/EntilZha/PyFunctional/blob/master/CHANGELOG.md) +## About me +To learn more about me (the author) visit my webpage at +[pedro.ai](https://www.pedro.ai). +I created `PyFunctional` while using Python extensivel, and finding that I missed the +ease of use for manipulating data that Spark RDDs and Scala collections have. The project takes the +best ideas from these APIs as well as LINQ to provide an easy way to manipulate data when using +Scala is not an option or PySpark is overkill. +## Contributors +These people have generously contributed their time to improving `PyFunctional` +* [versae](https://github.com/versae) +* [adrian17](https://github.com/adrian17) +* [lucidfrontier45](https://github.com/lucidfrontier45) +* [Digenis](https://github.com/Digenis) +* [ChuyuHsu](https://github.com/ChuyuHsu) +* [jsemric](https://github.com/jsemric) + +%package help +Summary: Development documents and examples for pyfunctional +Provides: python3-pyfunctional-doc +%description help +`map(func)/select(func)` | Maps `func` onto elements of sequence | transformation +`starmap(func)/smap(func)` | Apply `func` to sequence with `itertools.starmap` | transformation +`filter(func)/where(func)` | Filters elements of sequence to only those where `func(element)` is `True` | transformation +`filter_not(func)` | Filters elements of sequence to only those where `func(element)` is `False` | transformation +`flatten()` | Flattens sequence of lists to a single sequence | transformation +`flat_map(func)` | `func` must return an iterable. Maps `func` to each element, then merges the result to one flat sequence | transformation +`group_by(func)` | Groups sequence into `(key, value)` pairs where `key=func(element)` and `value` is from the original sequence | transformation +`group_by_key()` | Groups sequence of `(key, value)` pairs by `key` | transformation +`reduce_by_key(func)` | Reduces list of `(key, value)` pairs using `func` | transformation +`count_by_key()` | Counts occurrences of each `key` in list of `(key, value)` pairs | transformation +`count_by_value()` | Counts occurrence of each value in a list | transformation +`union(other)` | Union of unique elements in sequence and `other` | transformation +`intersection(other)` | Intersection of unique elements in sequence and `other` | transformation +`difference(other)` | New sequence with unique elements present in sequence but not in `other` | transformation +`symmetric_difference(other)` | New sequence with unique elements present in sequence or `other`, but not both | transformation +`distinct()` | Returns distinct elements of sequence. Elements must be hashable | transformation +`distinct_by(func)` | Returns distinct elements of sequence using `func` as a key | transformation +`drop(n)` | Drop the first `n` elements of the sequence | transformation +`drop_right(n)` | Drop the last `n` elements of the sequence | transformation +`drop_while(func)` | Drop elements while `func` evaluates to `True`, then returns the rest | transformation +`take(n)` | Returns sequence of first `n` elements | transformation +`take_while(func)` | Take elements while `func` evaluates to `True`, then drops the rest | transformation +`init()` | Returns sequence without the last element | transformation +`tail()` | Returns sequence without the first element | transformation +`inits()` | Returns consecutive inits of sequence | transformation +`tails()` | Returns consecutive tails of sequence | transformation +`zip(other)` | Zips the sequence with `other` | transformation +`zip_with_index(start=0)` | Zips the sequence with the index starting at `start` on the right side | transformation +`enumerate(start=0)` | Zips the sequence with the index starting at `start` on the left side | transformation +`cartesian(*iterables, repeat=1)` | Returns cartesian product from itertools.product | transformation +`inner_join(other)` | Returns inner join of sequence with other. Must be a sequence of `(key, value)` pairs | transformation +`outer_join(other)` | Returns outer join of sequence with other. Must be a sequence of `(key, value)` pairs | transformation +`left_join(other)` | Returns left join of sequence with other. Must be a sequence of `(key, value)` pairs | transformation +`right_join(other)` | Returns right join of sequence with other. Must be a sequence of `(key, value)` pairs | transformation +`join(other, join_type='inner')` | Returns join of sequence with other as specified by `join_type`. Must be a sequence of `(key, value)` pairs | transformation +`partition(func)` | Partitions the sequence into elements which satisfy `func(element)` and those that don't | transformation +`grouped(size)` | Partitions the elements into groups of size `size` | transformation +`sorted(key=None, reverse=False)/order_by(func)` | Returns elements sorted according to python `sorted` | transformation +`reverse()` | Returns the reversed sequence | transformation +`slice(start, until)` | Sequence starting at `start` and including elements up to `until` | transformation +`head()` / `first()` | Returns first element in sequence | action +`head_option()` | Returns first element in sequence or `None` if its empty | action +`last()` | Returns last element in sequence | action +`last_option()` | Returns last element in sequence or `None` if its empty | action +`len()` / `size()` | Returns length of sequence | action +`count(func)` | Returns count of elements in sequence where `func(element)` is True | action +`empty()` | Returns `True` if the sequence has zero length | action +`non_empty()` | Returns `True` if sequence has non-zero length | action +`all()` | Returns `True` if all elements in sequence are truthy | action +`exists(func)` | Returns `True` if `func(element)` for any element in the sequence is `True` | action +`for_all(func)` | Returns `True` if `func(element)` is `True` for all elements in the sequence | action +`find(func)` | Returns the element that first evaluates `func(element)` to `True` | action +`any()` | Returns `True` if any element in sequence is truthy | action +`max()` | Returns maximal element in sequence | action +`min()` | Returns minimal element in sequence | action +`max_by(func)` | Returns element with maximal value `func(element)` | action +`min_by(func)` | Returns element with minimal value `func(element)` | action +`sum()/sum(projection)` | Returns the sum of elements possibly using a projection | action +`product()/product(projection)` | Returns the product of elements possibly using a projection | action +`average()/average(projection)` | Returns the average of elements possibly using a projection | action +`aggregate(func)/aggregate(seed, func)/aggregate(seed, func, result_map)` | Aggregate using `func` starting with `seed` or first element of list then apply `result_map` to the result | action +`fold_left(zero_value, func)` | Reduces element from left to right using `func` and initial value `zero_value` | action +`fold_right(zero_value, func)` | Reduces element from right to left using `func` and initial value `zero_value` | action +`make_string(separator)` | Returns string with `separator` between each `str(element)` | action +`dict(default=None)` / `to_dict(default=None)` | Converts a sequence of `(Key, Value)` pairs to a `dictionary`. If `default` is not None, it must be a value or zero argument callable which will be used to create a `collections.defaultdict` | action +`list()` / `to_list()` | Converts sequence to a list | action +`set() / to_set()` | Converts sequence to a set | action +`to_file(path)` | Saves the sequence to a file at path with each element on a newline | action +`to_csv(path)` | Saves the sequence to a csv file at path with each element representing a row | action +`to_jsonl(path)` | Saves the sequence to a jsonl file with each element being transformed to json and printed to a new line | action +`to_json(path)` | Saves the sequence to a json file. The contents depend on if the json root is an array or dictionary | action +`to_sqlite3(conn, tablename_or_query, *args, **kwargs)` | Save the sequence to a SQLite3 db. The target table must be created in advance. | action +`to_pandas(columns=None)` | Converts the sequence to a pandas DataFrame | action +`cache()` | Forces evaluation of sequence immediately and caches the result | action +`for_each(func)` | Executes `func` on each element of the sequence | action +### Lazy Execution +Whenever possible, `PyFunctional` will compute lazily. This is accomplished by tracking the list +of transformations that have been applied to the sequence and only evaluating them when an action is +called. In `PyFunctional` this is called tracking lineage. This is also responsible for the +ability for `PyFunctional` to cache results of computation to prevent expensive re-computation. +This is predominantly done to preserve sensible behavior and used sparingly. For example, calling +`size()` will cache the underlying sequence. If this was not done and the input was an iterator, +then further calls would operate on an expired iterator since it was used to compute the length. +Similarly, `repr` also caches since it is most often used during interactive sessions where its +undesirable to keep recomputing the same value. Below are some examples of inspecting lineage. +```python +def times_2(x): + print(x) + return 2 * x +elements = seq(1, 1, 2, 3, 4).map(times_2).distinct() +elements._lineage +# Lineage: sequence -> map(times_2) -> distinct +l_elements = elements.to_list() +# Prints: 1 +# Prints: 1 +# Prints: 2 +# Prints: 3 +# Prints: 4 +elements._lineage +# Lineage: sequence -> map(times_2) -> distinct -> cache +l_elements = elements.to_list() +# The cached result is returned so times_2 is not called and nothing is printed +``` +Files are given special treatment if opened through the `seq.open` and related APIs. +`functional.util.ReusableFile` implements a wrapper around the standard python file to support +multiple iteration over a single file object while correctly handling iteration termination and +file closing. +## Road Map Idea +* SQL based query planner and interpreter +* `_` lambda operator +## Contributing and Bug Fixes +Any contributions or bug reports are welcome. Thus far, there is a 100% acceptance rate for pull +requests and contributors have offered valuable feedback and critique on code. It is great to hear +from users of the package, especially what it is used for, what works well, and what could be +improved. +To contribute, create a fork of `PyFunctional`, make your changes, then make sure that they pass. +In order to be merged, all pull requests must: +* Pass all the unit tests +* Pass all the pylint tests, or ignore warnings with explanation of why its correct to do so +* Not significantly reduce covrage without a good reason [coveralls.io](coveralls.io/github/EntilZha/PyFunctional)) +* Edit the `CHANGELOG.md` file in the `Next Release` heading with changes +## Contact +[Gitter for chat](https://gitter.im/EntilZha/PyFunctional) +## Supported Python Versions +* `PyFunctional` 1.4 and above supports and is tested against Python 3.6, Python 3.7, and PyPy3 +* `PyFunctional` 1.4 and above does not support python 2.7 +* `PyFunctional` 1.4 and above works in Python 3.5, but is not tested against it +* `PyFunctional` 1.4 and above partially works in 3.8, parallel processing currently has issues, but other feature work fine +* `PyFunctional` 1.3 and below supports and was tested against Python 2.7, Python 3.5, Python 3.6, PyPy2, and PyPy3 +## Changelog +[Changelog](https://github.com/EntilZha/PyFunctional/blob/master/CHANGELOG.md) +## About me +To learn more about me (the author) visit my webpage at +[pedro.ai](https://www.pedro.ai). +I created `PyFunctional` while using Python extensivel, and finding that I missed the +ease of use for manipulating data that Spark RDDs and Scala collections have. The project takes the +best ideas from these APIs as well as LINQ to provide an easy way to manipulate data when using +Scala is not an option or PySpark is overkill. +## Contributors +These people have generously contributed their time to improving `PyFunctional` +* [versae](https://github.com/versae) +* [adrian17](https://github.com/adrian17) +* [lucidfrontier45](https://github.com/lucidfrontier45) +* [Digenis](https://github.com/Digenis) +* [ChuyuHsu](https://github.com/ChuyuHsu) +* [jsemric](https://github.com/jsemric) + +%prep +%autosetup -n pyfunctional-1.4.3 + +%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-pyfunctional -f filelist.lst +%dir %{python3_sitelib}/* + +%files help -f doclist.lst +%{_docdir}/* + +%changelog +* Mon Apr 10 2023 Python_Bot <Python_Bot@openeuler.org> - 1.4.3-1 +- Package Spec generated |