semvec/pypi-packages huggingface dataset:
accelrod 0.1.0
A library for benchmarking the tflops of accelerators
Requires Python: >=3.10

# Accelrod


## Installation

> pip install -U accelrod

[all] includes nbformat to visualize the result in notebook
> pip install -U accelrod[all]

## Example
```
import torch

from accelrod.benchmark import benchrun, plot_result

# without max_dimension, the matrix size will be determined based on available VRAM
result = benchrun(
    algorithm="GEMM",
    device="auto",
    as_dataframe="pandas",
    params={
        # "max_dimension": 2048,
        "dtype": [torch.float32, torch.float16, torch.bfloat16],
    },
)

# plot in notebook
import plotly.offline as pyo

pyo.init_notebook_mode()
plot_result(result)

```

## Developer guide

### Setup working env / dependencies

Sync the project's dependencies with the environment.
> uv sync

lock dependencies declared in a pyproject.toml
> uv pip compile pyproject.toml -o requirements.txt



### Add dev dependencies
>uv add --dev ruff pytest

### Editable Installs
>uv pip install -e .[all,dev]

### Test package with local build
uv pip install dist/accelrod-0.1.0-py3-none-any.whl
uv run --with accelrod --no-project --refresh-package accelrod -- python -c "import accelrod"
pysage3 1.0.8
SAGE3 API
Requires Python: >=3.9

# Python API to SAGE3

# Configuration

.env file or environment variables

```
SAGE3_SERVER=example.com
ENVIRONMENT=production
TOKEN= XXX_JWT TOKEN for SAGE3 Auth_XXX
```

# Loading

```
from foresight.config import config as conf, prod_type
from foresight.Sage3Sugar.pysage3 import PySage3
# Connect to the SAGE3 server
ps3 = PySage3(conf, prod_type)
```

## Examples

See [https://sage-3.github.io/docs/SAGE3-API-in-SageCell](https://sage-3.github.io/docs/SAGE3-API-in-SageCell)

```python
from foresight.config import config as conf, prod_type
from foresight.Sage3Sugar.pysage3 import PySage3

room_id = %%sage_room_id
board_id = %%sage_board_id
app_id = %%sage_app_id
selected_apps = %%sage_selected_apps

ps3 = PySage3(conf, prod_type)
smartbits = ps3.get_smartbits(room_id, board_id)
bits = [smartbits[a] for a in selected_apps]
for b in bits:
  print(b)
```
postprocessing 0.1.0
Multi-Objective Learning via Ensembling
Requires Python: >=3.6

![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)
![GitHub version](https://img.shields.io/github/v/release/AminChrs/PostProcess)

<p align="center">
<img src="logo.png" width="400" />
</p>

This repository contains the experiments of the paper "[A Unifying Post-Processing Framework for Multi-Objective Learn-to-Defer Problems](https://arxiv.org/abs/2407.12710)" that was [published](https://neurips.cc/virtual/2024/poster/95484) in NeurIPS 2024. This paper introduces a post-processing method for solving a variety of multi-objective learning problems, including but not limited to learn-to-defer problem and fair multi-class classification problem. During this method, first an embedding function related to each objective is trained, and then an optimal classifier via linear combination of the embedding functions is obtained using validation data. This method presents an alternative paradigm compared to Lagrangian-based methods such as primal-dual methods.

The experiments are conducted using the ACSIncome and COMPAS datasets. The code for the experiments can be found in the following Jupyter Notebook files:



- ACS.ipynb
- COMPAS.ipynb

Please refer to these notebooks for the detailed implementation and analysis of the plots.

## Dataset
The following datasets are used for the experiments:

- The ACSIncome dataset from [Folktables](https://github.com/socialfoundations/folktables) package for income prediction
- The [COMPAS](https://www.science.org/doi/10.1126/sciadv.aao5580) dataset for prediction of recidivism
## Requirements

To run the code in the Jupyter Notebook files, make sure you have the dependencies installed. To do this, you can run the following command in your terminal:

```sh
pip install -r requirements.txt
```

## Usage
![image info](Diagram.jpg)

1. Clone this repository to your local machine.
2. Open the Jupyter Notebook files (ACS.ipynb and COMPAS.ipynb) using Jupyter Notebook.
3. Run the code cells in the notebooks to reproduce the experiments and generate the plots.

## License

This project is licensed under the [MIT License](LICENSE).

## Citation

In case that you have used codes in this repository, please consider citing our paper:

```bibtex
@article{charusaie2024unifying,
  title={A Unifying Post-Processing Framework for Multi-Objective Learn-to-Defer Problems},
  author={Charusaie, Mohammad-Amin and Samadi, Samira},
  journal={arXiv preprint arXiv:2407.12710},
  year={2024}
}
```
infomaniak-ai 0.0.1
A python wrapper around Infomaniak AI tools
Requires Python: >=3.9

# Infomaniak AI

[![PyPI - Version](https://img.shields.io/pypi/v/infomaniak-ai.svg)](https://pypi.org/project/infomaniak-ai)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/infomaniak-ai.svg)](https://pypi.org/project/infomaniak-ai)

---

## Table of Contents

- [Installation](#installation)
- [License](#license)

## Installation

```console
pip install infomaniak-ai
```

## License

`infomaniak-ai` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.
system-monitor-cli 0.1.1
A comprehensive system monitoring tool with real-time insights
Requires Python: >=3.6

# System Monitor

A comprehensive system monitoring tool built with Python and the `rich` library, providing real-time insights into system performance, including CPU usage, memory statistics, network details, disk I/O, and temperature monitoring.

## Features

- **Real-time Monitoring**: Displays live updates of system metrics.
- **Customizable Display**: Toggle visibility of different sections like CPU, memory, network, disk I/O, and temperature.
- **User-friendly Interface**: Uses the `rich` library for a visually appealing console interface.
- **Cross-platform Support**: Works on Windows, macOS, and Linux (with some features dependent on platform support).

## Installation

1. **Clone the Repository**:

   ```bash
   git clone https://github.com/johnniewhite/watchtower.git
   cd watchtower
   ```

2. **Install Dependencies**:
   Ensure you have Python 3.6 or later installed. Then, install the required packages:

   ```bash
   pip install -r requirements.txt
   ```

   The `requirements.txt` should include:

   ```
   rich
   psutil
   speedtest-cli
   pynput
   ```

## Usage

Run the system monitor using the following command:

```bash
python system_monitor.py
```

### Keyboard Commands

- **q**: Quit the application
- **s**: Toggle Speed Test display
- **p**: Toggle Process List
- **n**: Toggle Network Details
- **d**: Toggle Disk I/O Statistics
- **t**: Toggle Temperature Monitor
- **h**: Show help message

## Configuration

- **Update Intervals**: Adjust the refresh rate by modifying the `refresh_per_second` parameter in the `Live` context.
- **Speed Test Interval**: Change the `SPEED_TEST_INTERVAL` variable to set how often speed tests are conducted.

## Troubleshooting

- **Temperature Monitoring Not Supported**: If you receive an error about temperature monitoring, ensure your system supports it and that `psutil` is up-to-date.
- **Command Not Responding**: Ensure the terminal window is focused and that you are pressing the correct keys.
- **Dependencies Issues**: Verify that all dependencies are installed correctly using `pip list`.

## Contributing

Contributions are welcome! Please fork the repository and submit a pull request with your changes. Ensure your code follows the existing style and includes appropriate documentation.

## License

This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.

## Contact

For questions or support, please contact [boluwatifeeri@gmail.com](mailto:boluwatifeeri@gmail.com).
adb-wifi-py 0.3.4
A tool for pairing Android 11 and newer devices for wireless debugging directly through a terminal using QR code.
Requires Python: >=3.9

# [adb-wifi-py](https://github.com/Vazgen005/adb-wifi-py)

`adb-wifi-py` is a tool for pairing Android 11 and newer devices for wireless debugging directly through a terminal using QR code.

It leverages the `python-zeroconf` library for multicast DNS service discovery and the `qrcode` library for QR code generation.

## Installation

To install `adb-wifi-py` from [PyPI](https://pypi.org/project/adb-wifi-py/), run the following command:

### pip

```bash
pip install adb-wifi-py
```

### pipx

```bash
pipx install adb-wifi-py
```

### rye

```bash
rye tools install adb-wifi-py
```

### uv

```bash
uv tool install adb-wifi-py
```

## Usage

To use `adb-wifi-py`, run the following command:

```bash
adb-wifi
```

Follow the on-screen instructions to pair your device.

## License

This project is licensed under the GPL-3.0 License.

## Contributing

Contributions are welcome! Please open an issue or submit a pull request.

## Acknowledgements

- [chanzmao](https://github.com/benigumocom) for the idea and [original code](https://gist.github.com/benigumocom/a6a87fc1cb690c3c4e3a7642ebf2be6f).
- [python-zeroconf](https://github.com/python-zeroconf/python-zeroconf) for multicast DNS service discovery.
- [qrcode](https://github.com/lincolnloop/python-qrcode) for QR code generation.
mzapy 1.8.0
A Python package that provides an interface to unprocessed MS data in the MZA format.
Requires Python: >=3.8

# mzapy
A Python package that provides an interface to unprocessed MS data in the MZA format.

#### Contributors:
- Dylan Ross (dylan.ross@pnnl.gov)
- Aivett Bilbao (aivett.bilbao@pnnl.gov)
- Joon-Yong Lee (junyoni@gmail.com)
- Xueyun Zheng (xueyun.zheng@pnnl.gov)

<hr>


Documentation is available at https://mzapy.readthedocs.io/
pvspeakerdemo 1.0.5
Speaker library for Picovoice.
Requires Python: >=3.9
Keywords: Audio Player

# PvSpeaker Demo for Python

This project contains a Python command-line demo for PvSpeaker that demonstrates how to use PvSpeaker to play audio from a WAV file.

## PvSpeaker

PvSpeaker is an easy-to-use, cross-platform audio player designed for real-time speech audio processing. It allows developers to send raw PCM frames to an audio device's output stream.

## Compatibility

- Python 3.9+
- Runs on Linux (x86_64), macOS (x86_64 and arm64), Windows (x86_64, arm64), and Raspberry Pi (3, 4, 5).

## Installation

```console
pip3 install pvspeakerdemo
```

## Usage

In the following instructions, we will refer to  `{AUDIO_DEVICE_INDEX}` as the index of the audio device to use, and `{INPUT_WAV_PATH}` as the path to the pcm `wav` file that will be played.

`{AUDIO_DEVICE_INDEX}` defaults to -1 and `{INPUT_WAV_PATH}` must not be empty.

To show the available audio devices run:

```console
pv_speaker_demo --show_audio_devices
```

To run PvSpeaker run:

```console
pv_speaker_demo --audio_device_index {AUDIO_DEVICE_INDEX} --input_wav_path {INPUT_WAV_PATH}
```

Hit `Ctrl+C` if you wish to stop playing audio before it completes. If no audio device index (`-d`) is provided, the demo will use the system's default audio player device.
pvspeaker 1.0.5
Speaker library for Picovoice.
Requires Python: >=3.9
Keywords: Audio Player

# PvSpeaker Binding for Python

## PvSpeaker

PvSpeaker is an easy-to-use, cross-platform audio player designed for real-time speech audio processing. It allows developers to send raw PCM frames to an audio device's output stream.

## Compatibility

- Python 3.9+
- Runs on Linux (x86_64), macOS (x86_64 and arm64), Windows (x86_64, arm64), and Raspberry Pi (3, 4, 5).

## Installation

```shell
pip3 install pvspeaker
```

## Usage

Initialize and start `PvSpeaker`:

```python
from pvspeaker import PvSpeaker

speaker = PvSpeaker(
    sample_rate=22050,
    bits_per_sample=16,
    buffer_size_secs=20,
    device_index=0)

speaker.start()
```

(or)

Use `get_available_devices()` to get a list of available devices and then initialize the instance based on the index of a device:

```python
from pvspeaker import PvSpeaker

devices = PvSpeaker.get_available_devices()

speaker = PvSpeaker(
    sample_rate=22050,
    bits_per_sample=16,
    buffer_size_secs=20,
    device_index=0)

speaker.start()
```

Write PCM data to the speaker:

```python
def get_next_audio_frame():
    pass

speaker.write(get_next_audio_frame())
```

Note: the `write()` method only writes as much PCM data as the internal circular buffer can currently fit, and returns the length of the PCM data that was successfully written.

When all frames have been written, run `flush()` to wait for all buffered pcm data (i.e. previously buffered via `write()`) to be played:

```python
speaker.flush()
```

Note: calling `flush()` with PCM data as an argument will both write that PCM data and wait for all buffered PCM data to finish.

```python
def get_remaining_audio_frames():
    pass

speaker.flush(get_remaining_audio_frames())
```

To stop the audio output device, run `stop()`:

```python
speaker.stop()
```

Note that in order to stop the audio before it finishes playing, `stop` must be run on a separate thread from `flush`.

Once you are done (i.e. no longer need PvSpeaker to write and/or play PCM), free the resources acquired by PvSpeaker by calling `delete`. Be sure to first call `stop` if the audio is still playing. Otherwise, if the audio has already finished playing, you do not have to call `stop` before `delete`:

```python
speaker.delete()
```

## Demos

[pvspeakerdemo](https://pypi.org/project/pvspeakerdemo/) provides command-line utilities for playing audio from a file.
Automate-GPT 1.0.2
Use Chat GPT Automation

# Automate-GPT

`Automate-GPT` is a Python library that allows users to automate interactions with ChatGPT through a web driver. This library simplifies the process of sending prompts to ChatGPT and receiving responses in an automated manner.

---

## Features

- Automate interactions with ChatGPT.
- Use an undetected Chrome driver to bypass detection.
- Simplified interface for sending prompts and retrieving responses.
- Supports Reset Chat feature to clear the chat history.
- Supports Search internet feature to search for information.
---

## Installation

To install `Automate-GPT`, use pip:

```bash
pip install Automate-GPT
```

---

## Requirements

- Python 3.7 or higher
- [undetected-chromedriver](https://pypi.org/project/undetected-chromedriver/)

---

## Usage

Here is a basic example of how to use the `Automate-GPT` library:

### Example

```python
from Automate_GPT import ChatGPTAutomation
import undetected_chromedriver as uc

# Initialize the undetected Chrome driver
driver = uc.Chrome()

# Initialize ChatGPTAutomation with the Chrome driver
chatbot = ChatGPTAutomation(driver)
response = chatbot.chat("What is the capital of France?")
print(response)  # Output: Paris
chatbot.reset_chat()
chatbot.search_enable(False)
chatbot.get_conversation()
```

---

## API Reference

### `Automate_GPT.ChatGPTAutomation`

A class to automate interactions with ChatGPT.

#### **`__init__(self, driver: undetected_chromedriver.Chrome)`**

Initializes the `ChatGPTAutomation` instance.

- **Parameters**:
  - `driver` (*undetected_chromedriver.Chrome*): The Chrome web driver instance for interacting with ChatGPT.

#### **`prompt(self, prompt: str) -> str`**

Sends a prompt to ChatGPT and retrieves the response.

- **Parameters**:
  - `prompt` (*str*): The text prompt to send to ChatGPT.
- **Returns**:
  - (*str*): The response from ChatGPT.

#### **`reset_chat(self)`**
Resets the chat history.

#### **`search_enable(self, enable: bool)`**
Enables or disables the search internet feature.
- **Parameters**:
  - `enable` (*bool*): Whether to enable or disable the search internet feature.
#### **`get_conversation(self) -> list[dict]`**
Retrieves the conversation history.
- **Returns**:
  - (*list[dict]*): The conversation history.
---
## Notes

- Ensure you have the latest version of Chrome and the corresponding chromedriver installed.
- `undetected-chromedriver` is used to prevent detection during automated browser interactions.

---
## Acknowledgments
Created by [Sheth Jenil](https://github.com/dummyjenil/)