semvec/pypi-packages huggingface dataset:
pygdal 3.8.5.12
Virtualenv and setuptools friendly version of standard GDAL python bindings
License: MIT
Requires Python: >=3.6

# Virtualenv friendly GDAL bindings for Python

This package is for you if you had problems installing GDAL in your virtualenv.
You can install GDAL into your virtualenv using this package but you still need
to install GDAL library and its header files on your system. On Ubuntu it can be
done this way:

```bash
$ sudo apt-get install libgdal-dev
```

Version of the same package, and GDAL, so that if you have installed GDAL 3.6.4
you need to install 3.6.4.\* of this package:

```bash
$ gdal-config --version
3.6.4
$ virtualenv --no-site-packages env
$ env/bin/pip install pygdal=="3.6.4.*"
```

The trick with range of versions required to support pygdal versioning.

Package `numpy` is also listed as a dependency, so you do not need to install it
before installing GDAL. After package is installed you can use is same way as
standard GDAL bindings:

```python
from osgeo import gdal, ogr, osr

# ...
```
kf-filter 0.0.5.post2
Filtering on the wavenumber-frequency domain based on WK99.
License: MIT
Requires Python: <4.0,>=3.9

# KF Filter

A Python package for filtering equatorial waves in the wavenumber-frequency domain.

![Example Filter Visualization](example/figures/kelvin_filtered_OLR.png)

## Features

- Implements wavenumber-frequency filtering for equatorial waves.
- Supports filtering for MJO and TD as well.
- Provides visualization tools for filter masks.

## Installation

The easiest way to install is through pip.

```bash
pip install kf-filter
```

## Usage

```python
import xarray as xr
from kf_filter import KF

# Load your data as an xarray DataArray
data = xr.open_dataset("your_data.nc")["variable_name"]

# Initialize the KF filter
kf_filter = KF(data, sampling_per_day=2, time_taper_frac=0.1)

# Apply a Kelvin wave filter
filtered_data = kf_filter.kelvin_filter()

# Visualize the filter
kf_filter.visualize_filter("kelvin")
```

## Contributing

Contributions are welcome! Please fork the repository and submit a pull request.

## License

This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.
graph-orchestrator 0.2.5
A lightweight graph execution engine.
License: MIT
Requires Python: >=3.12

<p align="center">
  <img src="https://raw.githubusercontent.com/AbhinavS99/GraphOrchestrator/main/logo/logo.png" alt="GraphOrchestrator Logo" width="300"/>
</p>

<h1 align="center">GraphOrchestrator</h1>

[![CI](https://github.com/AbhinavS99/GraphOrchestrator/actions/workflows/ci.yml/badge.svg)](https://github.com/AbhinavS99/GraphOrchestrator/actions/workflows/ci.yml)
[![codecov](https://codecov.io/gh/AbhinavS99/GraphOrchestrator/graph/badge.svg?token=U69VNUUQ6I)](https://codecov.io/gh/AbhinavS99/GraphOrchestrator)
[![PyPI version](https://badge.fury.io/py/graph-orchestrator.svg)](https://badge.fury.io/py/graph-orchestrator)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://github.com/AbhinavS99/GraphOrchestrator/blob/main/LICENSE)

**GraphOrchestrator** is a powerful yet lightweight Python library designed to help you build and execute complex, dynamic workflows as directed graphs. Think of it as your toolkit for crafting intricate decision engines, agent workflows, or even robust data pipelines, all with the elegance of graph-based execution.

## ✨ Purpose

At its core, GraphOrchestrator simplifies the process of defining and running workflows where the flow of operations is determined by a graph. This approach provides exceptional flexibility and clarity, especially when dealing with:

- **Complex Decision Making:** Model intricate decision paths in a visually intuitive graph.
- **Agent Workflows:** Define sequences of actions for autonomous agents.
- **Data Processing Pipelines:** Orchestrate data transformations and processing steps with precision.

## 🚀 Key Features

- **Node-Based Processing:** Define your processing logic as modular **nodes**.
- **Flexible Control Flow:** Guide execution through **concrete and conditional edges**.
- **Decorator Magic:** Use decorators to easily define node actions, routing logic, and aggregators.
- **Robustness Built-In:** Leverage **retry policies** for fault-tolerant execution.
- **Dynamic Branching:** Implement **conditional branching** with ease using routing functions.
- **Parallelism and Aggregation:** Handle **parallel and aggregated state processing** effortlessly.
- **Visualize Your Flow:** Get a clear view of your workflows with **graph visualization** via Matplotlib.
- **Test-Driven Development:** Benefit from **built-in testability** with full unit test coverage.
- **Lightweight and Extensible:** Designed for simplicity, extensibility and easy integration in any project.

## 🛠️ Installation

You can install GraphOrchestrator via pip:



- ✅ **Decorator-driven design** for node actions, routing logic, and aggregators  
- 🔁 **Retry policies** and fault-tolerant execution  
- 🧠 **Conditional branching** using routing functions  
- 🤝 **Parallel and aggregated state processing**  
- 🎨 **Graph visualization** with Matplotlib  
- 🧪 **Built-in testability** with full unit test coverage  

Whether you're designing decision engines, agent workflows, or data pipelines—GraphOrchestrator offers an intuitive and extensible framework for graph-based execution.