semvec/pypi-packages huggingface dataset:
unique-picker 0.0.2
A package for unique random selection
Requires Python: >=3.6

# Unique Picker

Unique Picker is a Python package that allows you to randomly select an item from a list without repeating any item until all items in the list are covered. Once all items are selected, the list is reshuffled, and the process continues.

## Installation
You can install the package using pip:
```bash
pip install unique-picker
```

# Usage
Import the Package
```bash
import uniquePicker
```
# How to Use
Use the choice function to randomly select an item from a list:
```bash
data_list = [1, 2, 3, 4, 5]
for _ in range(10):
    print(uniquePicker.choice(data_list))

```
# Output
The choice function ensures that:
- No item is repeated until all items in the list are selected.
- After all items are used, the list is reshuffled for the next cycle.

Example Output:

```bash
css


3
5
1
4
2
(all items reshuffled)
4
3
2
5
1

```

# Features
- Random selection without immediate repetition.
- Automatic reshuffling after all items are covered.
- Easy-to-use API, just like Pythonâ€™s random.choice.

# Code Example
Hereâ€™s a complete working example:
```bash
import uniquePicker

# Define your list
data_list = ['apple', 'banana', 'cherry', 'date', 'elderberry']

# Select items
print("Random selections without repeats:")
for _ in range(10):
    print(uniquePicker.choice(data_list))

```
# How It Works
- The unique_picker.choice function internally uses a class to manage the list and its current state.
- It shuffles the list when all items are exhausted, ensuring fair and unique selection in cycles.

# License
This package is distributed under the MIT License. See the LICENSE file for details.
stepslist 0.7.5
A MkDocs extension to improve the visual of ordered lists.
Requires Python: >=3.6

<div align="center">

StepsList
=========================================

[![PyPI](https://img.shields.io/pypi/v/stepslist)](https://pypi.org/project/stepslist/)
![PyPI - Python Version](https://img.shields.io/pypi/pyversions/stepslist)
[![License](https://img.shields.io/github/license/a3bagged/stepslist-extension)](https://github.com/A3Bagged/stepslist-extension/blob/main/LICENSE.md)


**Extension for [Python-Markdown](https://python-markdown.github.io/): to be used on [Mkdocs](https://github.com/mkdocs/mkdocs) and [Material for Mkdocs](https://github.com/squidfunk/mkdocs-material)**


This Python package provides a custom Markdown extension that allows users to define step blocks in their Markdown documents. The extension recognizes specific markers and formats the enclosed content for better readability.

</div>

## Features
- Define step blocks using `--steps--` and `--!steps--` markers.
- Automatically wraps the content in a `<div>` with a class for custom styling.
- Easy integration with the existing Markdown parser.

## Installation
To use this extension, ensure you have the markdown library installed. You can install it using pip:
```bash
pip install markdown
```

You can install this package using pip:

```bash
pip install stepslist
```

## Usage
To use this extension, add it to your MkDocs configuration file (`mkdocs.yml`):

```
markdown_extensions:
  - stepslist
```
Now, you can use the `--steps--` `--!steps--` tag in your Markdown files:

> [!IMPORTANT]
> Note that you will need blank lines between the tags and your list otherwise it will not work!

### Markdown

```
--steps--

1. Step one
2. Step two
3. Step three

--!steps--
```
### Output example
This will be rendered as an ordered list within a div that you can style:

```
<div class="md-steps">
  <ol>
    <li>Step one</li>
    <li>Step two</li>
    <li>Step three</li>
  </ol>
</div>
```

### Styling
To style in `CSS` you need the following selectors:
You can also style the `::before` and `::after` pseudo elements.  
It's recommended to keep the `.md-steps` styling for the div itself unchanged unless you need to
```
.md-steps ol {
  /* Styling goes here */
}

.md-steps>ol>li {
  /* Styling goes here */
}

/* Optional */
.md-steps>ol>li::before {
  /* Styling goes here */
}

.md-steps>ol>li::after {
  /* Styling goes here */
}
```

<div align="center">

_If you like this extension consider buying me a :coffee:[coffee](https://ko-fi.com/cvanliere)._

</div>
agora-realtime-ai-api-v1 0.0.3
Agora's low latency, high performance Realtime API to work with Voice Conversational AI
Requires Python: >=3.10

## API Reference for `agora-realtime-ai-api` Python Package

### `RtcOptions` Class

The `RtcOptions` class represents the configuration options for an RTC (Real-Time Communication) session.

#### Constructor:
```python
RtcOptions(
    *,
    channel_name: str = None,
    uid: int = 0,
    sample_rate: int = 24000,
    channels: int = 1,
    enable_pcm_dump: bool = False
)
```
- **channel_name**: Name of the channel.
- **uid**: Unique identifier for the user.
- **sample_rate**: Sample rate for audio (default is 24,000 Hz).
- **channels**: Number of audio channels (default is 1).
- **enable_pcm_dump**: Flag to enable PCM audio dump (default is `False`).

### `AudioStream` Class

The `AudioStream` class represents an iterable stream of PCM audio frames.

#### Constructor:
```python
AudioStream()
```

#### Methods:
- `__aiter__() -> AsyncIterator[PcmAudioFrame]`: Async iterator to traverse through audio frames.
- `__anext__() -> PcmAudioFrame`: Returns the next audio frame in the queue.

---


### `Channel` Class

The `Channel` class handles the RTC channel and associated operations such as connection, audio subscriptions, and data stream messages.

#### Constructor:
```python
Channel(rtc: "RtcEngine", options: RtcOptions)
```

#### Methods:
- `connect() -> None`: Connects to the channel asynchronously.
- `disconnect() -> None`: Disconnects from the channel asynchronously.
- `get_audio_frames(uid: int) -> AudioStream`: Returns the audio stream for a specific user.
- `push_audio_frame(frame: bytes) -> None`: Sends a PCM audio frame to the channel.
- `clear_sender_audio_buffer() -> None`: Clears the audio buffer used for sending.
- `subscribe_audio(uid: int) -> None`: Subscribes to a user's audio stream.
- `unsubscribe_audio(uid: int) -> None`: Unsubscribes from a user's audio stream.
- `send_stream_message(data: str, msg_id: str) -> None`: Sends a data stream message to the channel.

---

### `ChatMessage` Class

Represents a chat message to be sent over the RTC channel.

#### Constructor:
```python
ChatMessage(message: str, msg_id: str)
```

---

### `Chat` Class

Handles the queue of chat messages and sends them over the RTC channel.

#### Constructor:
```python
Chat(channel: Channel)
```

#### Methods:
- `send_message(item: ChatMessage) -> None`: Sends a chat message.

---

### `RtcEngine` Class

The `RtcEngine` class initializes the Agora service and provides methods for managing RTC channels.

#### Constructor:
```python
RtcEngine(appid: str, appcert: str)
```

#### Methods:
- `create_channel(options: RtcOptions) -> Channel`: Creates an RTC channel with the given options.
- `destroy() -> None`: Destroys the RTC engine instance.

---