semvec/pypi-packages huggingface dataset:
DataExtruder 0.1.3
Render data from diffrent data-sources and jinaj2 template
License: MIT
Keywords: jinja2,directus

# About
The idea behind this project is, that you often have some centralizes systems containing your data. From these you want to generate several kind of content. This content could be html, markdown, terraform code or a lot more. 
Exaclty this is done by the utility. It takes a data-source and transforms it into content.  
The transformation/rendering is done by [cookiecutter](https://github.com/cookiecutter/cookiecutter) which offers jinja2 templating for more complex projects. 
The data can be loaded from several source.   
  
Currently supported:
- [Directus](https://github.com/directus/directus)
  
In planning:
- Google Sheets

> Please note: [python-sdk](https://github.com/vvatelot/directus-sdk-python) is included directly, as no pip package is available during creation. Full credtis are going to the creator for this part!  
  
# Usage
Create a json file with the required information included.
Call the CLI as follow: ```app.py --template git+https://foo.bar```  
## Installation
Run `pip install DataExtruder`

## Paramters
| Paramter        | Default           | Description  |
| ------------- | ------------- | ----- |
| --config      | config.josn | The config file used |
| --template      | NONE | The template folder or url used |
| --target      | target | The output directory |
| --log-level      | INFO | The log level |

# Modules
## Directus
Example

``` 
{   
    "source_type": "directus",
    "url": "http://localhost:8080",
    "username": "email@example.com",
    "password": "yourpasswordHere",
    "model": [
        {
            "name": "users",
            "collection": "employee",
            "fields": [
                "*"
            ]
        }
}
```

Some variables can be overwritten by Environment variables.  
`username` - `DATAEXTRUDER_DIRECTUS_USERNAME`  
`password` - `DATAEXTRUDER_DIRECTUS_PASSWORD`
python-duplicate 1.0.4
Handle duplicate in python
License: MIT

[![Build Status](https://travis-ci.com/Clement-O/python-duplicate.svg?branch=master)](https://travis-ci.com/Clement-O/python-duplicate) 
[![Coverage Status](https://coveralls.io/repos/github/Clement-O/python-duplicate/badge.svg?branch=master)](https://coveralls.io/github/Clement-O/python-duplicate?branch=master)
[![Documentation Status](https://readthedocs.org/projects/python-duplicate/badge/?version=latest)](https://python-duplicate.readthedocs.io/en/latest/?badge=latest)

The python-duplicate library intend to find and deal with duplicate.
Depending on what you need, it can:
- Find and return the unique or duplicate items* of a list
- Create a new list of unique items* from a list
- Find and return the indexes of said items* (act as a feedback)
- Find the rows (or just PK) of unique or duplicate column for MySQL 8 and PosgreSQL 10

*items can be a list, tuple, dict, number or string

## Upcoming improvements
In the future I intend to add support for:
- JSON
- Other type of item for list (Object class for example)
- Handle suppression of duplicate for MySQL and PostgreSQL
- Handle research of unique / duplicate on more than one table / column / pk
- Support more version of MySQL and Postgres
- Support more database type
layer-loader 0.0.1
Easy composition of configuration files
License: MIT

# Layer-Loader

[![CircleCI](https://circleci.com/gh/PeterJCLaw/layer-loader.svg?style=svg)](https://circleci.com/gh/PeterJCLaw/layer-loader)

Layer-loader is a Python library designed to allow easy composition of configuration files.

This project was inspired by [hiera][puppet-hiera], though intends to be somewhat simpler.

[puppet-hiera]: https://puppet.com/docs/puppet/latest/hiera_intro.html

## Usage

The primary interface is a Python API:

``` python
import json
import layer_loader

data = layer_loader.load_files(
    ['dev.json', 'main.json'],
    loader=json.load,
)
```

This will load the data from `dev.json` and `main.json`, interpreting it as JSON,
combine it into a single object and then any placeholders are expanded.

For convenience you can also run `layer_loader` as a module:

```shell
$ cat dev.json
{
    "url": "http://localhost:8000"
}
$ cat main.json
{
    "endpoints": [
        "{url}/abc",
        "{url}/def",
        "{url}/ghi"
    ],
    "url": "https://production.system"
}
$ python -m layer_loader --loader=json.load dev.json main.json
{
    "endpoints": [
        "http://localhost:8000/abc",
        "http://localhost:8000/def",
        "http://localhost:8000/ghi"
    ],
    "url": "http://localhost:8000"
}
```

## Layers

Layers are specified in order from most important (top) to least important (bottom).
When combining layers, layer-loader uses the following rules:

* Mappings can be _merged_, combining the entries from several layers
* Scalar values and lists _replace_ entries in the lower layers
* Keys in more important layers override those in lower layers
* Where keys are present in multiple layers, it is an error for those
  keys to have values of different types. The exception to this is
  that keys can explicitly be set to `null` in a higher layer in order
  to remove a value set in a lower layer.

## Placeholders

Placeholders are specified similarly to python format strings and may appear
anywhere inside a string value, for example `'foo {place.holder} bar'`.
Placeholders should not appear in keys -- they will not be found there.

Placeholders are expanded by walking the flattened data structure, using dots in
the placeholder to separate names at each level of nesting.

There is no mechanism to specify which layer a placeholder should be looked up
within -- all placeholder expansion happens after the layers have been
flattened.