semvec/pypi-packages huggingface dataset:
horseAnalysis 0.0.6
The system can look up and analyze a horse's history of running famous races.
Requires Python: >=3.7

# horseAnalysis

This system uses horse racing data from 2002 onward to know the names of horses in specific ranks by race and the historical times for specific races.

## usage
#### the names of horses in specific ranks by race
 horseAnalysis 1 "rank ex). 1" "race name"

#### the historical times for specific races.
 horseAnalysis 2 "race name"
jpsuicide 0.0.4
A package for visualizing number of suicides in Japan
Requires Python: >=3.7

# jpsuicide

A package for visualizing number of suicides in Japan

# How to install jpsuicide

$ pip install jpsuicide  
$ pip install tabula-py  
$ pip install matplotlib  
$ pip install japanize_matplotlib  
$ pip install pandas  

# How to run jpsuicide (example)

$ jpsuicide '東京都'
authenticator-backup 0.1.2
Tool to backup Google Authenticator to a GPG encrypted file
Keywords: google authenticator backup

# Authenticator Backup

Tool to backup (and restore) [Google Authenticator](https://play.google.com/store/apps/details?id=com.google.android.apps.authenticator2)
to GPG encrypted files.

**NOTE**: This has only been tested on Linux.  If you find any issues or would
like to share any solutions, [please submit an issue](https://github.com/mikeshultz/authenticator_backup).

## Quickstart

### System Dependencies

You will need to have `opencv` and `gpg` installed on your system for this
package to work.  You should install them before installing this package.  For
instance, on Arch Linux (other distributions may use different package managers
or package names):

    pacman -S opencv gnupg

Install Authenticator Backup:

    pip install --user authenticator_backup

## Backup

You'll need the public key for the PGP account(s) that can decrypt the file (the
recipients).  Each one separated by a space.

    python -m authenticator_backup backup 636ABA5F59810D7D97EF05035B705B8C90A02377 > /tmp/backup.txt

This will open a Window displaying video from  your Web cam to scan the export
QR code with.  To get this code:

1) Open up Google Authenticator
2) Tap the triple-dot in the top right-hand corner
3) Tap "Transfer Accounts"
4) Tap "Export Accounts"
5) Select the accounts you want to backup (probably all of them), and tap "Next"
6) Show this code to your Web cam

The window will close and the encrypted backup will be output once it
successfully captures the QR code.

## Restore

To restore, the recipient GPG account must be on the system to decrypt it.

    cat /tmp/backup.txt | python -m authenticator_backup restore

This will display a QR code yo ucan scan with Google Authenticator to re-import
the accounts.  **DO NOT DISPLAY THIS IN A PUBLIC PLACE**  

1) Open up Google Authenticator
2) Tap the triple-dot in the top right-hand corner
3) Tap "Transfer Accounts"
4) Tap "Import Accounts"
5) Tap "Scan QR code"
6) Scan QR code displayed in the window
6) Close the window when complete

If you had a lot of accounts, multiple windows showing QR code may be displayed,
one after another.
goon-parser 0.2.0
A python package used to parse ss13 dm files into json
Requires Python: >=3.10,<4.0


# Goon Parser

## Installation
#### Using Pip
    pip install goon_parser

#### Using Poetry
    poetry add goon_parser


## Usage
##### CLI
    - Poetry
    poetry run generate json './path/to/file.dm' './path/to/output.json'

##### Parser
    from goon_parser.parser import get_dict, get_json

    chemistry_recipes_dict = get_dict('./Chemistry_Recipes.dm')
    chemistry_recipes_json = get_json('./Chemistry_Recipes.dm')
Horsesale 0.0.1
A package designed to help you understand the trends of nations that host high-level G1 races.
Requires Python: >=3.6

# Horsesale

Horsesale displays the number of horses listed at Japanese horse sales by sire.<p>
To use it, you must fill in the URL from the JBIS Search page. In JBIS Search, the list of horses for sale is uploaded just before the actual day of the sale.<p>
https://www.jbis.or.jp/seri/result/?year=2022&x=68&y=18 <p>
mh 0.0.33
A small example package

# Example Package

## To show 
* package distribution
* package testing (unit, performance, acceptance and multi interpreter)
* logging use
* loading to pypi
<br /> 

## Usage
To install, either <br />
`pip install mh`<br /> 
`pip install git+https://github.com/MarkHallett/mh@v0.0.33` <br />
<br />
To import <br />
`import mh`<br /> 
<br /> 
Example usage   
* `print mh.EG_VAR2`<br /> 
* `print mh.test_function()`<br /> 
* `print mh.Mh().run_mh()`<br /> 
<br /> 

## Further documentation
[mh docs](https://markhallett.github.io/mh/)

## To run tests  
unit `python -m unittest `<br /> 
performance `cd tests/performance; python test_perf.py`<br /> 
acceptance `cd tests/acceptance; behave mh.feature`<br /> 
multi interpreter `tox`<br />
pygsom 0.1.0
gsom clustering and dimensional reduction algorithm
Requires Python: >=3.6

# `pygsom` - python GSOM algorithm

`pygsom` is an **open source** python-based implementation of **GSOM** algorithm. GSOM is unsupervised  dimensionality reduction and clustering  algorithm 


## Table of Contents

* [Installation](#installation)
* [Minimal example](#minimal-example)
* [Getting started](#getting-started)
* [Citing gsom](#citing pygsom)

## Installation

To pip install `pygsom` from github:

```bash
pip install pygsom
```


pygsom  supports Python 3.6+.

## Minimal example


```python
import numpy as np
import pandas as pd
import gsom

data_filename = "data/zoo.txt".replace('\\', '/')


if __name__ == '__main__':
    np.random.seed(1)
    df = pd.read_csv(data_filename)
    print(df.shape)
    data_training = df.iloc[:, 1:17]
    gsom_map = gsom.GSOM(.83, 16, max_radius=4)
    gsom_map.fit(data_training.to_numpy(), 100, 50)
    map_points = gsom_map.predict(df,"Name","label")
    gsom.plot(map_points, "Name", gsom_map=gsom_map)
    map_points.to_csv("gsom.csv", index=False)
```

## Getting started
Train the GSOM algorithm : need to give input data in numpy array with training iterations and smoothing iterations
```python
gsom_map.fit(data_training.to_numpy(), <training iterations>, <smooth iterations>)
```
Predict cluster nodes : need to give input data in pandas dataframe with names and labels 
```python
map_points = gsom_map.predict(df,<name column name>,<label column name>)
```
Plot the 2D map: need to give the output of predict function with label column (name column or label column)
```python
gsom.plot(map_points, <name column name/label column name>, gsom_map=<gsom_map>)
```

## Citing pygsom

If you use `pygsom`, please cite the following paper:

```
@article{alahakoon2000dynamic,
  title={Dynamic self-organizing maps with controlled growth for knowledge discovery},
  author={Alahakoon, Damminda and Halgamuge, Saman K and Srinivasan, Bala},
  journal={IEEE Transactions on neural networks},
  volume={11},
  number={3},
  pages={601--614},
  year={2000},
  publisher={IEEE}
}
```
eyesim 0.0.3
eyesy simulator
Requires Python: >=3.8

# eyesim

<img src="https://raw.githubusercontent.com/notmatthancock/eyesim/main/screenshot.png" width="50%" height="50%" />

This is a simulator for the [eyesy](https://www.critterandguitari.com/eyesy) visual synth. Its purpose is to allow you to develop new eyesy visualization modes when you're too lazy to get out of bed and plug in audio, video, and power cables.

The simulator is a command line tool. As input, you give it a path to the mode folder containing a `main.py` file conforming to the [eyesy API](https://www.critterandguitari.com/manual?m=EYESY_Manual#52-eyesys-api). You can also give it a path to an audio file to use. Currently, only 16 bit WAV are usable. The audio file input is optional.

## Install

```bash
pip install eyesim
```

## Usage

You can run a test mode by supplying "test" as the path.
```bash
eyesim --mode-folder test
```

However, normally you would invoke it like:
```bash
eyesim --mode-folder "/path/to/S - Nice Mode/" --audio-file "/path/to/song.wav"
```

When the simulator is running, pressing the space bar to toggle visibility of the sliders and buttons that simulate the knobs on the physical eyesy device.

The full command line usage is:

```bash
$ eyesim --help
usage: eyesim [-h] -m MODE_FOLDER [-a AUDIO_FILE] [-w WIDTH] [-t HEIGHT]

Start eyesy simulation

optional arguments:
  -h, --help            show this help message and exit
  -m MODE_FOLDER, --mode-folder MODE_FOLDER
                        path to folder containing mode's main.py script
  -a AUDIO_FILE, --audio-file AUDIO_FILE
                        path to audio file to play (optional)
  -w WIDTH, --width WIDTH
                        window width in pixels
  -t HEIGHT, --height HEIGHT
                        window height in pixels
```

## Caveats

The eyesy code runs Python 2, and all the stock modes are Python 2. But, this package is written in Python 3. I did this in order to use the pygame widgets package and to use the latest scipy for reading wav files. The result is that you might find your mode or a stock mode breaks. In my experience, this is almost always due to one of two things:

1. a Python 2 style print statement, i.e., `print "foo"` rather than `print("foo")`
2. assumed integer division, i.e., assuming `1/2` results in an integer

The latter is easily fixed by explicitly using integer division (the `//` operator), which is compatible with both Python 2 and 3. Or, you can explicitly convert to int by `int(1/2)`.

## References

- eyes OS: https://github.com/critterandguitari/EYESY_OS/
- stock eyes modes: https://github.com/critterandguitari/EYESY_Modes_Pygame