semvec/pypi-packages huggingface dataset:
github-rest-cli 1.0.3
GitHub REST API cli
Requires Python: >=3.11.5

# GitHub REST API

## Installation

Install using `pip`:
```shell
pip install github-rest-cli
```

Install using `uv`:
```shell
uv pip install github-rest-cli
```

## Usage

Set up python package dependencies in `pyproject.toml`:
```shell
uv sync
```

After sync the project, activate virtualenv in `.venv` directory:
```shell
source .venv/bin/activate
```

To list all installed packages, run:
```shell
uv pip list
```

Export your **GitHub PAT** as environment variable:
```shell
export GITHUB_AUTH_TOKEN="<github-auth-token>"
```

Run cli:
```shell
github-rest-cli -v
```

### Dynaconf

This python cli app uses dynaconf to manage secrets and environment variables.

So that you can use your secrets and environment variables declared in `settings.toml` or `.settings.toml`, use the `GITHUB` prefix value of `envvar_prefix` declared in config.py.

List all defined parameters:
```shell
just dl
```

Validate all defined parameters:
```shell
just dv
```

**NOTE:** To run dynaconf validate `dynaconf_validators.toml` should exist.

### Ruff

Run lint:
```shell
just lint
```

Run format:
```shell
just fmt
```
skill-markII-audio-receiver 0.1.1a1
Neon.AI Mark 2 Skill for Audio Receiving - Bluetooth, Airplay, KDE Connect, Raspotify
Keywords: Neon devicecontrol spotify kdeconnect airplay bluetooth mark2 audio cast

# skill-mark2-audio-receiver

## About

This skill enables voice intents for the following audio receiver options on the Mycroft Mark 2 device:

- Airplay (via [UxPlay](https://github.com/FDH2/UxPlay))
- [KDE Connect](https://kdeconnect.kde.org/)
- Spotify (via [Raspotify](https://dtcooper.github.io/raspotify/))
- Bluetooth

It allows you to:

- Get the status of any of these services on the Mark 2
- Enable/disable the services
- Rename your devices in Airplay/Raspotify
- Pair Bluetooth/KDE Connect with other devices

Supported in Neon versions after mid-August (TODO: Specific version when it's available)

Requires [neon-phal-plugin-audio-receiver](https://github.com/NeonGeckoCom/neon-phal-plugin-audio-receiver), an admin PHAL plugin that handles the portions of the code that require `sudo`.

## Examples

- "Is bluetooth enabled?"
- "Is airplay enabled?"
- "Is Spotify enabled?"
- "Is KDE Connect enabled?"
- "Disable airplay"
- "Deactivate bluetooth"
- "Enable KDE Connect"
- "Activate Spotify"
- "Rename Airplay device"
- "Rename Spotify device"
- "Pair Bluetooth"
- "Pair KDE Connect"

## Credits

[Mike Gray](mike@graywind.org)

## Category

Device Control

## Tags

#Neon #devicecontrol #spotify #kdeconnect #airplay #bluetooth #mark2 #audio #cast
seqtok 0.1.0a1
A Python implementation mimicking C's `strtok()` behavior for generic sequences, but without global state.
Requires Python: >=2

# Sequence Tokenizer (seqtok)

A Python implementation mimicking C's `strtok()` behavior for generic sequences, but without global state.

## Features

- Splits any sequence type (lists, tuples, strings) using separator elements
- Memory efficient (yields tokens one at a time)
- Follows C's `strtok()` conventions:
  - Skips leading/trailing separators
  - Treats consecutive separators as single delimiter
  - Never returns empty tokens
- But with crucial differences:  
  - State is encapsulated in the generator instance (no global state)
    - No thread safety concerns from global state
  - Each iterator maintains independent state (safe for separate instances)
    - Multiple tokenizers can operate simultaneously
  - Original sequence is never modified
  - Immutable tokens via COWList (Copy-On-Write List)

## Installation

```bash
pip install seqtok
```

## Examples

```python
from seqtok import seqtok

# Tokenize a list of numbers
numbers = [1, 2, 0, 3, 4, 0, 0, 5]
for token in seqtok(numbers, {0}):
    print(token)
# Output: COWList([1, 2])
#         COWList([3, 4])
#         COWList([5])

# Tokenize a string
text = "..Hello...world.!"
for token in seqtok(text, {'.', '!'}):
    print(''.join(token))
# Output: Hello
#         world
```

## Contributing

Contributions are welcome! Please submit pull requests or open issues on the GitHub repository.

## License

This project is licensed under the [MIT License](LICENSE).
gf180mcu 0.4.0
GlobalFoundries 180nm MCU
Requires Python: <3.14,>=3.11
Keywords: python

# gf180mcu 0.4.0

GlobalFoundries 180nm MCU based on [Google open source PDK](https://github.com/google/globalfoundries-pdk-libs-gf180mcu_fd_pr)

This is a pure python implementation of the PDK.

> **NOTE**: If you were previously using the `gf180` package, it has been renamed to `gf180mcu` and the original package is now deprecated. See the [migration guide](https://gdsfactory.github.io/gf180mcu/migration.html) for more information.

## Installation

We recommend `uv`

```bash
# On macOS and Linux.
curl -LsSf https://astral.sh/uv/install.sh | sh
```

```bash
# On Windows.
powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"
```

### Installation for users

Use python 3.11, 3.12 or 3.13. We recommend [VSCode](https://code.visualstudio.com/) as an IDE.

```
uv pip install gf180mcu --upgrade
```

Then you need to restart Klayout to make sure the new technology installed appears.

### Installation for contributors

For developers you need to `git clone` the GitHub repository, fork it, git add, git commit, git push and merge request your changes.

```
git clone https://github.com/gdsfactory/gf180mcu.git
cd gf180
uv venv --python 3.11
uv sync --extra docs --extra dev
```

## Documentation

- [gdsfactory docs](https://gdsfactory.github.io/gdsfactory/)
wikiscraper-py 0.0.3
A Python library to scrape Wikipedia articles easily
Requires Python: >=3.9

# WikiScraper

WikiScraper is a professional Python library to scrape Wikipedia articles easily. It allows you to scrape a single page or all linked articles recursively, supporting both `.txt` and `.csv` outputs.

## Features

- Scrape a single Wikipedia page or all linked articles recursively.
- Supports `.txt` and `.csv` output formats.
- Optionally add titles to scraped content.
- Logging options for file saves and all actions.
- Append all scraped articles into a single file or save separately.
- Handles multiple languages and errors gracefully.
- Polite crawling with configurable delay between requests.

## Installation

```bash
pip install wikiscraper-py
```

## Usage

### Scrape a single page

```python
from wikiscraper import WikiScraper

scraper = WikiScraper(file_type="txt", add_title=True)
scraper.scrape_one("https://en.wikipedia.org/wiki/Python")
```

### Scrape all linked articles

```python
from wikiscraper import WikiScraper

scraper = WikiScraper(file_type="txt", add_title=True, all_on_one_file=True, polite_time=2)
scraper.scrape_all("https://en.wikipedia.org/wiki/Python")
```

### CSV Output Example

```python
from wikiscraper import WikiScraper

scraper = WikiScraper(file_type="csv", add_title=True, all_on_one_file=True)
scraper.scrape_all("https://en.wikipedia.org/wiki/Ethiopia")
```

- If `add_title=True` and output is CSV:
  - The first column will contain the article title.
  - The second column will contain the article text.

## Parameters

- `file_type`: `'txt'` or `'csv'`. Default is `'txt'`.
- `add_title`: Add the article title at the top of the file or first CSV column. Default is `False`.
- `log_saving`: Log only file saves. Default is `True`.
- `log_all`: Log all actions including errors and skipped links. Default is `False`.
- `polite_time`: Delay between requests in seconds. Default is `3`.
- `all_on_one_file`: Append all articles into a single file when scraping multiple pages. Default is `True`.

## Directory Structure

Scraped files are saved in the `data/` folder created automatically in the working directory.

- If `all_on_one_file=True`: all articles are appended to `data/wikipedia_all.txt` or `.csv`.
- If `all_on_one_file=False`: each article is saved as a separate file with its title as filename.

## Error Handling

- Skips invalid Wikipedia URLs.
- Logs network errors and pages without titles.
- Automatically filters out non-article links (categories, special pages, user pages, etc.).

## License

MIT License
HoloWave 0.1.1
Modern Sound manager for modern AI-driven applications.
Requires Python: >=3.10
Keywords: AI, Agents, Speech Recognition, Productivity, Automation

﻿
---

# HoloWave

## Overview

**HoloWave** is a modern, thread-safe audio playback manager for Python applications.
It provides robust, low-latency sound signaling, channel management, and cross-platform fallbacks for automation, agent systems, and productivity tools.

**Highlights:**

* **Low-latency sound playback:** Instantly play any supported audio file with minimal delay.
* **Thread-safe singleton:** Designed for multi-threaded, interactive, or automated applications.
* **Custom sound mapping:** Associate sounds with keys or events for rapid notification and feedback.
* **Automatic cross-platform fallback:** Produces a system beep if audio hardware or files are unavailable.
* **Flexible channel management:** Control mixer channels, output routing, and concurrency with ease.

---

## Why HoloWave?

Standard sound modules are often limited to blocking playback, lack robust error handling, or require boilerplate for channel management.

**HoloWave** solves these problems by:

* Providing a **centralized, extensible interface** for all sound playback.
* Robust error handling and fallback signaling on any OS.
* Supporting channel-based playback for overlapping or grouped sounds.
* Ensuring safe operation in multi-threaded or interactive environments.

---

## Key Features

* **Simple Sound Playback:**
  Play any loaded audio file by key, with non-blocking channel control.

* **Cross-Platform Support:**
  Uses `pygame` for playback, with built-in system beep fallback.

* **Custom Sound Mapping:**
  Map sound files to any integer or string keys for quick event-driven playback.

* **Thread-Safe Singleton:**
  Safe to use across threads or in long-running service applications.

* **Robust Error Handling:**
  Handles missing files, mixer errors, and hardware issues gracefully.

---

## How It Works

1. **Instantiate HoloWave** in your Python application.
2. **Map sounds to keys or events** in your app logic.
3. **Trigger playback** by calling `getSound(key)` from any thread or event handler.
4. **Automatically falls back** to system beep if playback fails.

---

## FAQ

**Q: Does HoloWave require a specific folder or class naming?**
A: No. Organize your project and sound files as you see fit.

**Q: Can I use HoloWave for overlapping or concurrent sounds?**
A: Yes. Channel management allows for multiple simultaneous sounds.

**Q: Is HoloWave thread-safe and production-ready?**
A: Yes. The singleton implementation and locking ensure safe use in all environments.

---

## Code Examples

You can find code examples on my [GitHub repository](https://github.com/TristanMcBrideSr/TechBook).

---

## License

This project is licensed under the [Apache License, Version 2.0](LICENSE).
Copyright 2025 Tristan McBride Sr.

---

## Acknowledgments

Project by:
- Tristan McBride Sr.
- Sybil
audiosnatch 0.3.2
An Audiobook downloader for goldenaudiobooks and sharedaudiobooks.
Requires Python: >=3.8


# Audio Snatch

This Python cli tool allows you to download audiobooks from multiple websites.

## Table of contents
- [Supported Websites](#supported-websites)
- [Installation](#installation)
- [Usage/Examples](#usageexamples)
- [Acknowledgements](#acknowledgements)


## Supported Websites

- [Golden Audiobooks](https://goldenaudiobooks.club/)
- [Shared Audiobooks](https://sharedaudiobooks.net/)
- [HD Audiobooks](https://hdaudiobooks.net/)
- [Find Audiobook](https://findaudiobook.club/)
- [Bag of Audio](https://bagofaudio.com/)
- [Big Audiobooks](https://bigaudiobooks.club/)
- [Full Length Audiobooks](https://fulllengthaudiobooks.net/)
- [Prime Audiobooks](https://primeaudiobooks.club/)

## Installation

To install this project on your machine, you can use one of the following methods:

### Recommended: Using pipx

```bash
pipx install audiosnatch
```
### Using pip

```bash
pip install audiosnatch
```

### To get the latest: From the repository 

```bash
pip install git+https://github.com/rozari0/AudioSnatchCLI.git
```
## Usage/Examples

### Download in current folder


```bash
audiosnatch https://sharedaudiobooks.net/george-orwell-animal-farm-audiobook/
```

### Download in Another folder
```bash
audiosnatch -O ~/Music https://sharedaudiobooks.net/george-orwell-animal-farm-audiobook/
```
## Acknowledgements
 - [Rich Click](https://github.com/ewels/rich-click)
 - [pypdl](https://github.com/mjishnu/pypdl)
ncalib 0.1.2
Modular Python Library for Neural Cellular Automata
Requires Python: >=3.9

# ncalib
A modular Python Library for handling Neural Cellular Automata.

## Features

- Modular architecture for Neural Cellular Automata
- Easy-to-use API for building and training NCA models
- Extensible framework for custom implementations


## Quickstart
### Installation

Install ncalib from PyPI using pip:

```bash
pip install ncalib
```
Some examples and loggers are using [Weights and Biases](https://wandb.ai/). To use them install the required dependencies using:
```bash
pip install ncalib[wandb]
```
### Examples
Examples are found in ``examples``. Currently there are following implementations:
- [simple_nca.py](/examples/simple_nca.py) - Original NCA reconstructing an image ([Mordvintsev et al. (2020)](https://distill.pub/2020/growing-ca/))
- [simple_classifying_mnist.py](/examples/self_classifying_mnist.py) - Self-classicying MNIST Digits ([Randazzo et al. (2020)](https://distill.pub/2020/selforg/mnist/) )
- [image_segmentation.py](/examples/image_segmentation.py)/[image_segmentation_hydra.py](/examples/image_segmentation_hydra.py) - NCA that can segment an image (with and without hydra) ([Sandler et al. (2020)](https://arxiv.org/abs/2008.04965))
- [genome_nca.py](/examples/genome_nca.py) - NCA that can be seeded with different genomes ([Stovold (2023)](https://arxiv.org/abs/2305.12971))


## Development

This project uses [uv](https://docs.astral.sh/uv/) for package management and distribution.

### Setup Development Environment

```bash
# Clone the repository
git clone https://github.com/dwoiwode/ncalib.git
cd ncalib

# Install dependencies with uv
uv sync

# Install extra dependencies
uv sync  --all-extras
```

### Running Tests

Tests are run using pytest:

```bash
uv run pytest tests
```

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

## Links

- [PyPI Package](https://pypi.org/project/ncalib/)
- [GitHub](https://github.com/dwoiwode/ncalib)
- [Issues](https://github.com/dwoiwode/ncalib/issues)