semvec/pypi-packages huggingface dataset:
ansio 0.0.2
AnsI/O module for ansi input & output
Requires Python: >=3.10

# AnsI/O

[![pytest](https://github.com/nineteendo/ansio/actions/workflows/pytest.yml/badge.svg)](https://github.com/nineteendo/ansio/actions/workflows/pytest.yml)

AnsI/O module for ansi input &amp; output

## Example usage

### Ansi input

```python
from ansio import ansi_input, application_keypad, mouse_input
from ansio.input import InputEvent, get_input_event

with ansi_input, application_keypad, mouse_input:
    while True:
        event: InputEvent = get_input_event()
        print(event.pressed, repr(event.shortcut))
```

Example output:

```none
True 'alt+shift+a'
True 'ctrl+a'
True 'tab'
True 'shift+up'
True 'a'
True 'primary_click'
False 'primary_click'
True 'ctrl+primary_click'
False 'ctrl+primary_click'
```

### Ansi output

```python
from ansio import ansi_output
from ansio.colors import blue_bg, invert, italic, yellow

with ansi_output:
    print(f'Print in {yellow(blue_bg("color"))} and with {italic(invert("styles"))}')
```

Example output:

![](assets/ansi_output.png)
smart-pip-magic 0.1.2
A alternative pip magic to jupyter's %pip. It shows if you need to restart python after %smart_pip install
Requires Python: >=3.9

# Smart pip magic
A alternative pip magic to jupyter's %pip. It shows if you need to restart python after %pip install based on if existing imported modules are affected. 

## Install
```
pip install smart-pip-magic
```
## Usage
Enable smart pip:
```
import smart_pip
%pip install [opts] [list of package specifications]
```

At the end of pip standard output, it will alert you if need to restart python and list all affected imported modules.


Add action hook to act on affected imported modules by the end of %pip install. If no such module is found, hooks are not invoked. 

```
import smart_pip
def hook(modules_whose_files_changed: Callable[[List[str]], None]) -> None:
    print('hook called on ' + str(modules_whose_files_changed))
smart_pip.add_reload_hook(hook)
```

## Testing
```
pip install .[dev]
pytest
```
kandinskylib 0.1.4
A library for working with Kandinsky AI image generator API
Requires Python: <4,>=3.6
Keywords: kandinsky, ai, image generation, api

# KandinskyLib

A library for interacting with the Kandinsky AI image generation API.

## Installation

You can install the library using pip:

```bash
pip install kandinskylib
```

# Usage

## Generator

```python
from kandinskylib import Kandinsky

api_key = 'your_api_key'
secret_key = 'your_secret_key'
client = Kandinsky(api_key, secret_key)

# Generate an image
response = client.generate_image(
    prompt="A cat in sunglasses",
    scale="3:2",
    style="UHD",
    negative_prompt="Bright colors, neon colors",
    path="./image/generated_image.jpg"
)
print(response)
```

## Available Styles

```python
from kandinskylib import styles

# List available styles
styles_response = styles()
print(styles_response)
```

# Documentation
`class Kandinsky`
`__init__(self, api_key, secret_key)`
Initializes the client for API interaction.

- `api_key` (str): Your API key.
- `secret_key` (str): Your secret key.
`get_model(self)`
Fetches the model ID for image generation.

- Returns: `str` - The model ID or `None` in case of an error.
`generate_image(self, prompt, scale='1:1', style='UHD', negative_prompt="Яркие цвета, кислотные цвета", path='./image/generated_image.jpg')`
Generates an image based on a text prompt.

- `prompt` (str): Text prompt for image generation. The length should be less than 1000 characters.
- `scale` (str): Aspect ratio of the image in the format 'w
'. Default is '1:1'.
- `style` (str): Image style. Default is 'UHD'.
- `negative_prompt` (str): Negative text prompt to exclude unwanted elements.
- `path` (str): Path to save the generated image. Default is './image/generated_image.jpg'.
- Returns: `str` - Message about the result of the generation.
`_check_generation(self, request_id, attempts=10, delay=10)`

Checks the status of image generation.

- `request_id` (str): Generation request ID.
- `attempts` (int): Number of status check attempts. Default is 10.
- `delay` (int): Delay between status check attempts in seconds. Default is 10.
- Returns: `list` - List of generated images in base64 format or raises an exception in case of an error.

`_get_max_resolution(self, scale)`
Determines the maximum resolution of the image based on the aspect ratio.

- `scale` (str): Aspect ratio in the format 'w'.
- Returns: `tuple` - Width and height of the image.

`_save_image(self, base64_str, output_file)`
Saves the image to a file.

- `base64_str` (str): Base64 string of the image.
- `output_file` (str): Path to save the image.
  
`def styles()`
Fetches the list of available styles for image generation.

- Returns: `list` - List of available styles.

## License

This project is licensed under the terms of the MIT License - see the LICENSE file for details.
pyrockpaperscissors 1.0.2
A simple Rock Paper Scissors Game written in Python🐍

# Rock Paper Scissors Game

A simple Rock Paper Scissors game implemented in Python for the console.

## Table of Contents

- [Introduction](#introduction)
- [Features](#features)
- [Installation](#installation)
- [Usage](#usage)
- [Contributing](#contributing)

## Introduction

Welcome to the Rock Paper Scissors game! This is a console-based implementation of the classic game where you can play against the computer. The game is built using Python and is designed to be simple and easy to use.

## Features

- Play Rock Paper Scissors against the computer.
- Keep track of your score.
- Simple and intuitive command-line interface
- Easy to install.

## Installation

To install the Rock Paper Scissors game, you need to have Python installed on your system. You can install the game using pip:

```bash
pip install pyrockpaperscissors
```

## Usage

After installing the package, you can start the game by running the following command in your console:

```bash
rps
```

This will launch the Rock Paper Scissors game.

## Contributing

Contributions are welcome! If you have any ideas, suggestions, or bug reports, please open an issue or submit a pull request.

1. Fork the repository.
2. Create a new branch( ``git checkout -b feature-branch`` ).
3. Commit your changes( ``git commit -m 'Add some feature'`` ).
4. Push to the branch( ``git push origin feature-branch`` ).
5. Open a pull request.
apparat 0.2.0
This is the machine description framework
Requires Python: <4,>=3.10.4

# apparat

A meta framework

## Description

* OO-Drawing

* Automation
    - nodes
    - stages
    - environment
    - container

* monitoring

* Audio

### Concepts
* FS based
* Auto reload with inotify

### Strong tool usage

* Full tool coverage
* Full paradigm coverage
** async
** multiprocessing
* pydantic
* functional
* opt in profiling
* on-the fly callstack
* flexible logging

* mypy / mypyc
* platform independent
* support IDEs
* pyenv
* pipenv
* CI integration Gitlab runner
* profiling
* logging
* doctest
* documentation

## Installation

## Usage


## Test and Deploy

Use the built-in continuous integration in GitLab.

- [ ] [Get started with GitLab CI/CD](https://docs.gitlab.com/ee/ci/quick_start/index.html)
- [ ] [Analyze your code for known vulnerabilities with Static Application Security Testing(SAST)](https://docs.gitlab.com/ee/user/application_security/sast/)
- [ ] [Deploy to Kubernetes, Amazon EC2, or Amazon ECS using Auto Deploy](https://docs.gitlab.com/ee/topics/autodevops/requirements.html)
- [ ] [Use pull-based deployments for improved Kubernetes management](https://docs.gitlab.com/ee/user/clusters/agent/)
- [ ] [Set up protected environments](https://docs.gitlab.com/ee/ci/environments/protected_environments.html)


## Support

## Roadmap

## Contributing

## Authors and acknowledgment

## License

## Project status
w3crack 0.1.0
Web3 Wallet bruteforce using CPU and GPU
Requires Python: >=3.7
Keywords: web3, wallet, recovery, restore, bruteforce, bitcoin, ethereum, metamask, trust, trustwallet, brave, bravewallet

# W3crack

W3crack is driver implementation of [W3recovery](https://github.com/pepeic/W3recovery) project used to recover web3 wallets. It tries to crack wallets (test many passwords for a wallet) using both CPU and GPU (if possible and not spicified otherwise). It also written in Rust to provide better performance and ABI stability.

> **IMPORTANT**: GPU cracking is not available on AMD GPU's! You MUST specify cpu_only option if you use AMD GPU. Only NVidia GPU's are supported!

### Which wallets are supported?

For now the driver supports only these:

* MetaMask like wallets (MetaMask, Ronin, Binance Chain, etc.)
* Brave Wallet
* Trust Wallet (requires good GPU to perform GPU bruteforce)

### So little?

The project is in early stage of development. These wallets were implemented first as they are the most popular and because main project targets wallets from chromium browsers, however more wallets may be added in the future (if the project will be popular enough).
If you need usage examples, you can check [the main project](https://github.com/pepeic/W3recovery) which is very small so it should be easy to figure stuff out.

> **NOTE**: This project is under development and may contain bugs, you can report them if you find any, however it is not supposed to be used by third parties yet and actually part of the [W3recovery](https://github.com/pepeic/W3recovery) project.
eegpp 2.1.2
EEG Phrase Predictor
Requires Python: >=3.9

# EEG Phrase Predictor

## Setup
- Requirements: python==3.9
- Installing: 
    ```
        pip install eegpp
    ```
## Configuration
YML_CONFIG_FILE (e.g. data_config_infer.yml) with the following contents

```
datasets:
  time_step: 4000 #milliseconds
  data_dir: "FULL_PATH_TO_THE_FOLDER_WITH_RAW_SIGNAL_FILES"
  tmp_dir : "FULL_PATH_TO_THE_TMP_FOLDER"
  out_dir: "FULL_PATH_TO_THE_OUTPUT_FOLDER"
  seq_files: ["name_of_raw_file_1", "name_of_raw_file_2",...,"name_of_raw_file_n]
  template_files: ["template_label_file_1", "template_label_file_2", ..., "template_label_file_n"]
  out_seperator: "\t"

```
If there is no template for label file, leave it as : template_files: [] or remove the line
Example:
```
datasets:
  time_step: 4000 #milliseconds
  data_dir: "/home/EEGData/EEG_test_files"
  tmp_dir : "/home/EEGData/tmp"
  out_dir: "/home/EEGData/EEG_test_files"
  seq_files: ["raw_K3_EEG3_11h.txt", "raw_RS2_EEG1_23 hr.txt", "raw_S1_EEG1_23 hr.txt"]
  template_files: ["K3_EEG3_11h.txt", "RS2_EEG1_23 hr.txt", "S1_EEG1_23 hr.txt"] # if no template, set to : [ ] or remove this line
  out_seperator: "\t" for tab or "," for commas

```
or
```
datasets:
  time_step: 4000 #milliseconds
  data_dir: "/home/EEGData/EEG_test_files"
  tmp_dir : "/home/EEGData/tmp"
  out_dir: "/home/EEGData/EEG_test_files"
  seq_files: ["raw_K3_EEG3_11h.txt", "raw_RS2_EEG1_23 hr.txt", "raw_S1_EEG1_23 hr.txt"]
  template_files: [] # if no template, set to : [ ] or remove this line
  out_seperator: "\t" for tab or "," for commas

```

## Running

Command:

```
    python -m eegpp -p PATH_TO_THE_YML_CONFIG_FILE -e -t 0.55 {-n for norule}
```
e.g.

```
    python -m eegpp -p data_config_infer.yml -e -t 0.55
```

No rule:
```
    python -m eegpp -p data_config_infer.yml -e -t 0 -n
```

Add option -l to enter silence mode (no screen output).

For visualization:

First run inference with option -s:

```
    python -m eegpp -p data_config_infer.yml -e -t 0 -n -s
```

Then:

```
    python -m eegpp -p data_config_infer.yml -v
```

To enter visualization mode for the first dataset in data_config_infer.yml. 
EpochID starts with 1

or add -i option to set epoch ids

```
    python -m eegpp -p data_config_infer.yml -v -i EpochID1,EpochId2,...,EpochIDn
```
To plot the signal and prediction of the EpochID (Indexing from 1), separating by commas