semvec/pypi-packages huggingface dataset:
iflow-mcp_lukeage-python-pip-mcp 0.1.0
Minimal Example Implementation of an Anthropic MCP Server in Python with Pip
Requires Python: >=3.8

# python-pip-mcp

Minimal Example Implementation of an Anthropic [MCP](https://modelcontextprotocol.io/introduction) Client and Server in Python with Pip. 

The goal of this repository is to provide a reference implementation of a **mcp client and server** that can be easily debugged in VSCode on Windows using the Python / Python Debugger extension.

Alternative IDEs and OS are not tested but should work with minimal adjustments, too.

## Installation

```powershell
# create venv
python -m venv myenv
myenv\Scripts\activate

# install requirements
pip install -r requirements.txt

# create a .env file and set your anthropic api key
cp .env.sample .env

# run mcp_client.py script
python mcp_client.py

# query for current time
```
xarray-regrid 0.4.2
Regridding tools using xarray and flox.
Requires Python: >=3.10

# xarray-regrid: Regridding utilities for xarray.

<img align="right" width="100" alt="Logo" src="./docs/assets/logo.png">


With xarray-regrid it is possible to regrid between two rectilinear grids. The following methods are supported:
 - Linear
 - Nearest-neighbor
 - Conservative
 - Cubic
 - "Most common value", as well as other zonal statistics (e.g., variance or median).

All regridding methods can operate lazily on [Dask arrays](https://docs.xarray.dev/en/latest/user-guide/dask.html).

Note that "Most common value" is designed to regrid categorical data to a coarse resolution. For regridding categorical data to a finer resolution, please use "nearest-neighbor" regridder.

[![PyPI](https://img.shields.io/pypi/v/xarray-regrid.svg?style=flat)](https://pypi.python.org/pypi/xarray-regrid/)
[![conda-forge](https://anaconda.org/conda-forge/xarray-regrid/badges/version.svg)](https://anaconda.org/conda-forge/xarray-regrid)
[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.10203304.svg)](https://doi.org/10.5281/zenodo.10203304)
[![Docs](https://readthedocs.org/projects/xarray-regrid/badge/?version=latest&style=flat)](https://xarray-regrid.readthedocs.org/)

## Why xarray-regrid?

Regridding is a common operation in earth science and other fields. While xarray does have some interpolation methods available, these are not always straightforward to use. Additionally, methods such as conservative regridding, or taking the most common value, are not available in xarray.

## Installation

For a minimal install:
```console
pip install xarray-regrid
```

*Note: xarray-regrid is also [available on conda-forge](https://anaconda.org/conda-forge/xarray-regrid).*

To improve performance in certain cases:
```console
pip install xarray-regrid[accel]
```

which includes optional extras such as:
 - `dask`: parallelization over chunked data
 - `sparse`: for performing conservative regridding using sparse weight matrices
 - `opt-einsum`: optimized einsum routines used in conservative regridding

Benchmarking varies across different hardware specifications, but the inclusion of these extras can often provide significant speedups.

## Usage
The xarray-regrid routines are accessed using the "regrid" accessor on an xarray Dataset:
```py
import xarray_regrid

ds = xr.open_dataset("input_data.nc")
ds_grid = xr.open_dataset("target_grid.nc")

ds.regrid.linear(ds_grid)
```

For examples, see the benchmark notebooks and the demo notebooks.

## Benchmarks
The benchmark notebooks contain comparisons to more standard methods (CDO, xESMF).

To be able to run the notebooks, a conda environment is required (due to ESMF and CDO).
You can install this environment using the `environment.yml` file in this repository.
[Micromamba](https://mamba.readthedocs.io/en/latest/user_guide/micromamba.html) is a lightweight version of the much faster "mamba" conda alternative.

```sh
micromamba create -n environment_name -f environment.yml
```

## Acknowledgements

This package was developed under Netherlands eScience Center grant [NLESC.OEC.2022.017](https://research-software-directory.org/projects/excited).
alchemite-mcp 0.2.0
An Alchemite MCP server for local use by end users
Requires Python: >=3.10
Keywords: Alchemite, Alchemite API, Machine Learning, Artificial Intelligence, MCP

# Alchemite™ MCP server

A Model Context Protocol server to allow access to Alchemite™ data and models through LLM agents.

This is a beta product and subject to change.

See [the docs](https://docs.intellegens.com/alchemite-tm-mcp/overview) for details of how to use.
pytenjin 1.0.0
A fast and full-featured template engine based on embedded Python (maintained fork)
Requires Python: >=3.8
Keywords: template, engine, tenjin, embedded python

[![PyPI version](https://badge.fury.io/py/pytenjin.svg)](https://pypi.org/project/pytenjin/)
[![Python versions](https://img.shields.io/pypi/pyversions/pytenjin.svg)](https://pypi.org/project/pytenjin/)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

# PyTenjin

This is a maintained fork of the original [Tenjin](https://github.com/kwatch/tenjin) template engine, which is no longer actively maintained.

Original project: https://pypi.org/project/Tenjin/

## About

PyTenjin is a very fast and full-featured template engine. You can embed Python statements and expressions into your template file. PyTenjin converts it into Python script and evaluates it.

## Features

- **Very fast**: Approximately 10x faster than Django, 4x faster than Cheetah, 2x faster than Mako
- **Full featured**:
  - Nestable layout templates
  - Partial templates
  - Fragment caching
  - Capturing
  - Preprocessing
- **Easy to learn**: Simple and intuitive syntax

## Installation

```bash
pip install pytenjin
```

## Quick Example

**Template file (table.pyhtml):**

```html
<?py #@ARGS items ?>
<table>
  <?py for item in items: ?>
  <tr>
    <td>{=item=}</td>
  </tr>
  <?py #end ?>
</table>
```

**Python code:**

```python
import tenjin
from tenjin.helpers import *

engine = tenjin.Engine()
context = {'items': ['AAA', 'BBB', 'CCC']}
html = engine.render('table.pyhtml', context)
print(html)
```

**Output:**

```html
<table>
  <tr>
    <td>AAA</td>
  </tr>
  <tr>
    <td>BBB</td>
  </tr>
  <tr>
    <td>CCC</td>
  </tr>
</table>
```

## Template Syntax

PyTenjin supports multiple expression syntaxes:

- **`{=...=}`** - escaped expression (recommended)
- **`{==...==}`** - raw expression (recommended)
- `${...}` - escaped expression (deprecated)
- `#{...}` - raw expression (deprecated)

> **Note:** The `${...}` and `#{...}` syntax is deprecated and will be removed in a future version. Please use `{=...=}` and `{==...==}` instead.

## License

MIT License

Original copyright by kuwata-lab.com
django-grouper 0.4.0
Group Django objects by similarity

Group Django model instances based on similar fields

# Installation

1. add `django_grouper` to your `INSTALLED_APPS`
2. add `path("", include("django_grouper.urls"))` to your `urlpatterns`
3. go to `/grouper` and add the param `group_content_type` to specify which ContentType to group and the params `group_fields` to specify which fields to group by

# Configuration

If you define a `GROUP_FILTER` in you settings, the queryset in the `/grouper` view will be passed through this filter. The filter is expected to
be a callable and will receive the queryset and the request as parameters. This means you can pass the queryset together with the request to a
django-filter filter.

The `/group` view lets you select which objects of a list should be merged. If
you double click an object, it will become the primary, a single click marks an
object as secondary. There can be one primary and multiple secondaries. The
primary and the list of secondaries are then passed to the `trigger_merge`
signal. You can use this method to implement a custom merge method.

```
from django_grouper.signals import trigger_merge


@receiver(trigger_merge)
def react_on_merge_trigger(sender, primary, secondaries, **kwargs):
    primary.merge(secondaries)
```