<p align="center">
<img src="https://github.com/kaliv0/pyrio/blob/main/assets/Pyrio.jpg?raw=true" width="400" alt="Pyrio">
</p>
# PYRIO
[](https://github.com/kaliv0/pyrio/actions/workflows/ci.yml)
[](https://codecov.io/gh/kaliv0/pyrio)
[](https://pypi.org/project/pyrio/)
[](https://pepy.tech/projects/pyrio)
<br><b>Functional-style Streams API library</b><br>
<br>Facilitates processing of collections and iterables using fluent APIs.
<br>Gives access to files of various types (<i>json</i>, <i>toml</i>, <i>yaml</i>, <i>xml</i>, <i>csv</i> and <i>tsv</i>) for reading and executing complex queries
<br>Provides easy integration with <i>itertools</i>
<br>(NB: Commonly used <i>itertools 'recipes'</i> are included as part of the main APIs)
## How to use
### Creating streams
- stream from iterable
```python
Stream([1, 2, 3])
```
- from variadic arguments
```python
Stream.of(1, 2, 3)
```
- empty stream
```python
Stream.empty()
```
- infinite ordered stream
```python
Stream.iterate(0, lambda x: x + 1)
```
- infinite unordered stream
```python
import random
Stream.generate(lambda: random.random())
```
- infinite stream with given value
```python
Stream.constant(42)
```
- concat
<br>(concatenate several streams together or add new streams to the current one)
```python
Stream.concat((1, 2, 3), [5, 6]).to_list()
Stream.of(1, 2, 3).concat([4, 5]).to_list()
```
- prepend
<br>(prepend iterable to current stream)
```python
Stream([2, 3, 4]).prepend(0, 1).to_list()
```
--------------------------------------------
### Intermediate operations
- filter
```python
Stream([1, 2, 3]).filter(lambda x: x % 2 == 0)
```
- map
```python
Stream([1, 2, 3]).map(str).to_list()
Stream([1, 2, 3]).map(lambda x: x + 5).to_list()
```
- filter_map
<br>(filter out all None or falsy values (if falsy=True) and applies mapper function to the elements of the stream)
```python
Stream.of(None, "foo", "", "bar", 0, []).filter_map(str.upper, falsy=True).to_list()
```
```shell
["FOO", "BAR"]
```
- flat_map
<br>(map each element of the stream and yields the elements of the produced iterators)
```python
Stream([[1, 2], [3, 4], [5]]).flat_map(lambda x: Stream(x)).to_list()
```
```shell
[1, 2, 3, 4, 5]
```
- flatten
```python
Stream([[1, 2], [3, 4], [5]]).flatten().to_list()
```
```shell
[1, 2, 3, 4, 5]
```
- reduce
<br>(returns Optional)
```python
Stream([1, 2, 3]).reduce(lambda acc, val: acc + val, identity=3).get()
```
- peek
<br>(perform the provided operation on each element of the stream without consuming it)
```python
(Stream([1, 2, 3, 4])
.filter(lambda x: x > 2)
.peek(lambda x: print(f"{x} ", end=""))
.map(lambda x: x * 20)
.to_list())
```
- view
<br>(provides access to a selected part of the stream)
```python
Stream([1, 2, 3, 4, 5, 6, 7, 8, 9]).view(start=1, stop=-3, step=2).to_list()
```
```shell
[2, 4, 6]
```
- distinct
<br>(returns a stream with the distinct elements of the current one)
```python
Stream([1, 1, 2, 2, 2, 3]).distinct().to_list()
```
- skip
<br>(discards the first n elements of the stream and returns a new stream with the remaining ones)
```python
Stream.iterate(0, lambda x: x + 1).skip(5).limit(5).to_list()
```
- limit / head
<br>(returns a stream with the first n elements, or fewer if the underlying iterator ends sooner)
```python
Stream([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]).limit(3).to_tuple()
Stream([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]).head(3).to_tuple()
```
- tail
<br>(returns a stream with the last n elements, or fewer if the underlying iterator ends sooner)
```python
Stream([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]).tail(3).to_tuple()
```
- take_while
<br>(returns a stream that yields elements based on a predicate)
```python
Stream.of(1, 2, 3, 4, 5, 6, 7, 2, 3).take_while(lambda x: x < 5).to_list()
```
```shell
[1, 2, 3, 4]
```
- drop_while
<br>(returns a stream that skips elements based on a predicate and yields the remaining ones)
```python
Stream.of(1, 2, 3, 5, 6, 7, 2).drop_while(lambda x: x < 5).to_list()
```
```shell
[5, 6, 7, 2]
```
- sorted
<br>(sorts the elements of the current stream according to natural order or based on the given comparator;
<br>if 'reverse' flag is True, the elements are sorted in descending order)
```python
(Stream.of((3, 30), (2, 30), (2, 20), (1, 20), (1, 10))
.sorted(lambda x: (x[0], x[1]), reverse=True)
.to_list())
```
```shell
[(3, 30), (2, 30), (2, 20), (1, 20), (1, 10)]
```
--------------------------------------------
### Terminal operations
#### Collectors
- collecting result into list, tuple, set
```python
Stream([1, 2, 3]).to_list()
Stream([1, 2, 3]).to_tuple()
Stream([1, 2, 3]).to_set()
```
- into dict
```python
class Foo:
def __init__(self, name, num):
self.name = name
self.num = num
Stream([Foo("fizz", 1), Foo("buzz", 2)]).to_dict(lambda x: (x.name, x.num))
```
```shell
{"fizz": 1, "buzz": 2}
```
In the case of a collision (duplicate keys) the 'merger' functions indicates which entry should be kept
```python
collection = [Foo("fizz", 1), Foo("fizz", 2), Foo("buzz", 2)]
Stream(collection).to_dict(collector=lambda x: (x.name, x.num), merger=lambda old, new: old)
```
```shell
{"fizz": 1, "buzz": 2}
```
- alternative for working with collectors is using the <i>collect</i> method
```python
Stream([1, 2, 3]).collect(tuple)
Stream.of(1, 2, 3).collect(list)
Stream.of(1, 1, 2, 2, 2, 3).collect(set)
Stream.of(1, 2, 3, 4).collect(dict, lambda x: (str(x), x * 10))
```
- grouping
```python
Stream("AAAABBBCCD").group_by(collector=lambda key, grouper: (key, len(grouper)))
```
```shell
{"A": 4, "B": 3, "C": 2, "D": 1}
```
```python
coll = [Foo("fizz", 1), Foo("fizz", 2), Foo("fizz", 3), Foo("buzz", 2), Foo("buzz", 3), Foo("buzz", 4), Foo("buzz", 5)]
Stream(coll).group_by(
classifier=lambda obj: obj.name,
collector=lambda key, grouper: (key, [(obj.name, obj.num) for obj in list(grouper)]))
```
```shell
{
"fizz": [("fizz", 1), ("fizz", 2), ("fizz", 3)],
"buzz": [("buzz", 2), ("buzz", 3), ("buzz", 4), ("buzz", 5)],
}
```
#### Other terminal operations
- for_each
```python
Stream([1, 2, 3, 4]).for_each(lambda x: print(f"{'#' * x} ", end=""))
```
- count
<br>(returns the count of elements in the stream)
```python
Stream([1, 2, 3, 4]).filter(lambda x: x % 2 == 0).count()
```
- sum
```python
Stream.of(1, 2, 3, 4).sum()
```
- find_first
<br>(search for an element of the stream that satisfies a predicate,
returns an Optional with the first found value, if any, or None)
```python
Stream.of(1, 2, 3, 4).filter(lambda x: x % 2 == 0).find_first().get()
```
- find_any
<br>(search for an element of the stream that satisfies a predicate,
returns an Optional with some of the found values, if any, or None)
```python
Stream.of(1, 2, 3, 4).filter(lambda x: x % 2 == 0).find_any().get()
```
- any_match
<br>(returns whether any elements of the stream match the given predicate)
```python
Stream.of(1, 2, 3, 4).any_match(lambda x: x > 2)
```
- all_match
<br>(returns whether all elements of the stream match the given predicate)
```python
Stream.of(1, 2, 3, 4).all_match(lambda x: x > 2)
```
- none_match
<br>(returns whether no elements of the stream match the given predicate)
```python
Stream.of(1, 2, 3, 4).none_match(lambda x: x < 0)
```
- min
<br>(returns Optional with the minimum element of the stream)
```python
Stream.of(2, 1, 3, 4).min().get()
```
- max
<br>(returns Optional with the maximum element of the stream)
```python
Stream.of(2, 1, 3, 4).max().get()
```
- compare_with
<br>(compares linearly the contents of two streams based on a given comparator)
```python
fizz = Foo("fizz", 1)
buzz = Foo("buzz", 2)
Stream([buzz, fizz]).compare_with(Stream([fizz, buzz]), lambda x, y: x.num == y.num)
```
- quantify
<br>(count how many of the elements are Truthy or evaluate to True based on a given predicate)
```python
Stream([2, 3, 4, 5, 6]).quantify(predicate=lambda x: x % 2 == 0)
```
--------------------------------------------
### Itertools integration
Invoke <i>use</i> method by passing the itertools function and it's arguments as **kwargs
```python
import itertools
import operator
Stream([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]).use(itertools.islice, start=3, stop=8)
Stream.of(1, 2, 3, 4, 5).use(itertools.accumulate, func=operator.mul).to_list()
Stream(range(3)).use(itertools.permutations, r=3).to_list()
```
#### Itertools 'recipes'
Invoke the 'recipes' described [here](https://docs.python.org/3/library/itertools.html#itertools-recipes) as stream methods and pass required key-word arguments
```python
Stream([1, 2, 3]).ncycles(count=2).to_list()
Stream.of(2, 3, 4).take_nth(10, default=66).get()
Stream(["ABC", "D", "EF"]).round_robin().to_list()
```
--------------------------------------------
### Querying files with FileStream
- working with <i>json</i>, <i>toml</i>, <i>yaml</i>, <i>xml</i> files
```python
FileStream("path/to/file").map(lambda x: f"{x.key}=>{x.value}").to_tuple()
```
```shell
(
"abc=>xyz",
"qwerty=>42",
)
```
```python
from operator import itemgetter
(FileStream("path/to/file")
.filter(lambda x: "a" in x.key)
.map(lambda x: (x.key, sum(x.value) * 10))
.sorted(itemgetter(1), reverse=True)
.map(lambda x: f"{str(x[1])}::{x[0]}")
.to_list())
```
```shell
["230::xza", "110::abba", "30::a"]
```
FileStream reads data as series of Item objects with key/value attributes.
- querying <i>csv</i> and <i>tsv</i> files
<br>(each row is read as a dict with keys taken from the header row)
```python
FileStream("path/to/file").map(lambda x: f"fizz: {x['fizz']}, buzz: {x['buzz']}").to_tuple()
```
```shell
(
"fizz: 42, buzz: 45",
"fizz: aaa, buzz: bbb",
)
```
```python
from operator import itemgetter
FileStream("path/to/file").map(itemgetter('fizz', 'buzz')).to_tuple()
```
```shell
(('42', '45'), ('aaa', 'bbb'))
```
Raw data
{
"_id": null,
"home_page": "https://github.com/kaliv0/pyrio",
"name": "pyrio",
"maintainer": null,
"docs_url": null,
"requires_python": "<4.0,>=3.12",
"maintainer_email": null,
"keywords": "Stream, functional, processing, collections, fluent API",
"author": "kaliv0",
"author_email": "kaloyan.ivanov88@gmail.com",
"download_url": "https://files.pythonhosted.org/packages/b7/15/0b47a505995d6beffa293a49054a234085bb65946f65862b9e318bfab5ed/pyrio-1.1.1.tar.gz",
"platform": null,
"description": "<p align=\"center\">\n <img src=\"https://github.com/kaliv0/pyrio/blob/main/assets/Pyrio.jpg?raw=true\" width=\"400\" alt=\"Pyrio\">\n</p>\n\n# PYRIO\n\n\n\n[](https://github.com/kaliv0/pyrio/actions/workflows/ci.yml)\n[](https://codecov.io/gh/kaliv0/pyrio)\n[](https://pypi.org/project/pyrio/)\n[](https://pepy.tech/projects/pyrio)\n\n<br><b>Functional-style Streams API library</b><br>\n<br>Facilitates processing of collections and iterables using fluent APIs.\n<br>Gives access to files of various types (<i>json</i>, <i>toml</i>, <i>yaml</i>, <i>xml</i>, <i>csv</i> and <i>tsv</i>) for reading and executing complex queries\n<br>Provides easy integration with <i>itertools</i>\n<br>(NB: Commonly used <i>itertools 'recipes'</i> are included as part of the main APIs)\n\n## How to use\n### Creating streams\n- stream from iterable\n```python\nStream([1, 2, 3])\n```\n\n- from variadic arguments\n```python\nStream.of(1, 2, 3)\n```\n\n- empty stream\n```python\nStream.empty()\n```\n\n- infinite ordered stream\n```python\nStream.iterate(0, lambda x: x + 1)\n```\n\n- infinite unordered stream\n```python\nimport random\n\nStream.generate(lambda: random.random())\n```\n\n- infinite stream with given value\n```python\nStream.constant(42)\n```\n\n- concat\n<br>(concatenate several streams together or add new streams to the current one)\n```python\nStream.concat((1, 2, 3), [5, 6]).to_list()\nStream.of(1, 2, 3).concat([4, 5]).to_list()\n```\n\n- prepend\n<br>(prepend iterable to current stream)\n```python\nStream([2, 3, 4]).prepend(0, 1).to_list()\n```\n--------------------------------------------\n### Intermediate operations\n- filter\n```python\nStream([1, 2, 3]).filter(lambda x: x % 2 == 0)\n```\n\n- map\n```python\nStream([1, 2, 3]).map(str).to_list()\nStream([1, 2, 3]).map(lambda x: x + 5).to_list()\n```\n\n- filter_map\n<br>(filter out all None or falsy values (if falsy=True) and applies mapper function to the elements of the stream)\n```python\nStream.of(None, \"foo\", \"\", \"bar\", 0, []).filter_map(str.upper, falsy=True).to_list()\n```\n```shell\n[\"FOO\", \"BAR\"]\n```\n\n- flat_map\n<br>(map each element of the stream and yields the elements of the produced iterators)\n```python\nStream([[1, 2], [3, 4], [5]]).flat_map(lambda x: Stream(x)).to_list()\n```\n```shell\n[1, 2, 3, 4, 5]\n```\n\n- flatten\n```python\nStream([[1, 2], [3, 4], [5]]).flatten().to_list()\n```\n```shell\n[1, 2, 3, 4, 5]\n```\n\n- reduce \n<br>(returns Optional)\n```python\nStream([1, 2, 3]).reduce(lambda acc, val: acc + val, identity=3).get()\n```\n\n- peek\n<br>(perform the provided operation on each element of the stream without consuming it)\n```python\n(Stream([1, 2, 3, 4])\n .filter(lambda x: x > 2)\n .peek(lambda x: print(f\"{x} \", end=\"\"))\n .map(lambda x: x * 20)\n .to_list())\n```\n\n- view\n<br>(provides access to a selected part of the stream)\n```python\nStream([1, 2, 3, 4, 5, 6, 7, 8, 9]).view(start=1, stop=-3, step=2).to_list()\n```\n```shell\n[2, 4, 6]\n```\n\n- distinct\n<br>(returns a stream with the distinct elements of the current one)\n```python\nStream([1, 1, 2, 2, 2, 3]).distinct().to_list()\n```\n\n- skip\n<br>(discards the first n elements of the stream and returns a new stream with the remaining ones)\n```python\nStream.iterate(0, lambda x: x + 1).skip(5).limit(5).to_list()\n```\n\n- limit / head\n<br>(returns a stream with the first n elements, or fewer if the underlying iterator ends sooner)\n```python\nStream([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]).limit(3).to_tuple()\nStream([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]).head(3).to_tuple()\n```\n\n- tail\n<br>(returns a stream with the last n elements, or fewer if the underlying iterator ends sooner)\n```python\nStream([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]).tail(3).to_tuple()\n```\n\n- take_while\n<br>(returns a stream that yields elements based on a predicate)\n```python\nStream.of(1, 2, 3, 4, 5, 6, 7, 2, 3).take_while(lambda x: x < 5).to_list()\n```\n```shell\n[1, 2, 3, 4]\n```\n\n- drop_while\n<br>(returns a stream that skips elements based on a predicate and yields the remaining ones)\n```python\nStream.of(1, 2, 3, 5, 6, 7, 2).drop_while(lambda x: x < 5).to_list()\n```\n```shell\n[5, 6, 7, 2]\n```\n\n- sorted\n<br>(sorts the elements of the current stream according to natural order or based on the given comparator;\n<br>if 'reverse' flag is True, the elements are sorted in descending order)\n```python\n(Stream.of((3, 30), (2, 30), (2, 20), (1, 20), (1, 10))\n .sorted(lambda x: (x[0], x[1]), reverse=True)\n .to_list())\n```\n```shell\n[(3, 30), (2, 30), (2, 20), (1, 20), (1, 10)]\n```\n--------------------------------------------\n### Terminal operations\n#### Collectors\n- collecting result into list, tuple, set\n```python\nStream([1, 2, 3]).to_list()\nStream([1, 2, 3]).to_tuple()\nStream([1, 2, 3]).to_set()\n```\n\n- into dict\n```python\nclass Foo:\n def __init__(self, name, num):\n self.name = name\n self.num = num\n \nStream([Foo(\"fizz\", 1), Foo(\"buzz\", 2)]).to_dict(lambda x: (x.name, x.num))\n```\n```shell\n{\"fizz\": 1, \"buzz\": 2}\n```\n\nIn the case of a collision (duplicate keys) the 'merger' functions indicates which entry should be kept\n```python\ncollection = [Foo(\"fizz\", 1), Foo(\"fizz\", 2), Foo(\"buzz\", 2)]\nStream(collection).to_dict(collector=lambda x: (x.name, x.num), merger=lambda old, new: old)\n```\n```shell\n{\"fizz\": 1, \"buzz\": 2}\n```\n\n- alternative for working with collectors is using the <i>collect</i> method\n```python\nStream([1, 2, 3]).collect(tuple)\nStream.of(1, 2, 3).collect(list)\nStream.of(1, 1, 2, 2, 2, 3).collect(set)\nStream.of(1, 2, 3, 4).collect(dict, lambda x: (str(x), x * 10))\n```\n\n- grouping\n```python\nStream(\"AAAABBBCCD\").group_by(collector=lambda key, grouper: (key, len(grouper)))\n```\n```shell\n{\"A\": 4, \"B\": 3, \"C\": 2, \"D\": 1}\n```\n\n```python\ncoll = [Foo(\"fizz\", 1), Foo(\"fizz\", 2), Foo(\"fizz\", 3), Foo(\"buzz\", 2), Foo(\"buzz\", 3), Foo(\"buzz\", 4), Foo(\"buzz\", 5)]\nStream(coll).group_by(\n classifier=lambda obj: obj.name,\n collector=lambda key, grouper: (key, [(obj.name, obj.num) for obj in list(grouper)]))\n```\n```shell\n{\n \"fizz\": [(\"fizz\", 1), (\"fizz\", 2), (\"fizz\", 3)],\n \"buzz\": [(\"buzz\", 2), (\"buzz\", 3), (\"buzz\", 4), (\"buzz\", 5)],\n}\n```\n#### Other terminal operations\n- for_each\n```python\nStream([1, 2, 3, 4]).for_each(lambda x: print(f\"{'#' * x} \", end=\"\"))\n```\n\n- count\n<br>(returns the count of elements in the stream)\n```python\nStream([1, 2, 3, 4]).filter(lambda x: x % 2 == 0).count()\n```\n\n- sum\n```python\nStream.of(1, 2, 3, 4).sum() \n```\n\n- find_first\n<br>(search for an element of the stream that satisfies a predicate,\nreturns an Optional with the first found value, if any, or None)\n```python\nStream.of(1, 2, 3, 4).filter(lambda x: x % 2 == 0).find_first().get()\n```\n\n- find_any\n<br>(search for an element of the stream that satisfies a predicate,\nreturns an Optional with some of the found values, if any, or None)\n```python\nStream.of(1, 2, 3, 4).filter(lambda x: x % 2 == 0).find_any().get()\n```\n\n- any_match\n<br>(returns whether any elements of the stream match the given predicate)\n```python\nStream.of(1, 2, 3, 4).any_match(lambda x: x > 2)\n```\n\n- all_match\n<br>(returns whether all elements of the stream match the given predicate)\n```python\nStream.of(1, 2, 3, 4).all_match(lambda x: x > 2)\n```\n\n- none_match\n<br>(returns whether no elements of the stream match the given predicate)\n```python\nStream.of(1, 2, 3, 4).none_match(lambda x: x < 0)\n```\n\n- min\n<br>(returns Optional with the minimum element of the stream)\n```python\nStream.of(2, 1, 3, 4).min().get()\n```\n\n- max\n<br>(returns Optional with the maximum element of the stream)\n```python\nStream.of(2, 1, 3, 4).max().get()\n```\n\n- compare_with\n<br>(compares linearly the contents of two streams based on a given comparator)\n```python\nfizz = Foo(\"fizz\", 1)\nbuzz = Foo(\"buzz\", 2)\nStream([buzz, fizz]).compare_with(Stream([fizz, buzz]), lambda x, y: x.num == y.num)\n```\n\n- quantify\n<br>(count how many of the elements are Truthy or evaluate to True based on a given predicate)\n```python\nStream([2, 3, 4, 5, 6]).quantify(predicate=lambda x: x % 2 == 0)\n```\n--------------------------------------------\n### Itertools integration\nInvoke <i>use</i> method by passing the itertools function and it's arguments as **kwargs\n```python\nimport itertools\nimport operator\n\nStream([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]).use(itertools.islice, start=3, stop=8)\nStream.of(1, 2, 3, 4, 5).use(itertools.accumulate, func=operator.mul).to_list()\nStream(range(3)).use(itertools.permutations, r=3).to_list()\n\n```\n#### Itertools 'recipes'\nInvoke the 'recipes' described [here](https://docs.python.org/3/library/itertools.html#itertools-recipes) as stream methods and pass required key-word arguments\n```python\nStream([1, 2, 3]).ncycles(count=2).to_list()\nStream.of(2, 3, 4).take_nth(10, default=66).get()\nStream([\"ABC\", \"D\", \"EF\"]).round_robin().to_list()\n```\n--------------------------------------------\n### Querying files with FileStream\n- working with <i>json</i>, <i>toml</i>, <i>yaml</i>, <i>xml</i> files\n```python\nFileStream(\"path/to/file\").map(lambda x: f\"{x.key}=>{x.value}\").to_tuple()\n```\n```shell\n(\n \"abc=>xyz\", \n \"qwerty=>42\",\n)\n```\n```python\nfrom operator import itemgetter\n\n(FileStream(\"path/to/file\")\n .filter(lambda x: \"a\" in x.key)\n .map(lambda x: (x.key, sum(x.value) * 10))\n .sorted(itemgetter(1), reverse=True)\n .map(lambda x: f\"{str(x[1])}::{x[0]}\")\n .to_list()) \n```\n```shell\n[\"230::xza\", \"110::abba\", \"30::a\"]\n```\nFileStream reads data as series of Item objects with key/value attributes.\n\n- querying <i>csv</i> and <i>tsv</i> files\n<br>(each row is read as a dict with keys taken from the header row)\n```python\nFileStream(\"path/to/file\").map(lambda x: f\"fizz: {x['fizz']}, buzz: {x['buzz']}\").to_tuple() \n```\n```shell\n(\n \"fizz: 42, buzz: 45\",\n \"fizz: aaa, buzz: bbb\",\n)\n```\n```python\nfrom operator import itemgetter\n\nFileStream(\"path/to/file\").map(itemgetter('fizz', 'buzz')).to_tuple()\n```\n```shell\n(('42', '45'), ('aaa', 'bbb'))\n```\n",
"bugtrack_url": null,
"license": null,
"summary": "Functional-style Streams library for processing collections and querying files (json, toml, yaml, xml, csv, tsv). Provides easy integration with itertools.",
"version": "1.1.1",
"project_urls": {
"Homepage": "https://github.com/kaliv0/pyrio",
"Repository": "https://github.com/kaliv0/pyrio"
},
"split_keywords": [
"stream",
" functional",
" processing",
" collections",
" fluent api"
],
"urls": [
{
"comment_text": "",
"digests": {
"blake2b_256": "deb2f47211eb511a025b2590c79e0b5670cb88125c414a961919c71d7ecbd27c",
"md5": "1e678c4ce60365d9c274db09035efbb4",
"sha256": "bf3372b43731653f79119f5d3946e66c91b62004b9e6b252e85954649ae72e3a"
},
"downloads": -1,
"filename": "pyrio-1.1.1-py3-none-any.whl",
"has_sig": false,
"md5_digest": "1e678c4ce60365d9c274db09035efbb4",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": "<4.0,>=3.12",
"size": 14440,
"upload_time": "2024-11-07T16:54:57",
"upload_time_iso_8601": "2024-11-07T16:54:57.296382Z",
"url": "https://files.pythonhosted.org/packages/de/b2/f47211eb511a025b2590c79e0b5670cb88125c414a961919c71d7ecbd27c/pyrio-1.1.1-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "b7150b47a505995d6beffa293a49054a234085bb65946f65862b9e318bfab5ed",
"md5": "bb0f09d6c3a3b037579072b2deec9e82",
"sha256": "84e94a19e418aaf97afb55e8ae71c3e83e4896bf625301725d24b4b0a8f85a32"
},
"downloads": -1,
"filename": "pyrio-1.1.1.tar.gz",
"has_sig": false,
"md5_digest": "bb0f09d6c3a3b037579072b2deec9e82",
"packagetype": "sdist",
"python_version": "source",
"requires_python": "<4.0,>=3.12",
"size": 14410,
"upload_time": "2024-11-07T16:54:59",
"upload_time_iso_8601": "2024-11-07T16:54:59.241440Z",
"url": "https://files.pythonhosted.org/packages/b7/15/0b47a505995d6beffa293a49054a234085bb65946f65862b9e318bfab5ed/pyrio-1.1.1.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2024-11-07 16:54:59",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "kaliv0",
"github_project": "pyrio",
"travis_ci": false,
"coveralls": false,
"github_actions": true,
"lcname": "pyrio"
}
JSON
