Metadata-Version: 2.1
Name: live-cells-py
Version: 0.1.4
Summary: A reactive programming library for Python ported from Live Cells for Dart
Home-page: https://github.com/alex-gutev/live_cells_py
Author: Alexander Gutev
Author-email: alex.gutev@gmail.com
Classifier: Programming Language :: Python :: 3
Classifier: License :: OSI Approved :: BSD License
Classifier: Operating System :: OS Independent
Requires-Python: >=3.6
Description-Content-Type: text/markdown
License-File: LICENSE

# Live Cells Python

**This software is still in beta, and will likely experience rapid
changes before the first official release.**

Live Cells Python is a reactive programming library for Python, ported
from [Live Cells](https://livecells.viditrack.com/) for Dart.

## Installation

Run the following command to install Live Cells Python:

```sh
pip install live-cells-py
```

## Examples

**This section contains examples demonstrating the main features of
the library. Head to the
[documentation](https://alex-gutev.github.io/live_cells_py/index.html),
for more information on how to use this library.**

The basic building block of Live Cells is the cell, which is an object
with a value and a set of observers, which react to changes in the
value.

Cells are defined as follows:

```python
import live_cells as lc

a = lc.mutable(0)
a = lc.mutable(0)
```

And are observed as follows:

```python
lc.watch(lambda: print(f'{a()}, {b()}'))
```

The *watch function* defined above prints the values of the cells `a`
and `b` to standard output. It is called whenever the value of `a` or
`b` changes.

For example the following code, which sets the values of `a` and `b`:

```python
a.value = 1
b.value = 2
a.value = 3
```

Results in the following being printed to standard output:

```
1, 0
1, 2
3, 2
```

Watch functions comprising multiple statements can be defined using
the decorator of `watch`:

```python
@lc.watch
def watcher():
    print(f'A = {a()}')
    print(f'B = {b()}')
```

Cells can also be defined as a function of the values of one or more
cells. For example the following cell is defined as the sum of cells
`a` and `b`:

```python
c = lc.computed(lambda: a() + b())
```

The value of cell `c` is recomputed automatically whenever the value
of either `a` or `b` changes.

This cell can also be defined more succinctly as an expression of cells:

```python
c = a + b
```

That looks exactly like a normal variable definition.

This can be used to run a routine automatically whenever a certain
condition is met. For example, let's print a message to standard
output whenever the sum exceeds 100:

```python
@lc.watch
def watch_sum():
    if c() > 100:
        print('Sum exceeds 100!!!')
```

When the following is executed:

```python
a.value = 90
b.value = 30
```

The following message is printed to standard output automatically:

```
Sum exceeds 100!!!
```
