semvec/pypi-packages huggingface dataset:
hollow 0.0.1
Container for finding Python objects using database-like indexes.
License: MIT
Requires Python: >=3.7,<4.0

[![tests Actions Status](https://github.com/manimino/dbox/workflows/tests/badge.svg)](https://github.com/manimino/dbox/actions)
[![Coverage - 100%](https://img.shields.io/static/v1?label=Coverage&message=100%&color=2ea44f)](test/cov.txt)
[![license - MIT](https://img.shields.io/static/v1?label=license&message=MIT&color=2ea44f)](/LICENSE)
![python - 3.7+](https://img.shields.io/static/v1?label=python&message=3.7%2B&color=2ea44f)

# Hollow

Python container for looking up objects using database-like indexes.

DBox is more powerful than most containers, but is much simpler than a database.

Install: `pip install dbox`

Usage:
```
from dbox import DBox
d = DBox(objects, ['x', 'y'])  # create DBox containing objects, indexed on x and y
d[{
    'x': {'>': 5, '<': 10},     # find objects with x between 5 and 10
    'y': {'in': [1, 2, 3]}      # where y is 1, 2, or 3
}]
```

Valid operators are ==, !=, <, <=, >, >=, in, not in. 

#### Is DBox a database?

No. But like a database, DBox builds B-tree indexes and uses them to find results very quickly. It does
not any do other database things like SQL, tables, etc. This keeps DBox simple, light, and performant.

#### Is DBox fast?

Yes. Here's how DBox compares to other object-finders on an example task.

![]()

The closest thing to a DBox is an in-memory SQLite. While SQLite is a fantastic database, it requires much
more overhead. As such, DBox is generally faster.

### Example

Find a good day for flying a kite. It needs to have sunny skies and a wind speed between 5 and 10.

```
from dbox import DBox

days = [
    {'day': 'Saturday', 'sky': 'sunny', 'wind_speed': 1},
    {'day': 'Sunday', 'sky': 'rainy', 'wind_speed': 3},
    {'day': 'Monday', 'sky': 'sunny', 'wind_speed': 7},
    {'day': 'Tuesday', 'sky': 'rainy', 'wind_speed': 9},
    {'day': 'Wednesday', 'sky': 'sunny', 'wind_speed': 25}
]

d = DBox(                     # make a DBox
    days,                     # add objects of any Python type
    on=['sky', 'wind_speed']  # what to index on
)

dbox[{
    'sky': 'sunny', 
    'wind_speed': {'>': 5, '<': 10}
}]
# result: [{'day': 'Monday', 'sky': 'sunny', 'wind_speed': 7}]
```

`{'sky': 'sunny'}` is a shorthand for `{'sky': {'==': sunny}}`.

### Class APIs

There are three containers.
 - [DBox](https://dbox.readthedocs.io/en/latest/dbox.mutable.html#dbox.mutable.main.DBox): 
Can add / remove items after creation.
 - [ConcurrentDBox](https://dbox.readthedocs.io/en/latest/dbox.concurrent.html#dbox.concurrent.main.ConcurrentDBox): 
Same as DBox, but thread-safe.
 - [FrozenDBox](https://dbox.readthedocs.io/en/latest/dbox.frozen.html#dbox.frozen.main.FrozenDBox):
Cannot add / remove items after creation, it's read-only. But it's super fast, and of course thread-safe.

All three can be pickled using the special functions `dbox.save()` / `dbox.load()`. 

### Part 2

[Readme Part 2](/README_part_2.md) has lots more examples, including handling of nested data and missing attributes.
modupipe 1.0.2
A modular and extensible ETL-like pipeline builder
License: MIT
Requires Python: >=3.9,<4.0
Keywords: pipeline,etl,pipe

[![Build](https://github.com/vigenere23/modupipe/actions/workflows/build.yml/badge.svg)](https://github.com/vigenere23/modupipe/actions/workflows/build.yml)

# ModuPipe : A modular and extensible ETL-like pipeline builder

## Benefits

- Entirely typed
- Abstract, so it fits any use case
- Class-based for easy configurations and injections

## Usage

Extract-Transform-Load (ETL) pipelines are a classic form of data-processing pipelines used in the industry. It consists of 3 main elements:

1. An **`Extractor`**, which returns data in a stream-like structure (`Iterator` in Python) using a pull strategy.
2. Some **`Mapper`** (optional), which transforms (parse, converts, filters, etc.) the data obtained from the source(s). Mappers can be chained together and chained to an extractor (with `+`) in order to form a new extractor.
3. A **`Loader`**, which receives the maybe-transformed data using a push strategy. Loaders can be multiple (with `LoaderList`) or chained together (with `+`).

Therefore, those 3 processes are offered as interfaces, easily chainable and interchangeable at any time.

An interface `Runnable` is also offered in order to interface the concept of "running a pipeline". This enables a powerfull composition pattern for wrapping the execution behaviour of runnables.

## Examples

Usage examples are present in the [examples](./examples) folder.

## Discussion

### Optimizing pushing to multiple loaders

If you have multiple loaders (using the `LoaderList` class or many chained `PushTo` mappers), but performance is a must, then you should use a multi-processing approach (with `modupipe.runnable.MultiProcess`), and push to 1 queue per loader. Each queue will also become a direct extractor for each loader, all running in parallel. This is especially usefull when at least one of the loaders takes a long processing time.

As an example, let's take a `Loader 1` which is very slow, and a `Loader 2` which is normally fast. You'll be going from :

```
┌────── single pipeline ──────┐        ┌──────────────── single pipeline ───────────────┐
 Extractor ┬─⏵ Loader 1 (slow)    OR    Extractor ──⏵ Loader 1 (slow) ──⏵ Loader 2 (late)
           └─⏵ Loader 2 (late)
```

to :

```
┌────── pipeline 1 ──────┐               ┌────────── pipeline 2 ─────────┐
 Extractor ┬─⏵ PutToQueue ──⏵ Queue 1 ⏴── GetFromQueue ──⏵ Loader 1 (slow)
           └─⏵ PutToQueue ──⏵ Queue 2 ⏴── GetFromQueue ──⏵ Loader 2 (not late)
                                         └──────────── pipeline 3 ───────────┘
```

This will of course not accelerate the `Loader 1` processing time, but all the other loaders performances will be greatly improved by not waiting for each other.
ipygee 0.0.18
A set of tools for working with Google Earth Engine Python API in Jupyter notebooks
License: MIT
Keywords: google earth engine raster image processing gis satelite jupyter notebook ipython

# IpyGEE

A set of tools and Widgets for working with **Google Earth Engine** in Jupyter notebooks and Jupyter Lab

## Install

> pip install ipygee

*Note: Installation **does not** install Earth Engine Python API. You have to install it before installing `ipygee`, see: https://developers.google.com/earth-engine/python_install*

Be sure notebook extensions are enabled

ipywidgets:
> jupyter nbextension enable --py widgetsnbextension

ipyleaflet:
> jupyter nbextension enable --py --sys-prefix ipyleaflet

## Main Widgets

### - Map

``` python
from ipygee import *
Map = Map()
Map.show()
```

### - AssetManager
``` python
from ipygee import *
AM = AssetManager()
AM
```

### - TaskManager
``` python
from ipygee import *
TM = TaskManager()
TM
```

See examples in [here](https://github.com/fitoprincipe/ipygee/tree/master/examples)