semvec/pypi-packages huggingface dataset:
py4eos 0.6.0
Convenience functions for working with HDF4-EOS datasets
Requires Python: >=3.8

Python Tools for HDF4-EOS Format
================================

Unfortunately, many important NASA datasets are still distributed as HDF4-EOS granules. These can be difficult or impossible to work with using GIS software. Even when opened using a library like GDAL, key spatial metadata are not accessed, resulting in the failure to fix the dataset's true spatial coordinates.

This small library may help you to avoid needing to install GDAL just to read the file. It is capable of reading an an HDF4 file (and HDF4-EOS files, in particular) and writing out a spatial dataset using `rasterio`, based on some strict assumptions about the file-level attributes; assumptions that are usually satisfied by an HDF4-EOS file.

The problems solved by `py4eos` include:

- Reading an HDF4-EOS file without needing `GDAL` installed
- Figuring out the coordinate reference system (CRS) and affine transformation of an HDF4-EOS granule
- Converting an HDF4-EOS file to a more convenient raster format
- Applying the scale and offset to an HDF4-EOS dataset's values to obtain true, geophysical values


Example Use
-----------

```python
import earthaccess
import py4eos

# Download a MOD16A3GF granule
result = earthaccess.search_data(
    short_name = 'MOD16A3GF',
    temporal = ('2014-01-01', '2014-12-31'),
    bounding_box = (-106, 42, -103, 43))
earthaccess.download(result, TEST_DIR)

# Write the file to a GeoTIFF
hdf = py4eos.read_hdf4eos(granule_mod16a3)
hdf.to_rasterio('ET_500m', 'output_file.tiff')
```


Installation
------------

The easiest way to install `py4eos` is using `mamba` (see [installation instructions](https://github.com/conda-forge/miniforge#mambaforge)) or `conda`. This is the recommended way to install `py4eos` on Windows or Mac OS X:

```sh
mamba install py4eos
```

If the HDF4, `zlib`, and `libjpeg` libraries are already installed, then you can use `pip` on any system to install `py4eos`:

```sh
pip install py4eos
```

**Installing dependencies on GNU/Linux:**

- On Ubuntu GNU/Linux: `sudo apt install python3-dev libhdf4-dev`

**Running the test suite,** from the root directory of the repository:

```sh
python -m pytest
```

**Because data has to be downloaded as part of running the tests, they may fail the first time. Try running once more.**


Acknowledgements
----------------

Development of the `py4eos` library was supported by a grant from NASA (80NSSC23K0864).
gcp-mcp-fastmcp 0.1.1
MCP interface for Google Cloud Platform
Requires Python: >=3.11.8

[![Add to Cursor](https://fastmcp.me/badges/cursor_dark.svg)](https://fastmcp.me/MCP/Details/1456/google-cloud-platform)
[![Add to VS Code](https://fastmcp.me/badges/vscode_dark.svg)](https://fastmcp.me/MCP/Details/1456/google-cloud-platform)
[![Add to Claude](https://fastmcp.me/badges/claude_dark.svg)](https://fastmcp.me/MCP/Details/1456/google-cloud-platform)
[![Add to ChatGPT](https://fastmcp.me/badges/chatgpt_dark.svg)](https://fastmcp.me/MCP/Details/1456/google-cloud-platform)
[![Add to Codex](https://fastmcp.me/badges/codex_dark.svg)](https://fastmcp.me/MCP/Details/1456/google-cloud-platform)
[![Add to Gemini](https://fastmcp.me/badges/gemini_dark.svg)](https://fastmcp.me/MCP/Details/1456/google-cloud-platform)

# GCP MCP Application

## Claude Desktop Integration

To enable GCP management capabilities in Claude Desktop, simply add the following configuration to your Claude Desktop MCP configuration:

```json
{
  "gcp-mcp": {
    "command": "uvx",
    "args": [
      "gcp-mcp"
    ]
  }
}
```

That's it! No additional setup or credential manipulation is required. When you first ask Claude to interact with your GCP resources, a browser window will automatically open for you to authenticate and grant access. Once you approve the access, Claude will be able to manage your GCP resources through natural language commands.

Here are some example requests you can make:

Basic Operations:
- "Could you list my GCP projects?"
- "Show me my compute instances"
- "What storage buckets do I have?"

Resource Creation:
- "Please create a compute instance with 2GB RAM and 10GB storage, name it MCP-engine"
- "Create a new storage bucket called my-backup-bucket in us-central1"
- "Set up a new VPC network named prod-network with subnet 10.0.0.0/24"

Resource Management:
- "Stop all compute instances in the dev project"
- "Show me all instances that have been running for more than 24 hours"
- "What's the current CPU usage of my instance named backend-server?"
- "Create a snapshot of my database disk"

Monitoring and Alerts:
- "Set up an alert for when CPU usage goes above 80%"
- "Show me all critical alerts from the last 24 hours"
- "What's the current status of my GKE clusters?"

## Features

The application provides comprehensive coverage of GCP services:

### Resource Management
- Projects and quotas management
- Asset inventory
- IAM permissions

### Compute & Infrastructure
- Compute Engine instances
- Storage buckets and disks
- VPC networks and firewall rules
- Kubernetes Engine (GKE) clusters

### Databases & Storage
- Cloud SQL instances
- Firestore databases
- Cloud Storage
- Database backups

### Monitoring & Billing
- Metrics and alerts
- Billing information
- Uptime monitoring
- Resource usage tracking

### Coming Soon
- Deployment manager and infrastructure as code

## Installation

```bash
pip install gcp-mcp
```

## License

[MIT License](LICENSE) 

Your contributions and issues are welcome !
cachememo 0.1.2
TTL memoization for sync/async functions with stampede protection
Requires Python: >=3.10

# cachememo

Tiny, safe memoization for Python - with TTL and async support.

`cachememo` helps you cache the results of expensive functions **without accidentally shooting yourself in the foot under concurrency**.

It’s designed for when:

- you need **time-based expiration (TTL)**
- you are working with **async functions**
- you want to avoid **cache stampedes** under load

---
### Installation

```bash
pip install cachememo
```

---

### Basic Usage
```py
from cachememo import memoize

@memoize(ttl=60)
def expensive(x: int) -> int:
    return x * 2

@memoize(ttl=30)
async def fetch_user(uid: str) -> dict:
    ...
```
---
## License

MIT