semvec/pypi-packages huggingface dataset:
pyaudiocook 1.0.2
A Python package for audio recording and transcribing
Requires Python: <4.0,>=3.11

# pyaudiocook

A Python package for recording and transcribing audio.

- [pyaudiocook](#pyaudiocook)
  - [Installation](#installation)
  - [Usage](#usage)
    - [AudioRecorder](#audiorecorder)
      - [Example: start recording](#example-start-recording)
      - [Example: pause/resume recording](#example-pauseresume-recording)
      - [Example: stop recording](#example-stop-recording)
    - [AudioTranscriber](#audiotranscriber)
      - [Example: Local whisper model and single audio file](#example-local-whisper-model-and-single-audio-file)
      - [Example: Local whisper model and multiple audio file](#example-local-whisper-model-and-multiple-audio-file)
      - [Example: Calling OpenAI API](#example-calling-openai-api)
      - [Example: Using another model](#example-using-another-model)

## Installation

```bash
pip install pyaudiocook
```

## Usage

The package contains two classes: `AudioRecorder` and `AudioTranscriber`.

### AudioRecorder

#### Example: start recording

```python
recorder = AudioRecorder()
recorder.start_recording()
```

#### Example: pause/resume recording

```python
recorder = AudioRecorder()
recorder.toggle_recording()
```

#### Example: stop recording

```python
recorder = AudioRecorder()
recorder.stop_recording()
```

### AudioTranscriber

Before getting started, make sure you have already obtained an API key on OpenAI. If you have not done so, follow [this guide](https://platform.openai.com/docs/quickstart/create-and-export-an-api-key) to create one.

#### Example: Local whisper model and single audio file

```python
# Transcribe using local whisper model, which is the default
transcriber = AudioTranscriber('audio_1.wav')
transcriber.transcribe()
print(transcriber.texts)
```

#### Example: Local whisper model and multiple audio file

```python
# You can pass multiple audio files for transcribing
transcriber = AudioTranscriber('audio_1.wav', 'audio_2.wav')
transcriber.transcribe()
print(transcriber.texts)
```

#### Example: Calling OpenAI API

*Note: API usage fee applies.*

```python
# You can pass multiple audio files for transcribing
transcriber = AudioTranscriber('audio_1.wav', 'audio_2.wav', mode='remote')
transcriber.transcribe()
print(transcriber.texts)
```

#### Example: Using another model

*Note: this only applies when local whisper model is used*

```python
# Default is tiny.en
transcriber = AudioTranscriber('audio_1.wav', 'audio_2.wav', mode='local', model='base.en')
transcriber.transcribe()
print(transcriber.texts)
```
ODFex 0.0.2
A simple visualization tool intended to help interpret or predict the azimuthal variation in X-ray powder diffraction data
Requires Python: >=3.9

# ODFex
## Orientation Distribution Function Explorer
#### A simple visualization tool intended to help interpret or predict the azimuthal variation in X-ray powder diffraction data  
- 3D visualization of ODF (so far only fibre texture) in relation to the sample orientation  
- Visualization of the scattering vector $\vec{Q}$ and the contributing crystallite direction along the preferred orientation direction cone (POD)  
- Visualization of the azimuthal intensity variation of reflections at similar $2\theta$-values and their summed contribution  
- Easy drag-n-drop import of CIF files


### Examples
The images below show the two main windows in ODFex, the main window containing the user input interface and a plot of the azimuthal intensities of the selected reflections, and the 3D sphere window showing the ODF along with several relevant vectors and cone segments.
  
![ODFex main window example](example_1.png "ODFex main window example")
  
![ODFex 3D sphere window example](example_2.png "ODFex 3D sphere window example")

### Acknowledgements
The visuals, naming convention, and underlying math is heavily inspired by Wright et al. (1996)
### References
 [Wright, N. G., Nelmes, R. J., Belmonte, S. A., & McMahon, M. I. (1996). *Observation and modelling of preferred orientation in two-dimensional powder patterns.* Journal of Synchrotron Radiation, 3(3), 112-119.](https://doi.org/10.1107/S0909049596003627)
image-processingv777 0.0.2
Processamento de imagens
Requires Python: >=3.12

# Image_processing

Description. 
The package image_processing is used to:
    Processing:
	     -Histrogram matching 
	     -Structural similarity
         -Resize image
    Utils:
         -Read image
         -Save image
         -Plot image
         -Plot result
         -Plot histogram

## Installation

Use the package manager [pip](https://pip.pypa.io/en/stable/) to install image_processingv777

```bash
pip install image_processingv777
```

## Usage

```python
from package_name.module1_name import file1_name
file1_name.my_function()
```

## Author
Claudio  nogueira 

## License
[MIT](https://choosealicense.com/licenses/mit/)
pytoolbelt-cli 0.6.5
A CLI tool to help teams share internal tooling written in python.
Requires Python: >=3.9

[![Blueprint fonts](https://see.fontimg.com/api/renderfont4/BWWo5/eyJyIjoiZnMiLCJoIjo4NywidyI6MTAwMCwiZnMiOjg3LCJmZ2MiOiIjMUNBN0ZGIiwiYmdjIjoiI0ZGRkZGRiIsInQiOjF9/UHl0b29sYmVsdA/typo-draft-demo.png)](https://www.fontspace.com/category/blueprint)

### Sharing python tooling within your organization, the easy way.

## What is Pytoolbelt?
Pytoolbelt is a CLI, intended to simplify creating and sharing python tools within your organization.
It treats a standard git repo as a `toolbelt`, which is a mono repo with all of your python tools you want to share within your organization.
It also allows your team to define one or more python environments (venv) that can be re-used for multiple tools, 
Tools are installed as a zipapp from source, which can be run globally from your terminal. 

## Why Pytoolbelt?
Python is a wonderful language for writing scripts and small tools, but sharing them within your organization can be a pain.
Navigating the python packaging ecosystem can be daunting, and creating a package for a simple script can be overkill. Not to mention that if you want to be able to `pip install` your tool, you need either to publish it to PyPi 
or to have a private package server (aka artifact repo), which is not always desirable or simply too much work.

Pytoolbelt aims to simplify this process by treating a git repo as a `toolbelt`. Installation is a simple as cloning the repo and running 
`pytoolbelt tool install --name <toolname>`, and the tool is installed as a zipapp, which can be run globally from your terminal.

## Documentation
Check out the full documentation at github pages [here](https://pytoolbelt.github.io/pytoolbelt-cli/)


## Getting Started
pytoolbelt can be installed via pip (venv creation recommended):
```bash
pip install pytoolbelt-cli
```

`pytoolbelt` is also intended to be installed globally if desired. If that is the case, It is recommended to be installed via `pipx`
```bash
pipx install pytoolbelt-cli
```
Pipx is a tool that can be considered a "homebrew" for tools written in python. More information on `pipx` can be found [here](https://pipx.pypa.io/stable/installation/)

### Initialize pytoolbelt
To initialize a new pytoolbelt project and add the required directories to your `$PATH`, run the following command:
```bash
pytoolbelt init --path
```
this will add the `~/.pytoolbelt/tools` directory to your `$PATH` in your `.bashrc` or `.zshrc` file.

### Video Tutorials
Head over to the pytoolbelt YouTube channel for video tutorials on how to use pytoolbelt:
[Pytoolbelt YouTube Channel](https://www.youtube.com/channel/UCRz_AcS2QLVIUvh2nfBWgRQ)


## License
This project is licensed under the Apache License 2.0 - see the [LICENSE](LICENSE) file for details.
mr-openai-module 0.1.1
A module for interacting with OpenAI using prompt.
Requires Python: >=3.7

# OpenAI Utils

![PyPI - Python Version](https://img.shields.io/pypi/pyversions/openai-utils)
![PyPI - License](https://img.shields.io/pypi/l/openai-utils)
![PyPI - Downloads](https://img.shields.io/pypi/dm/openai-utils)

**OpenAI Utils** is a simple, reusable Python module that makes it easy to interact with the OpenAI API. It provides utility functions for generating text completions, listing available models, and more. This package is designed for developers who want to integrate OpenAI's powerful language models into their applications with minimal setup.

## Features

- **Text Completion**: Generate text based on a prompt using various OpenAI models.
- **Model Listing**: Easily retrieve a list of available OpenAI models.
- **Customizable**: Adjust parameters like temperature, max tokens, and more to fit your needs.

## Installation

You can install the package directly from PyPI:

```bash
pip install mr_openai_module

## Usage

from mr_openai_module.openai_client import OpenAIClient

client = OpenAIClient(api_key="your_openai_api_key")
response = client.generate_text("Tell me a joke.")
print(response)
pattern-buffer 0.0.4
Fast pattern counting on small-alphabet sequences with GPU acceleration
Requires Python: >=3.8

# Pattern Buffer 🧮

Fast pattern counting on small-alphabet sequences with GPU acceleration, built on PyTorch.

Originally designed to count patterns in DNA sequences with ambiguous bases as defined by the [IUPAC code](https://www.bioinformatics.org/sms/iupac.html), but can be extended to any pattern counting task where the original sequences and target patterns can be converted into a sensible categorical encoding.

> [!NOTE]
> The preface of "small-alphabet" sequences is given as the additional memory used by categorical encoding grows with the number of unique values in the alphabet. With DNA and IUPAC encoding this is tractable because many of the codes represent combinations of DNA bases, so despite there being 15 DNA nucleotide codes we only need to embed in a vector of length 4 (A, C, G, T).

## Usage

`Pattern Buffer` can be used with a broadly functional or object-oriented (OO) interface, with the functional interface geared towards one-time use and the OO interface for use multiple times (i.e. file parsing or PyTorch DataLoaders).

To demonstrate, we'll first create some sample sequences and queries. As we're using IUPAC nucleotide sequences, we can use the provided `generate_iupac_embedding` function to provide the embedding tensor.

```python
from pattern_buffer import generate_iupac_embedding
sequences = [
    "AACGAATCAAAAT",
    "AACAGTTCAAAAATTAGT",
    "AGTTCGYGGA",
    "AACAAGATCAGGAAAGCTGACTTGATG",
]
query_seqs = ["AAA", "AGT", "AAACA", "AAR", "GYGGA"]
embedding = generate_iupac_embedding()
```

From here, we can use the function `count_queries` to count the queries in a single function
call:

```python
from pattern_buffer import count_queries
count_queries(sequences, queries, embedding)
# tensor([[0, 0, 0, 0, 0],
#         [3, 1, 0, 3, 0],
#         [0, 1, 0, 0, 1],
#         [1, 0, 0, 3, 0]])
```

or create an instance of the `PatternBuffer` class, and use the `.count` method to count occurrences in new sequences. This has the advantage of not re-calculating the query embeddings or the `support` tensor each time, so is well suited for fast repeated counting:

```python
from pattern_buffer import PatternBuffer
pb = PatternBuffer(query_strings=queries, embedding=embedding)
pb.count(sequences)
# tensor([[0, 0, 0, 0, 0],
#         [3, 1, 0, 3, 0],
#         [0, 1, 0, 0, 1],
#         [1, 0, 0, 3, 0]])
```

## Limitations

- If all of your patterns contain unique (non-ambiguous) characters then this encoding scheme is likely overkill and other software would be more efficient.
- The software is designed for use with GPU acceleration, and will likely under-perform on CPU when compared to CPU-optimised counting schemes.

## Future work

- [x] Allow dynamic input lengths with padding
- [ ] Automatic encoding detection from pattern analysis
- [ ] FFT-based convolutions for long patterns