semvec/pypi-packages huggingface dataset:
gllm-generation-binary 0.2.11
A library containing generation related components in Gen AI applications.
Requires Python: <3.13,>=3.11

# GLLM Generation

## Description

A library containing generation related components in Gen AI applications.

## Installation

1. Python v3.11 or above:

You can install Python using [Miniconda](https://docs.anaconda.com/free/miniconda/index.html).

2. Make sure you're in the `base` conda environment:
```bash
conda activate
```

3. [Poetry](https://python-poetry.org/docs/) v1.8.1 or above:

You can install Poetry using cURL (you need Python to install Poetry):
```bash
curl -sSL https://install.python-poetry.org | python3 -
```

4. Install the library using Poetry:
```bash
# Latest
poetry add "git+ssh://git@github.com/GDP-ADMIN/gen-ai-internal.git#subdirectory=libs/gllm-generation"

# Specific version
poetry add "git+ssh://git@github.com/GDP-ADMIN/gen-ai-internal.git@gllm_generation-v0.0.1-beta.1#subdirectory=libs/gllm-generation"

# Specific Branch Name
poetry add "git+ssh://git@github.com/GDP-ADMIN/gen-ai-internal.git@<BRANCH NAME>#subdirectory=libs/gllm-generation"
```

5. At this step, you can deactivate Miniconda environment as Poetry will create and manage its own virtual environment for you.
```bash
conda deactivate
```

## Managing Dependencies
1. Go to root folder of `gllm-generation` module, e.g. `cd libs/gllm-generation`.
2. Run `poetry shell` to create a virtual environment.
3. Run `poetry lock` to create a lock file if you haven't done it yet.
4. Run `poetry install` to install the `gllm-generation` requirements for the first time.
5. Run `poetry update` if you update any dependency module version at `pyproject.toml`.


## Contributing
Please refer to this [Python Style Guide](https://docs.google.com/document/d/1uRggCrHnVfDPBnG641FyQBwUwLoFw0kTzNqRm92vUwM/edit?usp=sharing)
to get information about code style, documentation standard, and SCA that you need to use when contributing to this project

1. Activate `pre-commit` hooks using `pre-commit install`
2. Run `poetry shell` to create a virtual environment.
3. Run `poetry lock` to create a lock file if you haven't done it yet.
4. Run `poetry install` to install the `gllm-generation` requirements for the first time.
5. Run `which python` to get the path to be referenced at Visual Studio Code interpreter path (`Ctrl`+`Shift`+`P` or `Cmd`+`Shift`+`P`)
6. Try running the unit test to see if it's working:
```bash
poetry run pytest -s tests/unit_tests/
```
envguardx 0.2.0
CLI tool to validate .env files for safety and completeness
Requires Python: >=3.8

# 🛡️ envguardx

**envguardx** is a lightweight CLI tool for validating, inspecting, and generating `.env` and `.env.example` files — with support for optional schema validation.

---

## 🚀 Features

- ✅ Check for missing or empty env vars
- ⚠️ Detect unsafe or insecure values
- 🧪 Validate against a JSON schema
- 🧬 Generate `.env.example` from `.env`
- 🔧 Easy CLI usage with helpful output

---

## 📦 Installation

### ➤ Local Editable Install (Recommended for Dev)

```bash
pip install -e /absolute/path/to/envguardx
```

Replace /absolute/path/to/envguardx with the actual absolute path to your cloned or local project folder.

## 🧪 Usage

Once installed, you can run the CLI via:

```bash
envguardx --help
```

### ➤ Check an `.env` file

```bash
envguardx check .env
```

### ➤ Check an `.env` with a JSON Schema

```bash
envguardx check .env --schema schema.json
```

### Example `schema.json`

```json
{
  "API_KEY": "string",
  "DEBUG": "bool",
  "PORT": "int"
}
```

### ➤ Generate `.env.example` file from `.env`

```env
API_KEY=
DEBUG=
PORT=

```

## 📦 Bundling

### ➤ To build and deploy to package repo of choice (pypi)

Creat your `.pypirc` file

```config
[pypi]
username = __token__
password = <PyPI token>
```

```bash
python -m build
```

### To deploy

```bash
twine upload dist/*
```

It'll prompt you to log into your PyPI account (or you can pass -u USERNAME -p PASSWORD, or use an API token).
plotly-flex 0.1.0a2
Visualizing large datasets with plotly by using polars as backend.
Requires Python: <3.14,>=3.9
Keywords: big-data, visualization, plotly, plotly-dash, polars

# plotly-flex
Make plotly scalable - visualize large data with [plotly.py](https://github.com/plotly/plotly.py)!

This library aims to make plotly scalable by *aggregating data in the backend* before sending it to the frontend. This avoids loading all data into the frontend, which is how vanilla plotly works. This library is built on top of [polars](https://github.com/pola-rs/polars) to provide efficient data handling in the backend.


## Features

1. ⚡ **Making existing plotly traces scalable**
2. 🪄 **Aggregating data on events** (e.g. zooming, selection)  
    => support for cross-filtering
3. 🗃️ **Efficient handling of multiple lazyframes**

### Scalable Visualization Support

Overview of the supported trace types and their scalable support.
- Update on zoom = update the view when zooming in/out (e.g. by aggregating data)
- Update on selection (cross-filtering) = update the view when selecting related data (in another subplot)

| Plot Type  | Scalable Support | Update on Zoom | Update on Selection in other trace | Allow Selection |
|------------|------------------|----------------|---------------------|----------------|
| Scatter    | Supported        | Supported      | Supported           | Supported      |
| Scattergl  | Supported        | Supported      | Supported           | Supported      |
| Histogram  | Supported        | Supported      | Supported           | Supported      |
| Box        | Supported        | Not sensible   | Supported           | Supported      |
| Bar        | Supported        | Not sensible   | Supported           | Supported      |
| Pie        | Supported        | Not sensible   | Not possible        | Not supported  |


---

### Dependency management

This project uses [uv](https://github.com/astral-sh/uv) as dependency manager.

Dependencies are automatically installed when you run the `uv sync` command. The virtualenv is created in the `.venv` folder.

- Running scripts / commands in the virtualenv is as simple as running `uv run <command>`. This will automatically activate the virtualenv and run the command.
- Adding a dependency is as simple as running `uv add <package>`. Make sure to add `--dev` if the package is only needed for development.

> [!NOTE]  
> When developing, to [update the dependencies](https://github.com/astral-sh/uv/issues/1419#issuecomment-2457314237), run: `uv lock --upgrade; uv sync`