semvec/pypi-packages huggingface dataset:
grad-tts 0.0.4
A fork of the official implementation of the Grad-TTS model.

# Grad-TTS

A fork of the [official implementation](https://github.com/huawei-noah/Speech-Backbones/tree/main/Grad-TTS) of the Grad-TTS model based on Diffusion Probabilistic Modelling. This fork cleans up the code to focus on easy installation and inference.



## Installation


## Inference
See `grad_tts_cli.py` for how to use the model for inference.
```bash
python grad_tts_cli.py \
    --file /PATH/TO/TEXT_FILE \
    --checkpoint /PATH/TO/GRAD_TTS_CHECKPOINT \
    --hifigan_checkpoint /PATH/TO/HIFIGAN_CHECKPOINT \
    --outdir /PATH/TO/OUTPUT_DIR
```

You can download [Grad-TTS](https://drive.google.com/file/d/1YrlswCD2Q_IUlvFtQQ-gnfkG7FEvRoPJ/view?usp=drive_link) and [HiFi-GAN](https://drive.google.com/file/d/15AeZO2Zo4NBl7PG8oGgfQk0J1PpjaOgI/view?usp=drive_link) checkpoints trained on LJSpeech. 

## References

* HiFi-GAN model is used as vocoder, official github repository: [link](https://github.com/jik876/hifi-gan).
* Monotonic Alignment Search algorithm is used for unsupervised duration modelling, official github repository: [link](https://github.com/jaywalnut310/glow-tts).
* Phonemization utilizes CMUdict, official github repository: [link](https://github.com/cmusphinx/cmudict).
valimail 0.1.4
A library for advanced email verification.

# ValiMail - Email Verification Library

ValiMail is a library designed for advanced and effective verification of email addresses.

## Features

- Verify the format and validity of email addresses.
- Detect if an email address exists in a leaked database.
- Support email domain verification.
- Support email comparison against a blacklist.
- Integration with popular email service providers.

## Installation

You can install the library using the following command:

```python
pip install valimail
```

## How To Use

# Import the library
```python
from valimail import vali_mail, check_domain_name, check_if_known,is_dispose_email
```

# Use library functions to check email addresses

```python
email = "example@email.com"
is_valid = vali_mail(email)
is_in_database = check_if_known(email)
is_valid_domain = check_domain_name(email)
is_dispose = is_dispose_email(email)
```
```python
# Print the results
print(f"Is valid email: {is_valid}")
print(f"Is in database: {is_in_database}")
print(f"Has valid domain: {is_valid_domain}")
print(f"Is blacklisted: {is_dispose}")
```

#Ihad Been Added The RealTime Examples in The File example.py


## Documentation

For detailed documentation and examples, please refer to the [official documentation](#).

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
micromodel 0.0.0
todo
Requires Python: >=3.11

# Micromodel

Static and runtime dictionary validation.

## Install

```sh
$ pip install micromodel
```

## Why

We had a HUGE Python code base which was using `pydantic` to provide a validation layer for MongoDB operations. The code was all messy but it worked fine, until we decided to switch the type checker config from "basic" to "strict", then over a thousand of dictionary-related errors popped up, not to mention the annoying conversions from `dict` to classes that were going on on every validation and that should be checked everytime.

We then decided to make this validation in-loco using a more vanilla approach with only `TypedDict`s. Now our dictionaries containing MongoDB documents are consistently dicts that match with the static typing.

## Usage

```python
import typing
from micromodel import model

Animal = typing.TypedDict('Animal', {
    'name': str,
    'specie': list[typing.Literal[
        'dog',
        'cat',
        'bird'
    ]]
})

# even another TypedDicts can be used!
Person = typing.TypedDict('Person', {
    'name': str,
    'age': int,
    'animal': Animal
})

m = model(Person, {
    'Animal': Animal
})

old_validate = m.validate
def new_validate(target: Person):
    new = target.copy()
    new['name'] = new['name'].capitalize()
    return validate(Person, typing.cast(typing.Any, new))

# hooks can be implemented using monkeypatching
m.validate = new_validate

result = m.validate({
    'name': 'joao',
    'animal': {
        'name': 'thor',
        'specie': [
            'dog',
            # 'turtle' (this would produce both static and runtime errors)
        ]
    }
})

"""
{
  "name": "Joao",
  "animal": {
    "name": "thor",
    "specie": [
      "dog"
    ]
  }
}
"""
print(result)
```

## License

This library is [MIT licensed](https://github.com/capsulbrasil/normalize-json/tree/master/LICENSE).
stapidoc 0.1.0
Static Page Inline Decoder of Choice
Requires Python: >=3.10

# stapidoc

v0.1.0  
©2023 Jonas Santoso

**sta**tic **p**age **i**nline **d**ecoder **o**f **c**hoice

## Install

```shell
pip install stapidoc
```

## Usage

```shell
stapidoc input_file
```

Resulting document is written to `stdout`.

Given a static HTML document ('source'), *stapidoc* creates another HTML document which contains the source as a [percent](https://datatracker.ietf.org/doc/html/rfc3986.html#section-2.1)‑and‑base64‑encoded string, along with an inline script that decodes this string and plugs the source's DOM on‑the‑fly upon loading.

The source's `<link>` elements are plugged into the resulting DOM's `<head>` separately in order for linked resources to load.

Tacit assumptions:
  - The source document is entirely static. There are no `<script>` elements in either head or body.
  - The source document uses UTF-8 encoding.
renput 0.0.4
Tab-completion for inputs
Keywords: tab,completion,auto-completion,tab-completion,input,modified input,windows,easy-to-use

<p align="center">
<img src="https://raw.githubusercontent.com/JaegerwaldDev/Renput/main/Renput_ReadMe.png" height="96px"/>
</p>
<h1 align="center">Renput</h1>
<h2 align="center">A simple Python library for Windows, which replaces the default input function in order to add the functionality to automatically complete an input using the tab key.</h2>
<p align="center">
<a href="https://github.com/JaegerwaldDev/Renput/blob/master/LICENSE">
    <img alt="GitHub license" src="https://img.shields.io/github/license/JaegerwaldDev/Renput">
</a>
<a href="https://github.com/JaegerwaldDev/Renput/stargazers">
    <img alt="GitHub stars" src="https://img.shields.io/github/stars/JaegerwaldDev/Renput">
</a>
<a href="https://github.com/JaegerwaldDev/Renput">
    <img alt="GitHub all releases" src="https://img.shields.io/github/downloads/JaegerwaldDev/Renput/total">
</a>
<a href="https://github.com/JaegerwaldDev/Renput">
    <img alt="GitHub all releases" src="https://img.shields.io/github/watchers/JaegerwaldDev/Renput">
</a>
</p>

# Features

## `input(prompt, auto_complete)`

- `prompt`: The prompt given to the user before the input line.
- `auto_complete`: A list of auto completions that get input when the `tab ↹` key is pressed

# Example of use
```py
from renput import *

auto_complete = [
    "apple",
    "banana",
    "cherry",
    "pineapple"
]

print("Enter the first few letters of apple, banana, cherry or pinapple,\nthen press tab to see the functionality of Renput:")
while True:
    input(auto_complete=auto_complete)
```

Please report any issues that you find when using the library, but only if you are on the newest version.
Optionally, you can report new issues on [my discord server](https://discord.gg/MRb8jQf9fU).
lame-helpers-for-opencv-on-vscode 0.0.10
Lame tools to practice with opencv on VScode in place of Jupyter Notebooks.
Keywords: opencv,vscode


The objects in this package are useful to practice with python opencv on VScode.

Generally, it is preferable to use Jupiter Notebook to practice with opencv.
This is because JN allows easy ways to manage and display images.
But in case one wants to do the practice with VScode instead of JN, here comes this library.

This is a 'lame' library because the code is not very efficient.
In particular, the function 'cyclical_drawing' might be very CPU and RAM consuming.