semvec/pypi-packages huggingface dataset:
ravenml 1.2
ML Training CLI Tool
License: MIT
Keywords: machine learning,data science

<!-- [![Build Status](https://travis-ci.com/autognc/ravenML.svg?branch=master)](https://travis-ci.com/autognc/ravenML) -->

# ravenML
CLI tool for machine learning model training.

## Installation 

### PyPI
Install from pip via:
```bash
pip install ravenml
```

### Conda Installation (development)
Create the conda environment from the `environment.yml` file using:
```bash
conda env create -f environment.yml
```

Activate the conda environment with:
```bash
conda activate ravenml      # may require source activate ravenml depending on system setup
```

Install ravenML from the root of this repository using:
```bash
pip install --editable .
```

## Configuration
ravenML must be configured with the name of the S3 buckets you wish to pull [Jigsaw](https://github.com/autognc/jigsaw)-created
datasets from and upload trained models to.

After installation, set this configuration by running:
```bash
ravenml config update
```

You can check your configuration anytime by running `ravenml config show`, and update it anytime with `ravenml config update`.

### Training Plugins
ravenML provides core functionality while unique model training pipelines are implemented
via plugins dynamically loaded at runtime. A default set of plugins is located at
[ravenML-plugins](https://github.com/autognc/ravenML-plugins). See the README there
for more information about how plugins work and how to make your own.

To install all default plugins for use with ravenML you just need to clone the repository
and run a script.

Clone the respository with:
```bash
git clone https://github.com/autognc/ravenML-plugins
```

Install default plugins by navigating to the downloaded `ravenML` directory and using:
```bash
./install_all.sh
```

To test your installation run `ravenml train list` and verify that the training plugin names appear on your console.

## Contributing

### Commitizen
We will use commitizen for all commit messages. The repository is set up to use
commitizen via the `.czrc` file. If you have commitizen already installed globally,
you can use it to commit for this repository.  

If you do not have commitizen installed, follow the instructions on their 
[GitHub](https://github.com/commitizen/cz-cli).  

If you do not have npm installed, you will need to do that before installing commitizen.
npm is distributed with Node.js. Install Node.js [here](https://nodejs.org/en/download/).
pycasbin-redis-watcher 0.1.0
Redis watcher adapter for pycasbin
License: MIT
Requires Python: >3.5
Keywords: pycasbin,casbin,flask,rbac

# pycasbin redis watcher

Casbin role watcher to be used for monitoring updates to casbin policies

### Installation
```
pip install pycasbin-redis-watcher
```

### Basic Usage
Example used along with https://github.com/ScienceLogic/pycasbin/flask-authz
```
from flask_authz import CasbinEnforcer
from casbin_redis_watcher import RedisWatcher
casbin_enforcer = CasbinEnforcer(app, adapter)
watcher=RedisWatcher(redis_hostname, redis_port)
watcher.set_update_callback(casbin_enforcer.e.load_policy)
casbin_enforcer.set_watcher(watcher)

```

### Using alongside UWSGI 
This redis-watcher module starts separate processes which subscribe to a redis channel, and listens for updates to the casbin policy on that channel. When running within WSGI contexts (like uwsgi) you may want to start these processes as a postfork action. As is depicted below:
```
try:
    from uwsgidecorators import postfork
    print("Running in uwsgi context")
except ModuleNotFoundError:
    print("Not running in uwsgi context")
    postfork = None

if postfork:
    @postfork
    def load_watcher():
        global casbin_enforcer
        watcher = RedisWatcher(redis_info.hostname, redis_info.port)
        watcher.set_update_callback(casbin_enforcer.e.load_policy)
        casbin_enforcer.set_watcher(watcher)

```
vimspeed 1.2.0
Debug vim starting speed
License: MIT

# vimspeed: helping people with vim speed issues
A lot of people new to vim/neovim will install tons of plugins slowing
down their startup speed considerably.

This small python script displays debug logs for vim/neovim to allow
people to easily detect what plugins are contributing significantly
to vim's startup time.

## Using Vim Speed
At first you should just try running vimspeed and let the python script
figure out the possible settings. However, if that doesn't work for you
here are a few options that you can use:
- pass in which editor to use (neovim/vim):
    ` vimspeed -e nvim `
- pass in the plugin directory:
    ` vimspeed -d ~/.config/nvim/plugged `
- pass in a specific file type to debug:
    ` vimspeed -f test.c `
- pass in number of readings default is 1:
    ` vimspeed -n 100 `
dogebuild-c 0.1.1
C language dogebuild plugin
License: MIT
Keywords: dogebuild builder

# dogebuild-c

[![Build Status](https://travis-ci.com/dogebuild/dogebuild-c.svg?branch=master)](https://travis-ci.com/dogebuild/dogebuild-c)
[![PyPI version](https://badge.fury.io/py/dogebuild-c.svg)](https://badge.fury.io/py/dogebuild-c)
[![Documentation Status](https://readthedocs.org/projects/dogebuild-c/badge/?version=latest)](https://dogebuild-c.readthedocs.io/en/latest/?badge=latest)


C language plugin for dogebuild

## Install dogebuild c plugin

Install dogebuild c plugin via pip:

```shell script
pip install dogebuild-c
``` 

Dogebuild will be installed as a dependency.

## Creating project with tapas

The easiest way to create project is to use [tapas scaffold tool](https://github.com/tapas-scaffold-tool/tapas).
To install tapas use pip:

```shell script
pip install tapas
```

And then run tapas and follow instructions:

```shell script
tapas dogebuild-c <target-dir>
```

## Manually creating project

Create `dogefile.py` and fill it with following code:

```python
from pathlib import Path

from dogebuild_c.c_plugin import CPlugin, BinaryType


CPlugin(
    binary_type=BinaryType.EXECUTABLE,
    out_name="executable_name",
    src=Path("src").glob('**/*.c'),
    headers=Path("src").glob('**/*.h'),
)
```

Create directory `src` and put all your source code files into that.

## Building project

To build project run dogebuild in project directory:

```shell script
doge build
```

To build and run project run:

```shell script
doge run
```

## Next steps

Advanced documentation for dogebuild available in [readthedocs](https://dogebuild.readthedocs.io).

Advanced documentation for dogebuild c plugin available in [readthedocs](https://dogebuild-c.readthedocs.io).
pyxl-cli 0.2.1
openpyxl wrapper for cli use
License: MIT
Requires Python: >=3.8,<4.0

# pyxl-cli

opeypyxl wrapper for cli use.

## install

```sh
pip install pyxl-cli
```

## usage

### read
output stdout CSV format

```sh
pyxl read \
    --input_xlsx input.xlsx
```

output file TSV format

```sh
pyxl read \
    --input_xlsx input.xlsx \
    --output /tmp/output.tsv \
    --delimiter='\t'
```

### write
for CSV file

```sh
pyxl write \
    --sheet_xy_csv 1 A1 input.csv \
    template.xlsx output.xlsx
```

for 2 TSV files

```sh
pyxl write \
    --sheet_xy_csv 1 A1 input_a.tsv \
    --sheet_xy_csv 1 F12 input_b.tsv \
    --delimiter="\t" \
    template.xlsx output.xlsx
```