semvec/pypi-packages huggingface dataset:
NetHyTech-HindiTTS 1.1
Text To Speech In British Brian Voice
Requires Python: >=3.8

# Text-to-Speech (TTS) using Edge TTS and Pygame

This Python script provides a simple implementation of text-to-speech (TTS) using the Edge TTS API and Pygame library for audio playback.

## Requirements

- Python 3.11.4
- edge_tts module (for Edge TTS API)
- Pygame library

## Installation

1. Install the required modules:
    ```bash
    pip install NetHyTech-HindiTTS
    ```

## Usage

The `Speak` function in the script takes the text input and an optional output file path as arguments. If no output file path is provided, it saves the audio file as "speech.mp3" in the current directory.

Example usage:
```python
from NetHyTech_HindiTTS import Speak

text = "Hello, how are you?"
Speak(text, "output.mp3")  # Save audio to output.mp3
```

## Functionality

- The `Speak` function converts the input text to speech using the Edge TTS API and saves it to the specified output file.
- If no output file is provided, it saves the audio as "speech.mp3" in the current directory.
- The script handles the asynchronous operation using asyncio for better performance.
- Pygame is utilized for playing the generated audio file.

## Additional Notes

- Ensure you have valid credentials for the Edge TTS API and replace the `VOICE` variable with the desired voice.
- The `remove_file` function handles the removal of temporary files after audio playback.
- Error handling is implemented to catch any exceptions during the process.
bayesn 0.4.0
Hierarchical Bayesian modelling of type Ia SNe
Requires Python: >=3.10

# BayeSN

Hierarchical Bayesian SED modelling of type Ia supernova light curves

Developed and maintained by: Matt Grayling (@mattgrayling), Stephen Thorp (@stevet40), Gautham Narayan (@gnarayan), and 
Kaisey S. Mandel (@CambridgeAstroStat) on behalf of the BayeSN Team (@bayesn).

## About
BayeSN is a probabilistic optical-NIR SED model for type Ia supernovae, allowing for hierarchical analysis of the
population distribution of physical properties as well as cosmology-independent distance estimation for individual
SNe. This repository contains an implementation of the BayeSN SED model built with numpyro and jax, with support for 
GPU acceleration, as discussed in Grayling+2024 (`arXiv link <https://arxiv.org/abs/2401.08755>`, accepted by MNRAS).

## Installation and usage
BayeSN can be pip-installed via the command `pip install bayesn`. 

Detailed instructions on how to install and run the BayeSN model can be found here: https://bayesn.readthedocs.io/en/latest/index.html

## Support
Our goal with BayeSN is for the package to be clear and easy to use. If you find something unclear, come across any bugs
or think of any functionality that would add a lot of value for you, please raise a Github issue.

## Citing the code/model
If you utilise the BayeSN model in any way, please cite Mandel+2022 (MNRAS 510, 3, 3939-3966), and if you make use of
this code please cite Grayling+2024 (submitted to MNRAS). In addition, if you use any of the pre-trained models included
within BayeSN please cite the corresponding papers which present those models:

- M20 model: Mandel et al. 2022 (MNRAS 510, 3, 3939-3966)
- T21 model: Thorp et al. 2021 (MNRAS 508, 3, 4310-4331)
- W22 model: Ward et al. 2023 (ApJ 956, 2, 111)

## Things to note

### Filters

BayeSN includes a set of built-in filters for convenience, as detailed in the documentation. However, you can also add 
your own  filters through a yaml file to allow for new and updated filter responses to be used without needing a package
update.

### GPU Acceleration

This code has been designed with GPU acceleration in mind, and running on a GPU should yield a considerable (~100 times)
increase in performance. However, it is important to note that GPUs will show the most benefit running large scale jobs.
If you want to fit samples of 100s of SNe, the fit time per object will be considerably shorter than fitting just a 
handful. With only 1 object, you are likely better off running on CPU than GPU.

### Redshift requirement

At the present time, BayeSN is designed for use with spectroscopic redshifts, which are kept fixed during inference.
However, fitting with redshift as a free parameter based on a photometric redshift prior is feasible and planned in
future.
krypt 0.1.2
A helper tool for file encryption in Git repositories primarily aimed at encrypting Kubernetes secrets and other sensitive information to be later used in a CI/CD pipeline
Requires Python: >=3.8
Keywords: ci/cd pipeline, encryption, gitops, kubernetes, secrets

# Krypt: GitOps-friendly Secret Management for Kubernetes Clusters

Krypt is a tool designed to streamline secret management within Kubernetes cluster (and pretty much any other) configurations, particularly suited for GitOps workflows. It enables users to securely seal and unseal secrets within cluster configuration folders, ensuring sensitive information remains protected both in transit and at rest.

## Getting Started

To begin using Krypt, follow these simple steps:

1. **Initialization**: Initialize the cluster directory using the `krypt init` command. Provide a passphrase for encryption and specify the path to the cluster directory.
   
    ```bash
    krypt init --passphrase PASSPHRASE /path/to/cluster
    ```

2. **Sealing Secrets**: Seal the secrets within the cluster directory using the `krypt seal` command.

    ```bash
    krypt seal /path/to/cluster
    ```

3. **Commit and Push**: Once sealed, commit the changes to your Git repository and push them upstream. This ensures that the encrypted secrets are securely stored and version controlled.

4. **CI/CD Integration**: In your CI/CD pipeline, use the `krypt unseal` command to unseal the secrets before applying manifests onto the cluster. Pass the passphrase for decryption and specify the path to the cluster directory.

    ```bash
    krypt unseal --passphrase PASSPHRASE /path/to/cluster
    ```

## Usage Guidelines

- Only files with `.kpt.` in the name or those ending with `.kpt` are sealed by Krypt. Other files within the cluster directory remain stored in plaintext. This ensures that only intended secrets are encrypted while maintaining transparency for other configuration files.

- Krypt automatically adds files with `.kpt.` in the name or those ending with `.kpt` to .gitignore to ensure that plaintext secrets are not being committed to the repository.

- It's essential to securely manage and store the passphrase used for sealing and unsealing secrets. Consider using secure key management practices to protect this passphrase.

## Contributing

Contributions to Krypt are welcome! Feel free to open issues for bug reports, feature requests, or any questions you may have. Pull requests are also encouraged for those who would like to contribute directly to the project's development.

## License

Krypt is licensed under the [GPLv3 License](LICENSE), allowing for both personal and commercial use with proper attribution. Refer to the license file for detailed information.

## Acknowledgments

Krypt was inspired by the need for a secure and streamlined approach to managing secrets within Kubernetes clusters, particularly in GitOps workflows. We extend our gratitude to the open-source community for their contributions and support.

---

**Krypt** - Secure Secret Management for Kubernetes Clusters

For more information, visit [Krypt on GitHub](https://github.com/kubertools/krypt)
UnbreakableArmor-py 1.0.0
Encryption for Python scripts
Requires Python: >=3.6

# UnbreakableArmor

UnbreakableArmor is a Python tool for encrypting Python scripts.

## Installation

You can install UnbreakableArmor via pip:

```bash
pip install UnbreakableArmor


UnbreakableArmor filename.py



This version provides the necessary information for users to install the package and start using it without unnecessary details.