semvec/pypi-packages huggingface dataset:
PyAutoRestart 0.0.2
This package automatically re-runs a python file on changing.
Requires Python: >=3.6
Keywords: development,nodemon

# PyAutoRestart

This is a nodemon clone but for Python.  
The main.py file performs actions if a file has been updated.  
The file_update.py has a class called Watcher with functions to watch
for file updates.

## How to use:

To use this with a file, you need to run:

```
python main.py file_to_watch.py
```

If you don't provide a file, it will print this message:

```
Please enter a file name that you want to run with PyAutoRestart.
Usage: python main.py <file_name>
Example: python main.py test.py
```

Otherwise, if you pass a file that doesn't exist, it will give you this error:

```
Please enter a valid file name you want to run with PyAutoRestart.
```

If there is any other project that resembles this or is similar to this, it is a pure coincidence.
qNetVO-bdoolittle 0.1.0
The Quantum Network Variational Optimizer
Requires Python: >=3

# qNetVO

*The **Q**uantum **Net**work **V**ariational **O**ptimizer is python framework for
simulating and optimizing quantum communication networks using
quantum hardware.*

[![Test Status](https://github.com/ChitambarLab/qNetVO/actions/workflows/run_tests.yml/badge.svg?branch=main)](https://github.com/ChitambarLab/qNetVO/actions/workflows/run_tests.yml)

## Project Goals

1. Develop a variational quantum optimziation framework for quantum networks:
    1. Construct ansatz circuits that simulate quantum networks.
    2. Provide cost functions for quantifying useful network properties.
    3. Tools for simple optimizations over quantum network parameters.
2. Use framework to characterize nonlocality in noisy, near-term quantum networks:
    1. Find network parameters for maximal nonlocality in ideal quantum networks.
    2. Construct accurate noise models for near-term quantum network simulations. 
    3. Evaluate the noise robustness of quantum network nonlocality.

## Development

### Environment

For convenience a dev environment can be setup from the `environment.yml`.

1. Create the `qnetvo-dev` enviroment:

```
(base) $ conda env create -f environment.yml
```

2. Activate the `qnetvo-dev` environment:

```
(base) $ conda activate qnetvo-dev
```

### Documentation

To view the project documentation it must be built and served locally. 
It cannot currently be hosted by GitHub because the repository is private and hosting
services are not available for free accounts.


1. Build documentation:

```
(qnetvo-dev) $ sphinx-build -b html docs/source/ docs/build/html
```

2. Locally serve documentation by navigating to the `./docs/build/html` directory and running:

```
(qnetvo-dev) $ python -m http.server --bind localhost
``` 

### Tests

Run tests from the root directory with with `$ python -m pytest`. All test are found in the `./test` directory.

### Code Formatting

To format code run `$ black -l 100 qnetvo test docs`. This uses the [black](https://black.readthedocs.io/en/stable/) code formatter.
trainme 1.0
tune with optuna and model
Requires Python: >=3.6

# trainme - documentation

## Authors

- [@Aditta-das](https://github.com/Aditta-das)


# kaggle-autolgb

trainer is a combination of xgboost, lightgbm and optuna. I tried to make kaggle monthly competition simple. Its only working with classification problem.

## Installation
```
pip install trainer
``` 
   
## Features

- autotune
- autotrain
- auto submission file generate
- auto prediction 


## Deployment

```
from src.read_data import ReadFile

s = ReadFile(
	train_path="/home/aditta/Desktop/trainme/trainme/input/multi_class_classification.csv",
	test_path="/home/aditta/Desktop/trainme/trainme/input/multi_class_classification_test.csv",
	label="target",
    	task_type="multi_classification",
	compare=False,
	fold="skfold",
	model_name="xgb",
	output_path="/media/aditta/NewVolume/amazon",
	study_name="new_train",
	store_file ="out9",
	n_trials=1
)

print(s.report())
print(s.train())

```

## License

[Apache 2.0](https://choosealicense.com/licenses/apache-2.0/)
cqh-file-watcher 0.0.41
tools like vscode file-watcher but for command only
Requires Python: >=3.6

cqh_file_watcher
=============================================

something like `File-Watcher` for vscode


Usage
-------------------------------------------------


``cqh_file_watcher -c ***.conf``

conf example
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

use pattern
::::::::::::::::::::::::::::::::::::::::::::::::::


.. code-block::

    {"command_list":[
        {
            "pattern": "*.py",
            "command": "sudo supervisorctl restart redis"
        }
    ],
    "directory": "/home/vagrant/code/code1"
    }

no pattern
:::::::::::::::::::::::::::::::::::::::::::::::::::::::::


.. code-block::


    {"command_list":[

        {
            "command": "echo things changed"
        }
    ],
    "directory": "/home/vagrant/code/code1"
    }

directory for command
::::::::::::::::::::::::::::::::::::::::::::


.. code-block::

    {"command_list":[
        {
            "pattern": "*.py",
            "command": "sudo supervisorctl restart redis"
            "directory":  "/home/vagrant"
        }
    ]
    "directory": "/home/vagrant/code/code1"
    }


add ignore pattern for one
:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::


.. code-block::

    {"command_list":[
        {
            "pattern": "*.py",
            "ignore_pattern": ["_build/.*"],
            "command": "sudo supervisorctl restart redis"
            "directory":  "/home/vagrant"
        }
    ]
    "directory": "/home/vagrant/code/code1"
    }

add ignore pattern for multi
:::::::::::::::::::::::::::::::::::::::



.. code-block::

    {"command_list":[
        {
            "pattern": "*.py",
            "ignore_pattern": ["_build/.*" , "_download/.*", "^css/.*", "^_static/.*"],
            "command": "sudo supervisorctl restart redis"
            "directory":  "/home/vagrant"
        }
    ]
    "directory": "/home/vagrant/code/code1"
    }

use DIRECTORY env
:::::::::::::::::::::::::::::::::::::::::::::::::


.. code-block::

    {"command_list":[
        {
            "pattern": "*.py",
            "ignore_pattern": ["_build/.*" , "_download/.*", "^css/.*", "^_static/.*"],
            "command": "sudo supervisorctl restart redis"
            "directory":  "/home/vagrant"
        }
    ]
    "directory": "${DIRECTORY}"
    }





some problems
-----------------------------------------------------

sre_constants.error: nothing to repeat at position 0
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>


config

.. code-block::

    {"command_list":[
        {
            "pattern": "*\\.py",
            "ignore_pattern": ["_build/.*" , "_download/.*", "^css/.*", "^_static/.*"],
            "command": "${DIRECTORY}/venv/bin/invoke gpush"
        }
    ],
    "directory": "${DIRECTORY}"
    }

replace ``pattern: "*\\.py"`` with ``patter: ".*\\.py"``
krk-tablebase-generator 0.0.1
C++ extension package that generates a tablebase of KR_K chess endgames.

# KRK Tablebase Generator

KRK Tablebase Generator is a C++ extension for accelerating the generation of a [King and Rook versus King](https://www.chessprogramming.org/KRK) (KRK) endgame tablebase.

## Installation

Use the package manager [pip](https://pip.pypa.io/en/stable/) to install krk-tablebase-generator.

```bash
pip install krk-tablebase-generator
```

## Usage

```python
import tablebase

# returns a tuple containing black to move positions and white to move positions
tablebase.get_lists()
```

## License
[MIT](https://choosealicense.com/licenses/mit/)
rlsa 0.0.2
Run Length Smoothing Algorithm
Requires Python: >=3.8
Keywords: rlsa

# RLSA
C implementation of [RLSA](https://users.iit.demokritos.gr/~bgat/RLSA_values.pdf) for use in python.

## Usage
### Requirements
- python version >= 3.8

### Install
Install with:
```
pip install rlsa
```

### Usage
The main function is `rlsa`.\
It takes as input a black and white image (as a uint8 numpy array), and the hvs, vsv and ahvs values.
The function returns a new black and white image, leaving the original one intact.

You can also import the `rlsa_horizontal` and `rlsa_vertical` functions to apply only one of the RLSA components.

### Usage example
A full example would be:
```
import cv2
from rlsa import rlsa

img = cv2.imread("assets/rlsa_test_image.jpg", cv2.IMREAD_GRAYSCALE)
_, binary_img = cv2.threshold(img, 190, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)

hsv = vsv = 25
out_img = rlsa(binary_img, hsv, vsv, hsv//10)
```

With a similar setup, the other functions can be used like so:
```
out_img = rlsa_horizontal(binary_img, hsv)
out_img = rlsa_vertical(binary_img, vsv)
```

### Results
| Input image | After RLSA |
|    :---:      |     :---:     |
| ![Input](/assets/rlsa_test_image.jpg?raw "Output sample") | ![Output](/assets/rlsa_out.jpg?raw "Output sample") |

| Horizontal only | Vertical only |
|    :---:      |     :---:     |
| ![Horizontal](/assets/rlsa_out_hor_only.jpg?raw "Horizontal output sample") | ![Vertical](/assets/rlsa_out_vert_only.jpg?raw "Vertical output sample") |


## Included scripts

A few scripts are included in the tests folder. One is a python implementation of rlsa, serving as reference. The other two compare the result and speed of the implementations.\
To run the those scripts, you need to install opencv.

### Test
```
python -m tests.test assets/rlsa_test_image.jpg
```

### Benchmark
```
python -m tests.benchmark assets/rlsa_test_image.jpg
```
--> C version is around 400 times faster than the naive python one.



#### Misc
Note: the numpy tutorial/doc [here](https://numpy.org/doc/stable/user/c-info.how-to-extend.html) is (it seems) outdated (be carefull when using it).