Skip to main content

No project description provided

Project description

[![Build Status](https://travis-ci.com/andrea-lascola/Pytoolz.svg?branch=master)](https://travis-ci.com/andrea-lascola/Pytoolz)
[![PyPI version](https://badge.fury.io/py/pytoolz.svg)](https://badge.fury.io/py/pytoolz)
[![CII Best Practices](https://bestpractices.coreinfrastructure.org/projects/2441/badge)](https://bestpractices.coreinfrastructure.org/projects/2441)

# Pytoolz ๐Ÿš€

Module containing some python utilities/abstractions
python >= 3.7 compatible

## Prerequisites
python >= 3.7

## Installing
pip install pytoolz

## Sections

* [Functional](#functional) ฮป
* [Data Structures](#data-structures) ๐Ÿ“‚
* [Cache](#cache) ๐Ÿš€
* [Design](#design) ๐Ÿ›
* [Logs](#logs) ๐Ÿ“–
* [Multiprocess](#multiprocess) ๐Ÿ‘ฏ
* [Serialization](#serialization) ๐Ÿค–

#### Functional

A set of utilities oriented to functional programming.

##### compose(f1: Callable, f2: Callable) -> Callable
Compose two functions: return the fn composition of the two

```python
from pytoolz.functional import compose

if __name__ == "__main__":
f = compose(lambda x: x * 2,
lambda x: x * 3)
f(10)
# 60
```

##### pipe(functions: List[Callable], obj)
Recursively apply a list of morphism to an input value

```python
from pytoolz.functional import pipe

if __name__ == "__main__":
pipe([lambda x: x * 3,
lambda x: x * 2,
lambda x: x / 3], 10)
# 20.0
```

##### flat_map(fn: Callable, collection: Iterable)
Apply the input function to every element in iterable and flatten the result list
s
```python
from pytoolz.functional import flat_map

if __name__ == "__main__":
flat_map(lambda x: [x, x], [1, 2, 3])
# [1, 1, 2, 2, 3, 3]
flat_map(lambda x: (x, x), [1, 2, 3])
# [1, 1, 2, 2, 3, 3]
```

##### iflat_map(fn: Callable, collection: Iterable)
Apply the input function to every element in iterable and flatten the result list **lazily**

```python
from pytoolz.functional import iflat_map

if __name__ == "__main__":
iflat_map(lambda x: [x, x], [1, 2, 3])
# [1, 1, 2, 2, 3, 3]
iflat_map(lambda x: (x, x), [1, 2, 3])
# [1, 1, 2, 2, 3, 3]
```


##### for_each(fn: Callable, collection: Iterable)
Create side effect applying the input function for every element in iterable

```python
from pytoolz.functional import iflat_map

if __name__ == "__main__":
iflat_map(lambda x: [x, x], [1, 2, 3])
# [1, 1, 2, 2, 3, 3]
iflat_map(lambda x: (x, x), [1, 2, 3])
# [1, 1, 2, 2, 3, 3]
```



##### Stream(iterable: Iterable) -> Stream
[Experiment] Emulate the Java Stream API to create pipelines of transformations unsing function composition

```python
from pytoolz.functional import Stream

if __name__ == "__main__":
Stream([1, 2, 3]).map(lambda x: x * 3).to_list()
# [3, 6, 9]
Stream([1, 2, 3]).sum().to_int()
# 6
Stream([1, 2, 3]).map(lambda x: x * 3).filter(lambda x: x >= 6).to_tuple()
# (6, 9)
Stream(["a", "b", "c"]).map(lambda x: x + "a").to_set() == {'aa', 'ba', 'ca'}
# True
Stream([1, 4, 3]) \
.map(lambda x: x + 3) \
.map(lambda x: x * x) \
.filter(lambda x: x > 3) \
.sum() \
.to_float()
# 101.0

#Alternative constructor
Stream.of([1, 2, 3], [
(Stream.map, lambda x: x * 3),
(Stream.map, lambda x: x * 3)
]).to_list()
# [9, 18, 27]
```

#### Serialization

Serialization and deSerialization of objects:
different engine are built-in: Json/Pickle/Dict

```python
from pytoolz.serialization import Dict, Json, Pickle

if __name__ == "__main__":
original = '{"users": ["bob", "foo", "bar"], "companies": {}}'

data = Json(original).deserialize()
print(type(data))
# '<class 'dict'>'

string_data = Json(data).serialize()
print(type(string_data))
# '<class 'str'>'
```

#### Data structures
Utilities related to data structures (missing data structures or customization of existing ones)

##### LinkedList

```python
from pytooolz.ds import LinkedList, Node

if __name__ == "__main__":
ll = LinkedList()
ll.add(Node(3))
ll.add(Node(4))
ll.add(Node(5))
ll.add(Node(6))
print(ll)
#$ LinkedList(head=Node(value=6, next=Node(value=5, next=Node(value=4, next=Node(value=3, next=None)))))
```

##### DoublyLinkedList

TODO complete

#### Cache
Utilities related to **caching**. Different backend will be implemented:
ex:
* Redis
* Memcache
* LRU in-memory
* Filesystem

```python
from pytooolz.cache import memoize # memoize decorator
from pytooolz.cache import FileEngine # Disk cache engine
from pytooolz.cache import InMemoryEngine # LRU in memory engine
from pytooolz.cache import MemcachedEngine # Memcache engine
from pytooolz.cache import RedisEngine # Redis engine

if __name__ == "__main__":
@memoize(InMemoryEngine(limit=10, expiration=10))
def fn(*args):
return args


fn(1, 2, 3, 4, 5) # fn evaluated
fn(1, 2, 3, 4, 5) # got from cache
fn(1, 2, 3, 4, 5) # got from cache
fn(1, 2, 3, 4, 5) # got from cache
```


#### Design
Utilities related to application design
**Singleton decorator** - Examples:
```python
from pytooolz.design import singleton

if __name__ == "__main__":
@singleton.singleton
class MyClass:
pass

assert id(MyClass()) == id(MyClass())
```

**Traits**
Attach a specific trait to an instance.
This should enable polimorphism using composition instead of classic inheritance

To use this feature:
* decorate your class with ```@extendable``` decorator
* implement your custom class that implements ```Trait``` interface
* choose one (or more) traits during the class init using ```.with_trait(...)```

Example:
```python
from pytooolz.design import Trait
from pytooolz.design import extendable

if __name__ == "__main__":
class UserRenderHtml(Trait):
def render(self):
print("""
<h1>{0!s}</h1>
<p>{1!s}</p>
""".format(self.name, self.surname))


class UserRenderText(Trait):
def render(self):
print(self.name, self.surname)


@extendable
class User:
def __init__(self, name, surname):
self.name = name
self.surname = surname

usr = User("Andrea", "La Scola").with_trait(UserRenderHtml)
print(usr.render())
```

#### Logs
**log decorators**
- multiple backends


## Authors

* **Andrea La Scola** - *Initial work* - [PurpleBooth](https://github.com/andrea-lascola)

Project details


Download files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

Files for pytoolz, version 0.1.7
Filename, size File type Python version Upload date Hashes
Filename, size pytoolz-0.1.7.tar.gz (11.4 kB) File type Source Python version None Upload date Hashes View hashes

Supported by

Elastic Elastic Search Pingdom Pingdom Monitoring Google Google BigQuery Sentry Sentry Error logging AWS AWS Cloud computing DataDog DataDog Monitoring Fastly Fastly CDN SignalFx SignalFx Supporter DigiCert DigiCert EV certificate StatusPage StatusPage Status page