semvec/pypi-packages huggingface dataset:
card-shoe 0.0.4
A Python card shoe library for creating card shoes with multiple decks for blackjack and casino usage.
Requires Python: >=3.9

A Python card shoe library for creating card shoes with multiple decks for blackjack and casino usage.

Example usage:

```
from card_shoe import CardShoe

shoe = CardShoe()  # 1 deck
print(shoe.draw_card())
# will print a random card drawn
print(shoe.draw_card())
# will print a different card drawn

shoe = CardShoe(7)  # 7 decks for blackjack
shoe.shuffle()
print(shoe.draw_card())
# will print a random card
print(shoe.draw_card())
# can print the same card due to multiple decks
```
standard-playing-card 0.0.3
A Python module for creating French-suited standard playing card.
Requires Python: >=3.9

A Python module for creating French-suited standard playing card.

Example usage:

```
from standard_playing_card import Card

card = Card("2", "c")

print(card.get_rank())
# prints "2"

print(card.get_suit())
# prints "clubs"
```

`Card(rank, suit)` expects a string rank of the following values `"2", "3", "4", "5", "6", "7", "8", "9", "10", "jack", "queen", "king", "ace"`, and a string suit of the following values `"clubs", "diamonds", "hearts", "spades"` or their shortened version `"c", "d", "h", "s"`
amabase 0.0.1
A simple and flexible asset management application built upon the Django framework. Can also be used as a building block library for more complex applications.
Requires Python: >=3.9

Amabase
=======

A simple and flexible asset management application built upon the Django framework.

Can also be used as a building block library for more complex applications.

(**WORK IN PROGRESS**)


## Getting started

### Install

    pip install amabase

### Use as a standalone application

Just run the provided `amabase` command line application.

This will automatically detect missing dependencies (and propose to install them), manage its custom SQLite database, and run a local development web server:

    amabase web

Visit the local website at http://127.0.0.1:8000/. Default credentials for the local development web server:
- Username: your Linux or Windows username
- Password: `Debug123`

See available commands:

    amabase --help

### Use in another Django project

Replace `manage.py` by:

```py
#!/usr/bin/env python3
import os

from amabase import main

os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'myproject.settings')

main()
```

In your `settings.py` file, remove settings that you would like to be managed by Amabase (see [Amabase default settings](amabase/conf/default.py)).

It is possible and easier to remove all settings, so that everything is managed by Amabase, except the setting `APPS` which should indicate which applications should be added (otherwise, only infrastructure applications and `amabase.base` will be included).

If `DATABASES` is not provided, Amabase will create and use a custom SQLite database.


## Components

Infrastructure:
- `amabase.utils`: General-purpose shared utilities. Depends only on the Python standard library.
- `amabase.django`: Django-related utilities and infrastructure.
- `amabase.conf`: Shared Amabase configuration objects. Depends on Django only for Django-related features.
  Provides `settings`, a SQLite `db` and the `main` function to create the command-line interface.

Base application:
- `amabase.base`: The base Django application (this is the only Django application required by Amabase).

Other applications:
- TODO


## Contribute

Pull requests are welcome.

See [contributing guidelines](CONTRIBUTING.md).


## Credits

This project is licensed under the terms of the [MIT license](LICENSE.txt).

Logo by [Kristian Salonen - icons-for-free.com](https://icons-for-free.com/authentik-1329545813622522974/) (CC0-1.0 license).
Mathics3-Module-hello 9.0.1
Mathics3 Hello, World! module
Requires Python: >=3.10
Keywords: Mathematica, Wolfram, Interpreter, Shell, Math, CAS

This is a Mathics3 Python Module showing the classic "Hello, World!"
The purpose is to demonstrate how to write a Mathics3 Python Module which extends Mathics3 by adding a function, but written in Python.

You can also use this as a template to clone if you want to create your own Mathics3 Module.

To install in development mode (run code from the source tree):

::

   $ make develop


After installing inside Mathics3, you can load this using the
``LoadModule[]`` function.

Then the function ```Hello[]`` is available::

      $ mathicsscript
      In[1]:= LoadModule["pymathics.hello"]
      Out[1]= pymathics.hello

      In[2]:= Hello[]
      Out[2]:= Hello, World!

      In[2]:= Hello["everyone"]
      Out[2]:= Hello, everyone!

You can test with ``pytest``::

     $ pytest test

or simply::

     $ make check
pypricklybird 1.0.3
Python library to encode and decode pricklybird.
Requires Python: >=3.12

# pypricklybird

[![PyPI - Version](https://img.shields.io/pypi/v/pypricklybird.svg)](https://pypi.org/project/pypricklybird)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pypricklybird.svg)](https://pypi.org/project/pypricklybird)
[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
![GitHub License](https://img.shields.io/github/license/ndornseif/pypricklybird)

-----

## Overview 

[`pricklybird`](https://github.com/ndornseif/pricklybird) is a method for conversion of 
arbitrary binary data into more human-friendly words,  
where each word represents a single byte.  
A CRC-8 checksum is attached to allow the detection of errors during decoding.  
`0xDEADBEEF` becomes `turf-port-rust-warn-void`, for example.  

`pypricklybird` is a python implementation of `pricklybird` version `v1`.


## Documentation

Documentation is generated using [pdoc](https://pdoc.dev/) and can be found [here](https://ndornseif.github.io/pypricklybird/).

## Usage

Basic conversion functions that fully comply with the specification and 
include the CRC can be used as follows.

```python
>>> from pypricklybird import convert_to_pricklybird, convert_from_pricklybird
>>> data = bytearray.fromhex("4243")
>>> code = convert_to_pricklybird(data);
>>> code # Notice the third word "full" used to encode the CRC.
'flea-flux-full'
>>> convert_from_pricklybird(code).hex()
'4243'
```

It is also possible to map word to bytes and bytes to words without the 
full standard implementation and CRC.

```python
>>> from pypricklybird import words_to_bytes, bytes_to_words
>>> data = bytearray.fromhex("4243")
>>> words = bytes_to_words(data)
>>> words # Notice that no CRC is attached
['flea', 'flux']
>>> words_to_bytes(words).hex()
'4243'
```

Direct access to the `WORDLIST` used for mapping bytes to words, 
and the `HASH_TABLE` use to map words to bytes is also possible.

```python
>>> from pypricklybird import WORDLIST, HASH_TABLE, word_hash
>>> # Confirm that the word flux maps to the byte 0x43 in both directions.
>>> word = "flux"
>>> table_index = word_hash(word[0], word[-1]);
>>> table_index
603
>>> byte_value = HASH_TABLE[table_index]
>>> hex(byte_value)
'0x43'
```
## Installation

```console
pip install pypricklybird
```

## License

`pypricklybird` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.
py-autotune 0.0.1
Libreria Python per autotune su file audio.
Requires Python: >=3.8

# py-autotune

Libreria Python per correzione automatica dell’intonazione (autotune) su file audio.

## Installazione

```bash
pip install py-autotune
```

## Utilizzo rapido

```python
from py_autotune import autotune_audio

autotune_audio("input.wav", "output.wav", key="C major")
```

## Funzionalità
- Pitch detection (stima della frequenza fondamentale)
- Pitch shifting (modifica dell’intonazione)
- Correzione automatica verso la nota più vicina in una scala musicale
- API Python semplice e modulare

## API

### autotune_audio
```python
autotune_audio(input_path, output_path, key="C major")
```
Applica autotune a un file audio WAV.

### tuning
```python
tuning(data, sr, scale="chromatic")
```
Applica autotune a un array numpy.

## Esempio avanzato

```python
import soundfile as sf
from py_autotune.core import tuning

x, sr = sf.read("input.wav")
x_tuned = tuning(x, sr, scale="A minor")
sf.write("output.wav", x_tuned, sr)
```

## Scale supportate
- Maggiori, minori, cromatica

## Dipendenze
- numpy
- scipy
- soundfile

## Test
Esegui i test automatici:
```bash
pytest tests/
```

## Licenza
MIT