semvec/pypi-packages huggingface dataset:
easytranscriber 0.1.0
Speech recognition with accurate word-level timestamps.
Requires Python: >=3.10

<div align="center"><img width="1020" height="340" alt="image" src="https://github.com/user-attachments/assets/7f1bdf33-5161-40c1-b6a7-6f1f586e030b" /></div>


`easytranscriber` is an automatic speech recognition library built for efficient, large-scale transcription with accurate word-level timestamps. The library is backend-agnostic, featuring modular, parallelizable, pipeline components (VAD, transcription, feature/emission extraction, forced alignment), with support for both `ctranslate2` and `Hugging Face` inference backends. Notable features include:

* **GPU accelerated forced alignment**, using [Pytorch's forced alignment API](https://docs.pytorch.org/audio/main/tutorials/ctc_forced_alignment_api_tutorial.html). Forced alignment is based on a GPU implementation of the Viterbi algorithm ([Pratap et al., 2024](https://jmlr.org/papers/volume25/23-1318/23-1318.pdf#page=8)).
* **Parallel loading and pre-fetching of audio files** for efficient data loading and batch processing.
* **Flexible text normalization for improved alignment quality**. Users can supply custom regex-based text normalization functions to preprocess ASR outputs before alignment. A mapping from the original text to the normalized text is maintained internally. All of the applied normalizations and transformations are consequently **non-destructive and reversible after alignment**. 
* **35% to 102% faster inference compared to [`WhisperX`](https://github.com/m-bain/whisperX)**. See the [benchmarks](#benchmarks) for more details.
* Batch inference support for both wav2vec2 and Whisper models.

### Benchmarks

![Benchmarks](benchmarks/plots/all_speedup.png)
js-secret-santa 1.1.4
null
Requires Python: <4.0,>=3.13
Keywords: starter, template, python

# Secret Santa

## Steps to set up
1. Create a new repository in GitHub using this repository as a template
2. Generate Docker Hub PAT (Personal Access Token)
3. Create an [Environment in GitHub](https://docs.github.com/en/actions/managing-workflow-runs-and-deployments/managing-deployments/managing-environments-for-deployment#creating-an-environment) with the following secrets
   - DOCKER_USERNAME (Docker Hub username)
   - DOCKER_PASSWORD (Docker Hub PAT)
4. Create a Docker Hub repository with the same name as the GitHub repository
5. Update `assignees` in `renovate.json` with your GitHub username
6. Set up code-cove and make sure it has access to this repository
   - https://docs.codecov.com/docs/quick-start
7. Setup branch protection rules
   - Set `Enrforcment Status` to `Enabled`
   - Make sure `Target branches` set to `main` or default branch
   - Ensure these `Branch rules` are selected
     - `Restrict deletions`
     - `Require status checks to pass` with these checks
       - `Lint`
       - `Test`
     - `Block force pushes`
8. Create a PyPi `Trusted Publisher`
   - https://pypi.org/manage/account/publishing/
9. Ensure the name in `pyproject.toml` matches the name of the package on PyPi
10. Make sure the following linters are installed externally of the project
    - yamllint
    - shellcheck
    - shfmt
    - node (npx/dclint)

## TODO
- [X] Handle GitHub pre-release
- [X] Update PYTHONPATH with src folder
- [X] Add custom user to Dockerfile
- [ ] Fix Dockerfile
- [ ] Fix health check
- [ ] Fix version number
js-web-scraper 1.2.4
Customizable Web Scrapper to get alerts when criteria is met on web sites.
Requires Python: <4.0,>=3.13
Keywords: starter, template, python

# WebScraper
* This program can scrap data from websites using different scrapers, and send an email when 
matches/ changes deadening on the scraper used
* There are 2 types of scrapers:
    - Generic: Can scrap any website, but might not be as exact
    - Specific: Can scrap only specific websites, but will be more exact

## Generic Scrapers
 - Text
 - Diff

## Specific Scrapers
 - Cars.com

## How to use
### Text
1. Set these specific env variables
2. ```dotenv
    SCRAPER=text # Scraper to use
    URL=<URL> # URL to scrape
    TEXT=<TEXT> # Text to look for
   ```
3. Ensure all other required env variables are set

### Diff
1. Set these specific env variables
2. ```dotenv
    SCRAPER=diff # Scraper to use
    URL=<URL> # URL to scrape
    PERCENTAGE=<PERCENTAGE_DIFF> # Percentage difference to look for
   ```
3. Ensure all other required env variables are set

### Cars.com
1. Set these specific env variables
2. ```dotenv
    SCRAPER=cars_com # Scraper to use
    URL=https://www.cars.com/shopping/results/ # URL to scrape, must be on the results page, for a specific search
   ```
3. Ensure all other required env variables are set

### Required env variables
```dotenv
SLEEP_TIME_SEC= # Time to sleep between each scrape
SENDER_EMAIL= # Email to send from
FROM_EMAIL= # Name to send from i.e. '"Web Scraper" <no-reply@jstockley.com>'
RECEIVER_EMAIL= # Email to send to
PASSWORD= # Password for the sender's email
SMTP_SERVER= # SMTP server to use
SMTP_PORT= # SMTP port to use
TLS= # True/False to use TLS
```

### Running multiple of the same scraper
To run 2+ scrapers of the same type, i.e. 2 `diff` scrapers, make sure the host folder mapping is different
Ex:
```yaml
  diff-scraper-1:
    image: jnstockley/web-scraper:latest
    volumes:
      - ./diff-scraper-1-data/:/app/data/
    environment:
      - TZ=America/Chicago
      - SCRAPER=diff
      - URL=https://google.com
      - PERCENTAGE=5
      - SLEEP_TIME_SEC=21600

  diff-scraper-2:
    image: jnstockley/web-scraper:latest
    volumes:
      - ./diff-scraper-2-data/:/app/data/
    environment:
      - TZ=America/Chicago
      - SCRAPER=diff
      - URL=https://yahoo.com
      - PERCENTAGE=5
      - SLEEP_TIME_SEC=21600
```
seastartool 0.11
The Sea-faring System for Tagging, Attribution and Redistribution (SeaSTAR) is a GUI and CLI application for processing biodiversity data collected at sea.
Requires Python: >=3.7

![SeaSTAR Logo](seastar-logo-text.png)

SeaSTAR (Sea-faring System for Tagging, Attribution and Redistribution) is a CLI and GUI application for processing biodiversity data collected at sea.

## Use cases
Currently SeaSTAR focuses on processing data collected on the IFCB instrument. It has functionality for interactions with EcoTaxa and CRAB.

## How to install and use
```
$ pip install seastartool
Collecting seastartool
  Downloading seastartool-0.1-py3-none-any.whl.metadata (1.1 kB)
[...]
Successfully installed seastartool-0.1

$ seastar ifcb_v4_features -i testdata/*.hdr -o testout/
```
gpiod-sysfs-proxy 0.1.4
User-space compatibility layer for linux GPIO sysfs interface
Requires Python: >=3.6.0

<!-- SPDX-License-Identifier: MIT -->
<!-- SPDX-FileCopyrightText: 2024 Bartosz Golaszewski <bartosz.golaszewski@linaro.org> -->

# gpiod-sysfs-proxy

[libgpiod](https://git.kernel.org/pub/scm/libs/libgpiod/libgpiod.git/)-based
compatibility layer for the linux GPIO sysfs interface.

It uses [FUSE](https://www.kernel.org/doc/html/v6.3/filesystems/fuse.html)
(Filesystem in User Space) in order to expose a filesystem that can be mounted
over `/sys/class/gpio` to simulate the kernel interface.

## Running

Running the script with a mountpoint parameter will mount the simulated gpio
class directory and then exit. The script can also be run with `-f` or `-d`
switches for foreground or debug operation respectively.

The recommended command-line mount options to use are:

```
gpiod-sysfs-proxy <mountpoint> -o nonempty -o allow_other -o default_permissions -o entry_timeout=0
```

This allows to mount the compatibility layer on non-empty `/sys/class/gpio`,
allows non-root users to access it, enables permission checks by the kernel
and disables caching of entry stats (for when we remove directories from the
script while the kernel doesn't know it).

For a complete list of available command-line options, please run:

```
gpiod-sysfs-proxy --help
```

## Caveats

Due to how FUSE works, there are certain limitations to the level of
compatibility we can assure as well as some other issues the user may need
to have to work around.

### Non-existent `/sys/class/gpio`

If the GPIO sysfs interface is disabled in Kconfig, the `/sys/class/gpio`
directory will not exist and the user-space can't create directories inside
of sysfs. There are two solutions: either the user can use a different
mountpount or - for full backward compatibility - they can use overlayfs on
top of `/sys/class` providing the missing `gpio` directory.

Example:

```
mkdir -p /run/gpio/sys /run/gpio/class/gpio /run/gpio/work
mount -t sysfs sysfs /run/gpio/sys
mount -t overlay overlay -o lowerdir=/run/gpio/sys/class,upperdir=/run/gpio/class,workdir=/run/gpio/work,ro
gpiod-sysfs-proxy /sys/class/gpio <options>
```

### Links in `/sys/class/gpio`

The kernel sysfs interface at `/sys/class/gpio` contains links to directories
living elsewhere (specifically: under the relevant device entries) in sysfs.
For obvious reasons we cannot replicate that so, instead we expose actual
directories representing GPIO chips and exported GPIO lines.

### Polling of the `value` attribute

We currently don't support multiple users polling the `value` attribute at
once. Also: unlike the kernel interface, reading from `value` will not block
after the value has been read once.

### Static GPIO base number

Some legacy GPIO drivers hard-code the base GPIO number. We don't yet support
it but it's planned as a future extension in the form of an argument that will
allow to associate a hard-coded base with a GPIO chip by its label.

## Similar projects

* [sysfs-gpio-shim](https://github.com/info-beamer/sysfs-gpio-shim), written in
C. Officially only supports Raspberry Pi.
email-to-calendar 1.0.7
Takes emails from an IMAP server, parses the body, and creates event(s) in a CalDAV calendar
Requires Python: <4.0,>=3.13
Keywords: starter, template, python

# E-Mail to calendar Converter
The point of this application is to search an IMAP account, look for emails based on certain criteria(s), and parse 
the content, using regex, and automatically create calendar events in an iCal account.

## TO-DO
- [X] Get e-mails, and save ID to sqlite db to avoid duplicates
- [X] Save calendar events to sqlite db to avoid duplicates
- [X] Add config to backfill (check all emails from an optional certain date), or use most recent email
  - [X] If using most recent, when new email arrives, remove events not present, and add new ones
- [ ] If new email comes in with updated events, update event in calendar instead of creating a new one
- [ ] Using email summary check for words like `Cancelled`, etc. to delete events
- [ ] If event already exists, check if details have changed, and update if necessary
- [ ] Investigate IMAP IDLE (push instead of poll)
- [X] Make sure all day events are handled correctly
- [ ] Add Docker Model Runner support
- [ ] Add 'validate' function for events, and if it fails, have AI re-process that event


## Environment Variables
| Name | Description | Type | Default Value | Allowed Values |
|------|-------------|------|---------------|----------------|
|      |             |      |               |                |
|      |             |      |               |                |
|      |             |      |               |                |
ds-protocol-http-py-lib 0.1.0b2
A Python package from the ds-protocol library collection
Requires Python: >=3.11
Keywords: ds, protocol, python

# ds-protocol-http-py-lib

A Python package from the ds-common library collection.

## Installation

Install the package using pip:

```bash
pip install ds-protocol-http-py-lib
```

Or using uv (recommended):

```bash
uv pip install ds-protocol-http-py-lib
```

## Quick Start

```python
from ds_protocol_http_py_lib import __version__

print(f"ds-protocol-http-py-lib version: {__version__}")
```

## Usage

<!-- Add usage examples here -->

```python
# Example usage
import ds_protocol_http_py_lib

# Your code examples here
```

## Requirements

- Python 3.11 or higher

## Documentation

Full documentation is available at:

- [GitHub Repository](https://github.com/grasp-labs/ds-protocol-http-py-lib)
- [Documentation Site](https://grasp-labs.github.io/ds-protocol-http-py-lib/)

## Development

To contribute or set up a development environment:

```bash
# Clone the repository
git clone https://github.com/grasp-labs/ds-protocol-http-py-lib.git
cd ds-protocol-http-py-lib

# Install development dependencies
uv sync --all-extras --dev

# Run tests
make test
```

See the [README](https://github.com/grasp-labs/ds-protocol-http-py-lib#readme)
for more information.

## License

This package is licensed under the Apache License 2.0.
See the [LICENSE-APACHE](https://github.com/grasp-labs/ds-protocol-http-py-lib/blob/main/LICENSE-APACHE)
file for details.

## Support

- **Issues**: [GitHub Issues](https://github.com/grasp-labs/ds-protocol-http-py-lib/issues)
- **Releases**: [GitHub Releases](https://github.com/grasp-labs/ds-protocol-http-py-lib/releases)