semvec/pypi-packages huggingface dataset:
tracardi-graph-runner 0.6.13
Tracardi Graph Runner

[![header.jpg](https://raw.githubusercontent.com/atompie/tracardi/tracardi-unomi-master/screenshots/github-splash.png)](https://raw.githubusercontent.com/atompie/tracardi/tracardi-unomi-master/screenshots/github-splash.png)

# Tracardi Graph Runner Library

This library is part of TRACARDI Customer Data Platform. 

[Tracardi](http://github.com/atompie/tracardi)  is a open-source Customer Data Platform.

TRACARDI is an API-first solution, low-code / no-code platform aimed at any e-commerce business that 
wants to start using user data for marketing purposes. If you own a brand new e-commerce platform or 
a legacy system you can integrate TRACARDI easily. Use TRACARDI for:

 * **Customer Data Integration** - You can ingest, aggregate and store customer data
   from multiple sources in real time at any scale and speed due to elastic search backend.
   
 * **Customer Data Modelling** -  You can manage data. Define rules that will model data delivered
   from your page and copy it into user profile. You can segment customers into custom segments.
   
 * **User Experience Personalization** - You can personalize user experience with
   real-time customer segmentation and targeting.
   
 * **Profile Unification** - You can merge customer data from various sources to
   single profile. Auto de-duplicate customer records. Blend customers in one account.
   
 * **Automation** - TRACARDI is a great framework for creating
   marketing automation apps. You can send your data to other systems easily

# Main project

Visit [http://github.com/atompie/tracardi](http://github.com/atompie/tracardi) for main project. 

# License

Tracardi is available under MIT with Common Clause license.
pyspace-toolkit 1.1.25.294
pyspace is a tool set of data science python functions
Requires Python: >=3.6

# pyspace

## installation

```
git clone -b pyspace_resources https://github.com/sahinbatmaz/resources.git pyspace_resources
cd pyspace_resources
pip install .

pip install pyspace-toolkit
```

```
# UPGRADE
pip install pyspace-toolkit --no-deps --force-reinstall
```

## requirements

```
    'sklearn','pandas','numpy',
    'matplotlib','seaborn',
    'rasa>=1.10.3','tensorflow',
    'lightgbm','xgboost',
    'spacy>=2.3.0','spacymoji',
    'stanza','nlpcube',
    'fuzzywuzzy','jellyfish>=0.8.2','fuzzy_sequence_matcher','fastdtw',
    'tabulate','tqdm','jsonlines',
    'sklearn-hierarchical-classification','JPype1','MiniSom'
```

## text classification
```
from pyspace.data.analyse import get_cv_predictions
from pyspace.data.metrics import get_confusion_report

# train # pandas DataFrame # required columns : ['Text', 'Intent']
outdf_avg, y_prob_matrix_avg_df =  get_cv_predictions(train, mode='text', cv=5, model_repeat_count=3, n_jobs=5, verbose=11,)

# outdf_avg # required columns : ['Text', 'Intent', 'y_pred'], additional columns : ['y_prob', 'y_2nd_pred', ...] 
get_confusion_report(outdf_avg, excel_file_path='./dataset_analysis.xlsx', y_prob_matrix_df=None)
```

## text gcn
```
import pandas as pd
train = pd.read_csv('dataset.csv')
train.columns = ['text', 'label']

from sklearn.model_selection import StratifiedKFold
skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=0)
train_idx, test_idx = list(skf.split(list(train.index), train['label'].values))[4]

train['tot'] = None
train.at[train_idx, 'tot'] = 'train'
train.at[test_idx, 'tot'] = 'test'
```
```
from pyspace.nlp.models.text_gcn.text_gcn import TextGCN_TransductiveClassifier
from pyspace.nlp.models.text_gcn.fast_text_gcn_norank import FastTextGCN_InductiveClassifier

fasttextgcn = FastTextGCN_InductiveClassifier(verbose=1, )
fasttextgcn.train(train, validation_ratio=0.0, batch_size=256, epochs=80, learning_rate=0.01)

```


--- 

        
## future work

- maxpumperla/hyperas
- https://www.kaggle.com/baghern/a-deep-dive-into-sklearn-pipelines
- https://www.kaggle.com/graymant/pytorch-regression-with-sklearn-pipelines
- https://gist.github.com/MaxHalford/9bfaa8daf8b4bc17a7fb7ba58c880675
chkpt 0.1.0
A tiny pipeline builder
Requires Python: >=3.6, <4
Keywords: pipeline,data,prototyping

# chkpt
A <sub>tiny</sub> pipeline builder

## What

`chkpt` is a zero-dependency, 100-line library that makes it easy to define and execute checkpointed pipelines.

It features...

* Fluent pipeline construction
* Transparent caching of expensive operations
* JSON serialization

## How

### Defining a `Stage`

`Stage`s are the atomic units of work in `chkpt` and correspond to single Python functions. Existing functions need only use a decorator `@chkpt.Stage.wrap()` to be used as a `Stage`:

```python
@chkpt.Stage.wrap()
def stage1():
  return "123"

# stage1 is now a Stage instance
assert isinstance(stage1, chkpt.Stage)

# but the original function is still accessible
assert stage1.func() == "123"
```

`Stage`s can also accept parameters to be provided by other `Stage`s in the final `Pipeline`:

```python
@chkpt.Stage.wrap()
def stage2(stage1_input):
  return [stage1_input, "456"]
```

### Defining a `Pipeline`

`Pipeline`s define the excution graph of `Stage`s to be run. `Stage`s are combined with shift operators (`<<` and `>>`) to direct the dataflow:

```python
# Each defines a pipeline calculating `stage1` and passing its output to `stage2`.
pipeline = stage1 >> stage2
pipeline = stage2 << stage1
pipeline = stage2 << (stage1,)
pipeline = (stage1,) >> stage2
pipeline = () >> stage1 >> stage2 
```

More complex pipelines should be defined from the leaves down:

```python
result1 = (stage1, stage2) >> stage3
result2 = (result1, stage1) >> stage4
pipeline = result2 >> stage5
```

### Executing a `Pipeline`

`Pipeline`s can be directly executed which will use the default config settings:

```python
result = pipeline()
```

The defaults can be configured by passing a `Config` instance:

```python
# Will store all stage results and attempt to load already-stored results, if present.
result = pipeline(chkpt.Config(store=True, load=True, dir='/tmp'))
```

### Examples

For detailed usage, see the [examples/]() directory.

The following is a brief example pipeline:

```python
import chkpt


@chkpt.Stage.wrap()
def make_dataset1():
  ...

@chkpt.Stage.wrap()
def big_download2():
  ...

@chkpt.Stage.wrap()
def work_in_progress_analysis(dataset1, dataset2):
  ...

pipeline = (make_dataset1, big_download2) >> work_in_progress_analysis
# Work-intensive inputs only run once, caching on reruns.
result = pipeline(chkpt.Config(load=[make_dataset1, big_download2]))
```
distance-calculator-thackerdynasty 1.0
A Distance Calculator
Requires Python: >=3.6

# Distance Calculator
## Introduction
The distance calculator is a way to find the distance between two points!
## Usage
First, you will need to create two variables, `p1`, and `p2`.
Next, you will need to assign them to the point class, with the coordinates after that. It will look like this:
````python
#The coordinates shown here are just an example.
p1 = Point(4, 9)
p2 = Point(3, 4)
````
After you have done this,  you can calculate the distance by simply running `print(p1.distance(p2))
`.(Obviously you don't have to print it, you can save as variable.)
credmarkutils 0.0.1
Credmark Utils

# Credmark Utils
The purpose of this project is to create pythonic wrappers and tools for blockchain interaction.

## Installation
Run the following to install:
```python
pip install credmarkutils
```


## Usage
```python
from helloworld import say_hello

# Generate "Hello, World!"
say_hello()

# Generate "Hello, Everybody!"
say_hello("Everybody")
```

# Developing Credmark Utils
To install credmarkutils, along with the tools you need to develop and run tests, run the following in your virtualenv:

```bash
$ pip install -e .[dev]
```
curses-utils 0.0.13
Simple curses utilities
Requires Python: >=3.7

# CursesUtils
## Functions
`menu.menu(stdscr, title, options)`

Pulls up a select menu.

* `stdscr`:  The screen to write to.
* `title`:   The title of the menu.
* `options`: A collection of strings to choose from.

Returns the index of the selected item, or None if the user chooses to quit.

`number_select.number_select(stdscr, title, num_range, start = None)`

Pulls up a number selection menu.

* `stdscr`:    The screen to write to.
* `title`:     The title of the selection.
* `num_range`: A range object for valid numbers.
* `start`:     The starting selected number. Defaults to `num_range`'s min value.

Returns the number selected, or None if the user chooses to quit.

`keys.set_key_codes(key_name, key_codes)`

Sets a key's function by name.

* `key_name`:  The key name to set.
* `key_codes`: A collection of key codes (as returned by `stdscr.getkey()`) to use.

Make sure to set keys before using them!
Internally, CursesUtils uses the following keys:
* `menu_up` (for navigating UP through menus)
* `menu_down` (for navigating DOWN through menus)
* `menu_confirm` (for CONFIRMING on menus)
* `menu_cancel` (for QUITTING on menus)

`keys.get_key_codes(key_name)`

Gets a key's codes by name.

* `key_name`: The key name to get the codes of.

Returns the key codes of the given key, or None if it doesn't exist. See set_key_codes for more information.

`keys.get_next_key(stdscr)`

Gets the next key and saves it.

* `stdscr`: The screen to write to.

`keys.get_current_key()`

Gets the current pressed key.

`keys.get_key_with_timeout(stdscr, timeout)`

Waits for a timeout, returning immediately on a key. Saves the key, saving None if no key was pressed.

* `stdscr`:  The screen to write to.
* `timeout`: The timeout in milliseconds.

`keys.wait_for_key(stdscr)`

Waits for a key, but doesn't consume it.

* `stdscr`: The screen to write to.

`keys.is_pressed(key_name)`

Checks if the given key is the current pressed key by name.

* `key_name`: The key name to check.

`wrapper.wrapper(func)`

Wraps a function to set up and shut down, also wrapping using `curses.wrapper`.

* `func`: The function to wrap.