semvec/pypi-packages huggingface dataset:
flyteplugins-pytorch 2.0.0
pytorch plugin for flyte
Requires Python: >=3.10

# Union PyTorch Plugin

Union can execute **PyTorch distributed training jobs** natively on a Kubernetes Cluster, which manages the lifecycle of worker pods, rendezvous coordination, spin-up, and tear down. It leverages the open-sourced **TorchElastic (torch.distributed.elastic)** launcher and the **Kubeflow PyTorch Operator**, enabling fault-tolerant and elastic training across multiple nodes.

This is like running a transient PyTorch cluster — worker groups are created for the specific job and torn down automatically after completion. Elastic training allows nodes to scale in and out, and failed workers can be restarted without bringing down the entire job.

To install the plugin, run the following command:

```bash
pip install --pre flyteplugins-pytorch
```
flyteplugins-databricks 2.0.0
Databricks plugin for flyte
Requires Python: >=3.10

# Databricks Plugin for Flyte

This plugin provides Databricks integration for Flyte, enabling you to run Spark jobs on Databricks as Flyte tasks.

## Installation

```bash
pip install flyteplugins-databricks
```

## Usage

```python
from flyteplugins.databricks import Databricks, DatabricksConnector

@task(task_config=Databricks(
    databricks_conf={
        "run_name": "flyte databricks plugin",
        "new_cluster": {
            "spark_version": "13.3.x-scala2.12",
            "autoscale": {
                "min_workers": 1,
                "max_workers": 1,
            },
            "node_type_id": "m6i.large",
            "num_workers": 1,
            "aws_attributes": {
                "availability": "SPOT_WITH_FALLBACK",
                "instance_profile_arn": "arn:aws:iam::339713193121:instance-profile/databricks-demo",
                "ebs_volume_type": "GENERAL_PURPOSE_SSD",
                "ebs_volume_count": 1,
                "ebs_volume_size": 100,
                "first_on_demand": 1,
            },
        },
        # "existing_cluster_id": "1113-204018-tb9vr2fm", # use existing cluster id if you want
        "timeout_seconds": 3600,
        "max_retries": 1,
    },
    databricks_instance="mycompany.cloud.databricks.com",
))
def my_spark_task() -> int:
    # Your Spark code here
    return 42
```
flyteplugins-spark 2.0.0
Spark plugin for flyte
Requires Python: >=3.10

# Union Spark Plugin

Union can execute Spark jobs natively on a Kubernetes Cluster, which manages a virtual cluster’s lifecycle, spin-up, and tear down. It leverages the open-sourced Spark On K8s Operator and can be enabled without signing up for any service. This is like running a transient spark cluster — a type of cluster spun up for a specific Spark job and torn down after completion.

To install the plugin, run the following command:

```bash
pip install --pre flyteplugins-spark
```
flyteplugins-openai 2.0.0
OpenAI plugin for flyte
Requires Python: >=3.10

# Flyte OpenAI Plugin

This plugin provides a drop-in replacement for OpenAI packages. It provides
drop-in replacements for functionality in the `openai-agents` package so that
it works on Flyte.

To install the plugin, run the following command:

```bash
pip install --pre flyteplugins-openai
```
flyteplugins-sglang 2.0.0
SGLang plugin for flyte
Requires Python: >=3.10

# Flyte SGLang Plugin

Serve large language models using SGLang with Flyte Apps.

This plugin provides the `SGLangAppEnvironment` class for deploying and serving LLMs using [SGLang](https://docs.sglang.ai/).

## Installation

```bash
pip install --pre flyteplugins-sglang
```

## Usage

```python
import flyte
import flyte.app
from flyteplugins.sglang import SGLangAppEnvironment

# Define the SGLang app environment
sglang_app = SGLangAppEnvironment(
    name="my-llm-app",
    model="s3://your-bucket/models/your-model",
    model_id="your-model-id",
    resources=flyte.Resources(cpu="4", memory="16Gi", gpu="L40s:1"),
    stream_model=True,  # Stream model directly from blob store to GPU
    scaling=flyte.app.Scaling(
        replicas=(0, 1),
        scaledown_after=300,
    ),
)

if __name__ == "__main__":
    flyte.init_from_config()
    app = flyte.serve(sglang_app)
    print(f"Deployed SGLang app: {app.url}")
```

## Features

- **Streaming Model Loading**: Stream model weights directly from object storage to GPU memory, reducing startup time and disk requirements.
- **OpenAI-Compatible API**: The deployed app exposes an OpenAI-compatible API for chat completions.
- **Auto-scaling**: Configure scaling policies to scale up/down based on traffic.
- **Tensor Parallelism**: Support for distributed inference across multiple GPUs.

## Extra Arguments

You can pass additional arguments to the SGLang server using the `extra_args` parameter:

```python
sglang_app = SGLangAppEnvironment(
    name="my-llm-app",
    model="s3://your-bucket/models/your-model",
    model_id="your-model-id",
    extra_args="--max-model-len 8192 --enforce-eager",
)
```

See the [SGLang server arguments documentation](https://docs.sglang.ai/backend/server_arguments.html) for available options.
flyteplugins-ray 2.0.0
Ray plugin for flyte
Requires Python: <3.13,>=3.10

# Flyte Ray Plugin

Union can execute Ray jobs natively on a Kubernetes Cluster,
which manages a virtual cluster’s lifecycle, spin-up, and tear down.
It leverages the open-sourced KubeRay and can be enabled without signing up for any service.
This is like running a transient ray cluster —
a type of cluster spun up for a specific Ray job and torn down after completion.

To install the plugin, run the following command:

```bash
pip install --pre flyteplugins-ray
```
flyteplugins-dask 2.0.0
Dask plugin for flyte
Requires Python: >=3.10

# Union Dask Plugin

Flyte can execute `dask` jobs natively on a Kubernetes Cluster, which manages the virtual `dask` cluster's lifecycle
(spin-up and tear down). It leverages the open-source Kubernetes Dask Operator and can be enabled without signing up
for any service. This is like running a transient (ephemeral) `dask` cluster - a type of cluster spun up for a specific
task and torn down after completion. This helps in making sure that the Python environment is the same on the job-runner
(driver), scheduler and the workers.

To install the plugin, run the following command:

```bash
pip install --pre flyteplugins-dask
```
flyteplugins-bigquery 2.0.0
BigQuery plugin for flyte
Requires Python: >=3.10

# BigQuery Plugin for Flyte

This plugin provides BigQuery integration for Flyte, enabling you to run BigQuery queries as Flyte tasks.

## Installation

```bash
pip install flyteplugins-bigquery
```

## Usage

```python
from flyteplugins.bigquery import BigQueryConfig, BigQueryTask

config = BigQueryConfig(ProjectID="my-project", Location="US")
task = BigQueryTask(
    name="my_query",
    query_template="SELECT * FROM dataset.table WHERE id = {{ .user_id }}",
    plugin_config=config,
    inputs={"user_id": int},
)
```
flyteplugins-polars 2.0.0
polars plugin for flyte
Requires Python: >=3.10

# Polars Plugin

This plugin provides native support for **Polars DataFrames and LazyFrames** in Flyte, enabling efficient data processing with Polars' high-performance DataFrame library.

The plugin supports:
- `polars.DataFrame` - Eager evaluation DataFrames
- `polars.LazyFrame` - Lazy evaluation DataFrames for optimized query execution

Both types can be serialized to and deserialized from Parquet format, making them ideal for large-scale data processing workflows.

To install the plugin, run the following command:

```bash
pip install --pre flyteplugins-polars
```
flyteplugins-vllm 2.0.0
vLLM plugin for flyte
Requires Python: >=3.10

# Union vLLM Plugin

Serve large language models using vLLM with Flyte Apps.

This plugin provides the `VLLMAppEnvironment` class for deploying and serving LLMs using [vLLM](https://docs.vllm.ai/).

## Installation

```bash
pip install --pre flyteplugins-vllm
```

## Usage

```python
import flyte
import flyte.app
from flyteplugins.vllm import VLLMAppEnvironment

# Define the vLLM app environment
vllm_app = VLLMAppEnvironment(
    name="my-llm-app",
    model="s3://your-bucket/models/your-model",
    model_id="your-model-id",
    resources=flyte.Resources(cpu="4", memory="16Gi", gpu="L40s:1"),
    stream_model=True,  # Stream model directly from blob store to GPU
    scaling=flyte.app.Scaling(
        replicas=(0, 1),
        scaledown_after=300,
    ),
)

if __name__ == "__main__":
    flyte.init_from_config()
    app = flyte.serve(vllm_app)
    print(f"Deployed vLLM app: {app.url}")
```

## Features

- **Streaming Model Loading**: Stream model weights directly from object storage to GPU memory, reducing startup time and disk requirements.
- **OpenAI-Compatible API**: The deployed app exposes an OpenAI-compatible API for chat completions.
- **Auto-scaling**: Configure scaling policies to scale up/down based on traffic.
- **Tensor Parallelism**: Support for distributed inference across multiple GPUs.
fairyex 0.2.2
FairyEx - FEErical Extraction
Requires Python: >=3.10

# FairyEx

FairyEx (for FEE Extraction) is a Python package to perform extraction with some ZIP solution file.


## Magical extraction

- Fast: focus on speed
- Efficient: low memory usage
- Easy: to install and to use


## Quickstart

```bash
pip install fairyex
```

```python
from fairyex import DarkSol

with DarkSol("Model Open World Solution.zip") as ds:
    df = ds.query(
        phase="STSchedule",
        children_class="Generator",
        children=ds.query_children("Generator"),
        properties=["Generation"],
        samples=["1", "2", "3"],
    )
```
markmap-anywidget 0.2.0
Interactive mindmaps from markdown using markmap
Requires Python: >=3.10

# markmap-anywidget

A simple [anywidget](https://github.com/manzt/anywidget) implementation of [markmap](https://markmap.js.org/) for Jupyter and marimo notebooks.

## Installation

**PyPI:**
```bash
pip install markmap-anywidget
```

**Nix:**
```nix
# your flake.nix
{
  inputs = {
    nixpkgs.url = "github:NixOS/nixpkgs/nixpkgs-unstable";
    markmap-anywidget.url = "github:daniel-fahey/markmap-anywidget";
  };

  outputs = { nixpkgs, markmap-anywidget, ... }:
    let
      system = "x86_64-linux";
      pkgs = nixpkgs.legacyPackages.${system};
    in {
      devShells.${system}.default = pkgs.mkShell {
        packages = [
          (pkgs.python3.withPackages (ps: [
            markmap-anywidget.packages.${system}.default
          ]))
        ];
      };
    };
}
```

## Usage

See the [`marimo` documentation](https://docs.marimo.io/api/inputs/anywidget/) for more information.

```python
import marimo as mo
from markmap_anywidget import MarkmapWidget

widget = mo.ui.anywidget(
    MarkmapWidget(
        markdown_content="""---
markmap:
  colorFreezeLevel: 2
  maxWidth: 300
---

# markmap

## Links
- [Website](https://markmap.js.org/)
- [GitHub](https://github.com/gera2ld/markmap)

## Features
- `inline code`
- **strong** and *italic*
- Katex: $x = {-b \pm \sqrt{b^2-4ac} \over 2a}$
"""
    )
)

widget
```

## Development

```bash
git clone git@github.com:daniel-fahey/markmap-anywidget.git
cd markmap-anywidget

nix develop -c bun run build                  # rebuild static assets
nix develop -c marimo run examples/marimo.py  # test widget
```

Tests run automatically in the Nix build.

## Releasing

```bash
# Update version
echo "0.3.0" > VERSION
nix develop -c bun run build

# Commit and tag
git add -A && git commit -m "v0.3.0"
git tag v0.3.0 && git push --tags

# Create release on GitHub (publishes to PyPI automatically)
```