semvec/pypi-packages huggingface dataset:
diffrp-nvdiffrast 0.3.3.1
nvdiffrast - modular primitives for high-performance differentiable rendering
Requires Python: >=3.6

## Nvdiffrast &ndash; Modular Primitives for High-Performance Differentiable Rendering

![Teaser image](./docs/img/teaser.png)

**Modular Primitives for High-Performance Differentiable Rendering**<br>
Samuli Laine, Janne Hellsten, Tero Karras, Yeongho Seol, Jaakko Lehtinen, Timo Aila<br>
[http://arxiv.org/abs/2011.03277](http://arxiv.org/abs/2011.03277)

Nvdiffrast is a PyTorch/TensorFlow library that provides high-performance primitive operations for rasterization-based differentiable rendering.
Please refer to &#x261E;&#x261E; [nvdiffrast documentation](https://nvlabs.github.io/nvdiffrast) &#x261C;&#x261C; for more information.

## Licenses

Copyright &copy; 2020&ndash;2024, NVIDIA Corporation. All rights reserved.

This work is made available under the [Nvidia Source Code License](https://github.com/NVlabs/nvdiffrast/blob/main/LICENSE.txt).

For business inquiries, please visit our website and submit the form: [NVIDIA Research Licensing](https://www.nvidia.com/en-us/research/inquiries/)

We do not currently accept outside code contributions in the form of pull requests.

Environment map stored as part of `samples/data/envphong.npz` is derived from a Wave Engine
[sample material](https://github.com/WaveEngine/Samples-2.5/tree/master/Materials/EnvironmentMap/Content/Assets/CubeMap.cubemap)
originally shared under 
[MIT License](https://github.com/WaveEngine/Samples-2.5/blob/master/LICENSE.md).
Mesh and texture stored as part of `samples/data/earth.npz` are derived from
[3D Earth Photorealistic 2K](https://www.turbosquid.com/3d-models/3d-realistic-earth-photorealistic-2k-1279125)
model originally made available under
[TurboSquid 3D Model License](https://blog.turbosquid.com/turbosquid-3d-model-license/#3d-model-license).

## Citation

```
@article{Laine2020diffrast,
  title   = {Modular Primitives for High-Performance Differentiable Rendering},
  author  = {Samuli Laine and Janne Hellsten and Tero Karras and Yeongho Seol and Jaakko Lehtinen and Timo Aila},
  journal = {ACM Transactions on Graphics},
  year    = {2020},
  volume  = {39},
  number  = {6}
}
```
peleren 1.0.2
A simple WSGI server optimized for AI applications
Requires Python: >=3.6

# Peleren Optimized WSGI Server

An asynchronous, efficient, and developer-friendly WSGI server built with Python's asyncio. This server is optimized for high performance, security, and compliance with the WSGI specification, making it an excellent choice for developers looking to deploy WSGI applications.

## Table of Contents

- [Features](#features)
- [Requirements](#requirements)
- [Installation](#installation)
- [Quick Start](#quick-start)
- [Usage](#usage)
  - [Command-Line Arguments](#command-line-arguments)
  - [Running with SSL/TLS](#running-with-ssl-tls)
- [Configuration](#configuration)
- [Examples](#examples)
  - [Simple WSGI Application](#simple-wsgi-application)
  - [Simple Echo Application](#simple-echo-application)
- [Logging](#logging)
- [Contributing](#contributing)
- [License](#license)
- [Contact](#contact)
- [Acknowledgments](#acknowledgments)
- [Additional Information](#additional-information)
  - [Security Considerations](#security-considerations)
  - [Future Enhancements](#future-enhancements)
  - [FAQs](#faqs)
- [Testing](#testing)
- [Feedback](#feedback)

---

## Features

- **Asynchronous I/O with asyncio:** Efficiently handles a large number of simultaneous connections.
- **WSGI 1.0 Compliance:** Fully compliant with the WSGI specification, ensuring compatibility with WSGI applications.
- **SSL/TLS Support:** Optional SSL/TLS encryption for secure connections.
- **Caching Mechanism:** Built-in caching to optimize repeated requests.
- **Detailed Logging:** Uses Python's logging module for configurable logging levels.
- **Extensible:** Designed with extensibility in mind, allowing for future enhancements like middleware support.
- **Easy Configuration:** Command-line arguments for quick configuration without modifying the code.

---

## Requirements

- Python 3.7 or higher
- `asyncio` library (comes with Python 3.7+)
- SSL certificates (if using SSL/TLS)

---

## Installation

Clone the repository:

```bash
pip install peleren
```
denoisers 0.2.0
A package for training audio denoisers
Requires Python: >=3.9

# Denoisers

Denoisers is a denoising library for audio with a focus on simplicity and ease of use. There are two major architectures available for waveforms: WaveUNet which follows the [paper](https://arxiv.org/abs/1806.03185) and a custom UNet1D architecture similar to what you would see in diffusion models.

## Demo

[![Hugging Face Spaces](https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Spaces-blue)](https://huggingface.co/spaces/wrice/denoisers)

## Usage/Examples

```sh
pip install denoisers
```

### Inference

```python
import torch
import torchaudio
from denoisers import WaveUNetModel
from tqdm import tqdm

model = WaveUNetModel.from_pretrained("wrice/waveunet-vctk-24khz")

audio, sr = torchaudio.load("noisy_audio.wav")

if sr != model.config.sample_rate:
    audio = torchaudio.functional.resample(audio, sr, model.config.sample_rate)

if audio.size(0) > 1:
    audio = audio.mean(0, keepdim=True)

chunk_size = model.config.max_length

padding = abs(audio.size(-1) % chunk_size - chunk_size)
padded = torch.nn.functional.pad(audio, (0, padding))

clean = []
for i in tqdm(range(0, padded.shape[-1], chunk_size)):
    audio_chunk = padded[:, i:i + chunk_size]
    with torch.no_grad():
        clean_chunk = model(audio_chunk[None]).audio
    clean.append(clean_chunk.squeeze(0))

denoised = torch.concat(clean, 1)[:, :audio.shape[-1]]
```

### Train

```sh

train unet1d unet1d-24khz /data_root/

```

### Publish

```sh

publish model model_name /path/to/model

```
model-ELISA 0.1.3
A GUI to simulate the direct ELISA model

# model_ELISA
Creates a GUI which simulates the mechanisms of a direct Sandwich ELISA

An enzyme-linked immunosorbant assay or ELISA is used to identify and/or quantify proteins. Given its detection abilities, it is highly useful for diagnosing various diseases from immune system disorders to infections. There are multiple different varieties of ELISAs, however one of the most commonly used is the direct sandwich ELISA. In this method the antigen of choice binds to a capture antibody. The capture antibody - antigen complex then binds to another antibody, termed the detection antibody. The detection anitbody is linked to an enzyme. When a substrate is introduced, the enzyme on the detection antibody converts the substrate to a colorimetric product and the amount of signal is used to quantify the amount of antigen in the mixture. 

ELISA development and optimization requires researchers to perform benchtop experiments that are often cumbersome and necessitate many sequential experiments to determine the best concentrations and settings for each species. 

This tool allows the user to mimic the experimental results of a direct sandwich ELISA which can aide when deciding to choose initial species concentration, temperature conditions, and which reaction variables to adjust to obtain an optimal reaction time. 

The user inputs initial concentrations, kinetic constants, and overall reaction time. The output will a plot which shows the concentrations of the species overtime and it also denotes the minimum time to steady state.

## Setup
pip install model_ELISA

## Load GUI
<img width="454" alt="Screenshot 2024-12-05 at 7 59 24 PM" src="https://github.com/user-attachments/assets/41a1cc17-b765-42be-8898-76ed753cea18">

## Choose input parameters or select default parameters
<img width="455" alt="Screenshot 2024-12-05 at 7 59 52 PM" src="https://github.com/user-attachments/assets/b30bfb84-042c-4abf-b591-18429f263178">

## Run simulation
<img width="1100" alt="Screenshot 2024-12-05 at 8 00 29 PM" src="https://github.com/user-attachments/assets/07fe5d32-7e21-4094-90d5-efbe52d03ee1">

## Optional: Clear plot and input parameters, enter new parameters and re-run simulation
<img width="1097" alt="Screenshot 2024-12-05 at 8 00 50 PM" src="https://github.com/user-attachments/assets/b076f628-17d8-43a9-b70b-508835b2b9fd">
greenscale-ai 0.1.2
Python SDK for Greenscale AI
Requires Python: >=3.6

# Greenscale AI Python SDK

Python SDK for interacting with the Greenscale AI APIs.

## Installation

```bash
pip install greenscale-ai
```

## Usage

```python
from greenscale_ai import GreenscaleAI

# Initialize the SDK
app = GreenscaleAI()

# Scrape a URL
result = app.scrape_url("https://example.com")
```

## Free Trial vs API Key

### Free Trial

```python
# Free trial (no API key required)
app = GreenscaleAI()  # Uses default free trial key
result = app.scrape_url("https://example.com")
```

**Rate Limits**: Free trial is limited and shared across all users.

### Personal API Key

```python
# Using your personal API key
app = GreenscaleAI(api_key="your_api_key_here")
result = app.scrape_url("https://example.com")
```

**Rate Limits**: Personal API keys have more relaxed limits based on your subscription tier.

To get your personal API key, email us at hello@greenscale.ai

## Advanced Usage

You can customize the scraping behavior using optional parameters:

```python
# Example with all available parameters
params = {
    "formats": ["markdown", "html"],  # Output formats (default: ["markdown"])
    "include_metadata": True,         # Include page metadata (title, description, etc.)
    "include_menu_links": True        # Extract navigation menu links
}

result = app.scrape_url("https://example.com", params=params)
```

### Parameters Explanation:

- `formats`: List of desired output formats. Available options: "markdown" and "html"
- `include_metadata`: When True, returns page metadata like title, description, OpenGraph and custom tags
- `include_menu_links`: When True, extracts and returns navigation menu links from the page
colorich 0.6.5
Replace the classic print function with several colorful functions

# colorich
Python module - Use ANSI formatting to color output text by hexadecimal values, RGB values or by color specific name or decorate it

Use ANSI formatting to color output text by hexadecimal values, RGB values or by color specific name or decorate
it.\
The color names and values is inspired by https://www.w3schools.com/colors/colors_names.asp and
https://github.com/jonathantneal

Functions:\
expand - Expands the colors list, extra colors will be available if this function will be executed.

enrich - Return colored and decorated font for rgb values or for hex.\
e.g. print(enrich("SeaGreen", (45, 140, 85)), "\n")\
This example will color and print the text "<span style="color: #2d8c55">SeaGreen</span>" in the rgb color of (45, 140, 85) and start a new line.

dye - Only determine the foreground color of the font but can accept a dictionary of strings with their different colors values.\
e.g. print(dye({"Periwinkle ": "periwinkle ", "Iceberg ": "Ice berg", "and ": "", "Forest green\n": "Forest green"}))\
This example will color and print the text "<span style="color: #CCCCFF">Periwinkle</span> <span style="color: #71A6D2">Iceberg</span> and <span style="color: #5FA777">Forest green</span>" with several colors - every word will be colored with the color that is writen next to it, notice that the word "and" won't be colored because no color has been assigned to it.

printr - Prints the decorated colorized text that have sent as argument.\
e.g. printr("Bold Turquoise on MediumSlateBlue", (64, 224, 208), "#7B68EE", "B", "\n")\
This example will color, decorate and print the text "<span style="color: #45B5AA; background-color: #7B68EE; font-weight: bold;">Bold Turquoise on MediumSlateBlue</span>".\
As it says, (64, 224, 208) is the text color, #7B68EE is the background color, "B" makes it bold, and \n will start a new line.

printd - Prints text that have sent as an argument in multiple colors.\
e.g. printd("Red ; red", "Slate Blue ; slateBlue", "default color ", "and; Orange Red\n; OrangeRed")\
This example will color and print the text "<span style="color: red">Red</span> <span style="color: #6A5ACD ">Slate Blue</span> default color <span style="color: #FF4500 ">and; Orange Red</span>" with several colors and eventualy will start a new line, notice that the delimeter sign ";" only apllyed as a delimeter to the last time of it's use.

show - prints all the colors and decorations name available and how it looks like.

Examples are in the bottom of the main file.