semvec/pypi-packages huggingface dataset:
fast-starter 0.1.0
A simple package to quickly set up a FastAPI project structure.
Requires Python: >=3.6

<<<<<<< HEAD
# Fast_Starter
a fast api project structurer
=======
# Fast Starter

A simple package to quickly set up a FastAPI project structure.

## Installation

You can install the package via pip:

```bash
pip install fast_starter
>>>>>>> 475bd97 (Initial commit)
vz-recommender 0.5.5
vz recommender package
Requires Python: >=3.5

# DeepRed

![Python Versions](https://img.shields.io/badge/python-3.6%7C3.7-brightgreen)
![PyTorch Versions](https://img.shields.io/badge/pytorch-1.10.0-brightgreen)
![Ray Versions](https://img.shields.io/badge/ray-1.13.0-brightgreen)
![PyPI Version](https://badge.fury.io/py/vz_recommender.svg)

## Developer Guide
This guide provides dev teams with the technical information needed to integrate DeepRed into their applications

## Code documentation
- The ever evolving deepred code is being documented extensively and is actively maintained below

## Our Demo Playground include some of the key features team developed for:
- Search
- GenAI Search
- Recommendation

## Latest News
- Our paper: Efficient Multi-Task Learning via Generalist Recommender has been accepted at the 32nd ACM International Conference on Information and Knowledge Management (CIKM 2023).
- Personalization AI team presented tech talk Large scale Pathways Recommender Systems (PaRS) at Verizon at Ray Summit 2023.

## More About DeepRed and Personalization AI
DeepRed is the monorepo for centralized Verizon AI service development.
Personalization AI(PZAI) is an centralized personalization framework for building end to end large-scale search & recommender systems. The use cases developed on top of personalization AI can seamless integrate to Verizon personalization ecosystem, scale out to the Verizon AI infrastructure, and measurement framework in the production environment.

Personalization AI provides end-to-end support for:
- Big Data ETL: feature extraction pipeline which matches same pipeline running in realtime environment
- Model Training: large scale distributed model training on Ray and Pytorch Lightning
- Serving: High performance model serving on seldon-core and Ray, support Python/Java/Scala API
- App: Full platform search & LLM application developed in Flutter


## Communication
* GitLab Issues: Please use gitlab issues to submit bug reports, feature requests, install issues, RFCs, thoughts, etc. 
* Slack: We have slack channels host a primary audience of moderate to experienced personalization engineers for general discussions and collaboration. If you need a slack invite, please contact luyang.wang@verizon.com

## Releases 
PZAI plans to adopt a 90-day release cycle (major releases), currently working in progress. Please let us know if you encounter a bug by filing an issue.
We appreciate all contributions. If you plan to contribute new features, bug fixes, or extensions to the core, please first open an issue and discuss the feature with us.
Sending a PR without discussion might end up resulting in a rejected PR because we might be taking the core in a different direction than you might be aware of.
gradio-modal 0.0.4
A popup modal component
Requires Python: >=3.8
Keywords: Modal, Popup, gradio-custom-component, gradio-template-Column


# `gradio_modal`
<a href="https://pypi.org/project/gradio_modal/" target="_blank"><img alt="PyPI - Version" src="https://img.shields.io/pypi/v/gradio_modal"></a>  

A popup modal component

## Installation

```bash
pip install gradio_modal
```

## Usage

```python
import gradio as gr
from gradio_modal import Modal

with gr.Blocks() as demo:
    with gr.Tab("Tab 1"):
        text_1 = gr.Textbox(label="Input 1")
        text_2 = gr.Textbox(label="Input 2")
        text_1.submit(lambda x:x, text_1, text_2)
        show_btn = gr.Button("Show Modal")
        show_btn2 = gr.Button("Show Modal 2")
        gr.Examples(
            [["Text 1", "Text 2"], ["Text 3", "Text 4"]],
            inputs=[text_1, text_2],
        )
    with gr.Tab("Tab 2"):
        gr.Markdown("This is tab 2")
    with Modal(visible=False) as modal:
        for i in range(5):
            gr.Markdown("Hello world!")
    with Modal(visible=False) as modal2:
        for i in range(100):
            gr.Markdown("Hello world!")
    show_btn.click(lambda: Modal(visible=True), None, modal)
    show_btn2.click(lambda: Modal(visible=True), None, modal2)

if __name__ == "__main__":
    demo.launch()

```

## `Modal`

### Initialization

<table>
<thead>
<tr>
<th align="left">name</th>
<th align="left" style="width: 25%;">type</th>
<th align="left">default</th>
<th align="left">description</th>
</tr>
</thead>
<tbody>
<tr>
<td align="left"><code>visible</code></td>
<td align="left" style="width: 25%;">

```python
bool
```

</td>
<td align="left"><code>False</code></td>
<td align="left">If False, modal will be hidden.</td>
</tr>

<tr>
<td align="left"><code>elem_id</code></td>
<td align="left" style="width: 25%;">

```python
str | None
```

</td>
<td align="left"><code>None</code></td>
<td align="left">An optional string that is assigned as the id of this component in the HTML DOM. Can be used for targeting CSS styles.</td>
</tr>

<tr>
<td align="left"><code>elem_classes</code></td>
<td align="left" style="width: 25%;">

```python
list[str] | str | None
```

</td>
<td align="left"><code>None</code></td>
<td align="left">An optional string or list of strings that are assigned as the class of this component in the HTML DOM. Can be used for targeting CSS styles.</td>
</tr>

<tr>
<td align="left"><code>allow_user_close</code></td>
<td align="left" style="width: 25%;">

```python
bool
```

</td>
<td align="left"><code>True</code></td>
<td align="left">If True, user can close the modal (by clicking outside, clicking the X, or the escape key).</td>
</tr>

<tr>
<td align="left"><code>render</code></td>
<td align="left" style="width: 25%;">

```python
bool
```

</td>
<td align="left"><code>True</code></td>
<td align="left">If False, component will not render be rendered in the Blocks context. Should be used if the intention is to assign event listeners now but render the component later.</td>
</tr>
</tbody></table>


### Events

| name | description |
|:-----|:------------|
| `blur` | This listener is triggered when the Modal is unfocused/blurred. |
censorship.py 0.16
Censorship Audio is a Python library that allows you to censor specific words in an audio file based on a given list of words.

<div align="center">
  <img height="100" src="censorship_logo.png"  />
  <h1>CENSORSHIP.PY</h1>
</div>

![Static Badge](https://img.shields.io/badge/open-source-green)
![Static Badge](https://img.shields.io/badge/version-0.16-blue)
![PyPI - Downloads](https://img.shields.io/pypi/dm/censorship-py)


Censorship Audio is a Python library that allows you to censor specific words in an audio file based on a given list of words. The library outputs a censored version of the input audio, replacing the specified words with a beep sound.

## Features

- **Audio Censorship:** Automatically censors a list of provided words in an audio file.
- **Text-to-Speech Integration:** Supports transcribing audio to text using [Faster-Whisper](https://github.com/guillaumekln/faster-whisper).
- **Customizable Word List:** You can easily add or modify the words you want to censor.



## Installation

```bash
pip install censorship.py
```

Make sure you have installed **ffmpeg** for audio processing.

Use this command if you have Linux or a subsystem (recommended)

```bash
sudo apt update && sudo apt install ffmpeg
```

Or install it on Windows using Chocolatey

```bash
choco install ffmpeg
```

## Usage

Here is an example of how to use the Censorship Audio library:

```python
from censorship import Censorship_Audio

if __name__ == "__main__":
    censorship = Censorship_Audio()  # Create an instance of the Censorship class
    censorship.censure_audio('audio_to_censure.mp3', 'censored_audio.mp3', ['word1', 'word2'])

    # Optional: Transcribe the censored audio to text
    audio_to_text = censorship.return_audio_text('censored_audio.mp3')
    print(audio_to_text)
```

## Changing Whisper Model Parameters
By default, Censorship Audio uses the large-v3 Whisper model with cpu as the device and int8 for the compute type. However, you can change these parameters based on your system's capabilities or model preferences.

You can check the differents types of models and parameter in the [faster-whisper documentation](https://github.com/guillaumekln/faster-whisper).

### Example

```python
# Create an instance with custom Whisper model parameters
# Run on GPU with FP16
censorship = Censorship_Audio(model_size='large-v2', device='"cuda"', compute_type='"float16"')
```

## Contributing

If you find a bug or have an idea for improvement, feel free to open an issue or submit a pull request. Contributions are always welcome!
eplremade2 1.0.0
Every Python Library Remade, a project to improve base Python modules and libraries.
Requires Python: >=3.10

# EPL Remade
Every Python Library Remade, is a project that aims to improve on the base python modules and libraries. Although still under the works, you may expect bit releases of the libraries in the future. The libraries will be released in the form of a package, and will be available on PyPi, GitHub and other platforms.

## Libraries
- [ ] `complexnum` - This is completely custom library that can be used for algebraic operations on complex numbers involving variables
- [ ] `rmath` - This is a direct improvement on the base python `math` module, with added functions and improvements
- [ ] `matrixop` - This is a custom library that can be used for matrix operations, including addition, subtraction, multiplication, division, etc.
- [ ] `rtype` - This is a custom library that can be used for type checking and type conversion, with added functions and improvements
- [ ] `rnetwork` - This is a custom library that can be used for network operations, including sending and receiving data, etc.
- [ ] `rfunctools` - This is a custom library that can be used for functional programming, with added functions and improvements
- [ ] `algorithms` - This is a custom library that can be used for algorithms, including sorting, searching, etc.
- [ ] `circuit` - This is a custom library that can be used for operations such as AND, OR, NOT, etc.
eplremade 1.0.0
Every Python Library Remade, a project to improve base Python modules and libraries.
Requires Python: >=3.10

# EPL Remade
Every Python Library Remade, is a project that aims to improve on the base python modules and libraries. Although still under the works, you may expect bit releases of the libraries in the future. The libraries will be released in the form of a package, and will be available on PyPi, GitHub and other platforms.

## Libraries
- [ ] `complexnum` - This is completely custom library that can be used for algebraic operations on complex numbers involving variables
- [ ] `rmath` - This is a direct improvement on the base python `math` module, with added functions and improvements
- [ ] `matrixop` - This is a custom library that can be used for matrix operations, including addition, subtraction, multiplication, division, etc.
- [ ] `rtype` - This is a custom library that can be used for type checking and type conversion, with added functions and improvements
- [ ] `rnetwork` - This is a custom library that can be used for network operations, including sending and receiving data, etc.
- [ ] `rfunctools` - This is a custom library that can be used for functional programming, with added functions and improvements
- [ ] `algorithms` - This is a custom library that can be used for algorithms, including sorting, searching, etc.
- [ ] `circuit` - This is a custom library that can be used for operations such as AND, OR, NOT, etc.