semvec/pypi-packages huggingface dataset:
paips 0.0.5
Run complex pipelines from terminal using configuration files
Requires Python: >=3.6

# Paips
Run complex Python pipelines from command line using configuration files.

### How it works
- First define tasks that you want to be executed. These tasks are written in Python and consist of classes inheriting from paips.core.Task. Tasks can receive parameters and data from other tasks, return data, and be interconnected.
- Then, write one or more configuration files, which will tell Paips which tasks to run, with which parameters and how they will be connected. Configuration files are written in yaml, are modular and can be easily composed and also modified from command line.
- Finally, run in command line:
```
paiprun <config_path>
```
and the tasks declared in the configuration file will be executed in the right order.

Now, hands on pipelining...

Installing paips is really easy, just run:

```
pip install paips
```

Now that paips is installed, take a look at the [Tutorial](docs/tutorial.md) to learn how to make your life easier when building those large and complex pipelines.
dienen 0.0.3
Train deep neural networks using configuration files
Requires Python: >=3.6

### Dienen
Build complex deep learning models using configuration files.

##### Installation
First of all you need to have tensorflow with gpu working in your system. You should be able to run nvidia-smi and get information about your GPUs.

Then, install using pip

```
pip install dienen
```

Now, that dienen is installed, it is time to train some models. Check out the [tutorial](docs/tutorial.md) and learn how to do it.
kahnfigh 0.0.4
Boosted dictionaries to make complex and nested configuration files easier
Requires Python: >=3.6

## Kahnfigh

Load a yaml file:

```
from kahnfigh import Config
config = Config('sample.yaml')
```

Access keys using xpath syntax:

```
config['Model/Architecture/Dense/units']
```

Edit existing values:
```
config['Model/Architecture/Dense/units'] = 128
```

If the path doesn't exist, it will automatically create it:
```
config['Model/Architecture/MyNewLayer/units'] = 88
```

Moreover, you might want to find all paths matching a pattern. Use a wildcard:
```
config['Model/Architecture/*/units']
```
If there was a list in config['Model/Architecture'], then it will return all the value of key 'units' of all elements of the list which have that key

You can also do some more elaborate but handy things like:
```
config['Model/Architecture/*/[units=88]/name']
```
This will return the value of key name of all elements of the list in Architecture which have the pair key:value units:88

Sometimes it is really hard to work with nested dictionaries. Use to_shallow() and turn it into a depth-1 dictionary:
```
shallow = config.to_shallow()
```

Then, after some modifications, you might want to go back to a nested dictionary:
```
from kahnfigh.core import shallow_to_deep

nested = shallow_to_deep(shallow)
```

Also, you may want to create custom behaviours. For example, if we want a value to be replaced by a variable when the symbol $ appears, we can do:
```
config['Model/name']
# this returns: $model_name
config['Model/Architecture/ConvLayer/filters']
# this returns: $n_filters

params = {'model_name': 'CNN-LSTM',
          'n_filters': 64}
config.replace_on_symbol('$',lambda x: params[x])

config['Model/name']
#this now returns: CNN-LSTM
config['Model/Architecture/ConvLayer/filters']

#this now returns: 64