semvec/pypi-packages huggingface dataset:
eeve 1.7.0
A simple, flexible and powerfull event trigger
License: MIT

eeve
====

.. image:: https://img.shields.io/pypi/v/eeve.svg
    :target: https://pypi.python.org/pypi/eeve
    :alt: Latest PyPI version

.. image::  https://travis-ci.org/vMarcelino/eeve.svg?branch=master
   :target:  https://travis-ci.org/vMarcelino/eeve
   :alt: Latest Travis CI build status

A simple, flexible and powerfull event trigger

Usage
-----
``python -m eeve``

Or from the project folder:

``python run.py``

Default GUI Usage
-----------------
The program flow is split in 3 main components:
Actions, triggers and events. 

**Actions** are the execution, they can vary from opening an app to 
sending a keystroke to the OS. They are *what* happens. 

**Triggers** make events happen. They usually run in background 
and activate events. They are *when* it happens. 

**Events** are the glue between triggers and actions. 
It can contain many triggers and many actions. When
an event is activated, it runs its actions in sequence. 
You can add many triggers to an event and every time one of the
added triggers fires, the event is activated and will run all its actions in order. 


Actions and triggers can also accept arguments, which documentation 
can be accessed using the (?) button on the editing page. The 
documentation is up to the trigger or action's developer to write.
However, eeve also shows what arguments the action or trigger accepts
by analyzing the code. 

**Variables** can also be used in actions. They can be from one of the three types:
*local variables*, that live while the event is running and are deleted as soon as the
last action is run. They can be accessed only by the actions inside that single run.
You can access them in a argument by a single $. 
Eg: $count

*event variables* (AKA task variables), that are accessible from any action from the event and are deleted when
eeve stops running or the event is deleted. You can access them by using two $
Eg: $$count

*global variables*, that are accessible by any action running, regardless of the 
event. They are deleted when eeve stops running. You can access them by using three $
Eg: $$$count


Installation
------------
From pip:

``pip install -U eeve``

From source:

``pip install -e .`` or ``python setup.py install``

Requirements
^^^^^^^^^^^^

Compatibility
-------------

Only tested on windows x64, but should work on any other OS just fine. Actions and triggers, however, have their own compatibility


Licence
-------
MIT Licence

Authors
-------

`eeve` was written by `Victor Marcelino <victor.fmarcelino@gmail.com>`_.
jque 0.1.3
Query JSON in memory as though it were a Mongo database.
License: MIT
Requires Python: >=3.6.0

<h2 align=center>j q u e</h2>
<p align=center>Query JSON in memory as though it were a Mongo database</p>
<p align=center><a href="https://pypi.org/project/jque/"><img src="https://img.shields.io/pypi/v/jque.svg" /></a> <a href="https://circleci.com/gh/j6k4m8/jque"><img src="https://img.shields.io/circleci/project/github/RedSparr0w/node-csgo-parser.svg" /></a> <img src="https://img.shields.io/badge/extremely_rad-%F0%9F%A4%99-blue.svg" /> <img src="https://img.shields.io/github/license/j6k4m8/jque.svg" /><a href="https://codecov.io/gh/j6k4m8/jque">
  <img src="https://codecov.io/gh/j6k4m8/jque/branch/master/graph/badge.svg" />
</a></p>

## Installation

```shell
pip3 install jque
```

## Usage

```python
import jque
```

`jque` accepts a variety of inputs to the constructor.

Pass a list of dicts:
```python
data = jque.jque([
    { "name": "john" }, 
    { "name": "paul" }, 
    { "name": "george" }, 
    { "name": "ringo" }
])
```

Pass a JSON filename:
```python
DATAFILE = "~/my/big/data.json"
data = jque.jque(DATAFILE)
```

Now you can query this dataset using Mongo-like syntax:

```python
>>> data.query({ "name": {"$neq": "paul"} })
[
    { "name": "john" },
    { "name": "george" }, 
    { "name": "ringo" }
]
```

### Arguments to `query`:

| Arg | Description |
|-----|-------------|
| `wrap` (`boolean` : `True`) | Whether to wrap the resultant dataset in a new `jque` object. This allows chaining, like `jque.query(...).query(...)`, if you're the sort of person to do that. Pass `False` to get back a `list` instead. |


### Another example!

```python
data = jque.jque([{
    "_id": "ABC",
    "name": "Arthur Dent",
    "age": 42,
    "current_planet": "earth"
}, {
    "_id": "DE2",
    "name": "Penny Lane",
    "age": 19,
    "current_planet": "earth"
}, {
    "_id": "123",
    "name": "Ford Prefect",
    "age": 240,
    "current_planet": "Brontitall"
}])
```

```python
teenage_earthlings = data.query({
    "current_planet": {"$eq": "earth"},
    "age": { "$lte": 20, "$gte": 10 }
})
```

Which returns:

```python
[{
    "_id": "DE2",
    "name": "Penny Lane",
    "age": 19,
    "current_planet": "earth"
}]
```


Use Python lambdas as a filter:

```python
>>> libraries = jque.jque([
...     {"name": "jque", "language": "Python"}, 
...     {"name": "react", "language": "node"}
... ])
>>> list(libraries.query({
...     'language': lambda x: x[:2] == "Py"
... }))
[{"name": "jque", "language": "Python"}]
```
jmr 1.0.0
JSON Mapper
License: MIT

# jmr

![PyPI](https://img.shields.io/pypi/v/jmr.svg?style=flat-square)
![GitHub](https://img.shields.io/github/license/mashape/apistatus.svg?style=flat-square)

`jmr` is mappable JSON object.

## Installation

Using pip

```
$ pip install git+https://github.com/hinatades/jmr.git
```

or using pip with PyPI: https://pypi.python.org/pypi/jmr

```
$ pip install jmr
```

## Usage

```python
import jmr

json_data = {}
jmr = JSONMapper(json_data)
```

## Example

### map json keys with CSV

```python
new_input_data = jmr.map_keys_with_csv(
    'MAPPING_CSV_PATH',
    'MAPPING_PKL_PATH',
    [1, 0]
)
```

## Author

@hinatades (<hnttisk@gmail.com>)