semvec/pypi-packages huggingface dataset:
iflow-mcp_un4ckn0wl3z-mem-mcp 0.1.0
Cheat Engine-like but MCP
Requires Python: >=3.11

# MemMCP
Cheat Engine-like but MCP (This is a PoC of the feature that this library provides, as-is.)

## Demo
https://youtu.be/NlY_R0lm5-M <br>
https://youtu.be/ivDTdxdTAQo

## Note
Don't forget to change the value inside `mcpserver-config.json` to match your environment
iflow-mcp_akchro-googlesheetsmcp 0.1.0
Add your description here
Requires Python: >=3.11

# Google Sheets MCP
Model Context Protocol (MCP) integration with Google Sheets

## Features
This integration allows the LLM to 
- List all the spreadsheets of the user
- Create a new spreadsheet
- Copy a spreadsheet to another
- Write and Edit cells
- Fill tool for cells

## Get Started
1. [Create a new Google Cloud project](https://console.cloud.google.com/projectcreate)
2. [Enable the Google Drive API](https://console.cloud.google.com/workspace-api/products)
3. [Configure an OAuth consent screen](https://console.cloud.google.com/apis/credentials/consent) ("internal" is fine for testing)
4. [Create an OAuth Client ID](https://console.cloud.google.com/apis/credentials/oauthclient) for application type "Desktop App"
5. Download the JSON file of your client's OAuth keys
6. Rename the key file to `credentials.json` and place into the root of this repo (i.e. `google-sheets-mcp/credentials.json`)

> Note: If setting the user type to external, make sure to add your email for testing
plop-sdk 0.1.0
Plop Python SDK — receive and poll for emails in your tests and applications
Requires Python: >=3.10

# Plop Python SDK

The official Python SDK for [Plop](https://plop.email) — receive and poll for emails in your tests and applications.

## Installation

```bash
pip install plop-sdk
```

## Quick Start

```python
from plop_sdk import Plop

# Reads PLOP_API_KEY from environment if not provided
plop = Plop(api_key="plop_...")

# List mailboxes
mailboxes = plop.mailboxes.list()

# List messages
messages = plop.messages.list(mailbox="qa", tag="login", limit=10)

# Get a specific message
message = plop.messages.get("message-uuid")

# Get the latest message
latest = plop.messages.latest(mailbox="qa", tag="otp")

# Wait for an email (polls until match or timeout)
email = plop.messages.wait_for(
    mailbox="qa",
    tag="verification",
    timeout=30,
    interval=1.0,
)
```

## Async Usage

```python
from plop_sdk import AsyncPlop

async with AsyncPlop() as plop:
    email = await plop.messages.wait_for(mailbox="qa", tag="login")
    messages = await plop.messages.list(mailbox="qa")
```

## Webhook Verification

```python
from plop_sdk import Plop

plop = Plop()

is_valid = plop.webhooks.verify(
    secret="whsec_...",
    signature=request.headers["x-plop-signature"],
    body=raw_body,
)
```

## Error Handling

```python
from plop_sdk import Plop, PlopError, PlopNotFoundError, PlopTimeoutError

plop = Plop()

try:
    message = plop.messages.get("nonexistent-id")
except PlopNotFoundError:
    print("Message not found")
except PlopError as e:
    print(f"API error: {e.message} (status={e.status})")
```

## Configuration

| Parameter | Environment Variable | Default |
|-----------|---------------------|---------|
| `api_key` | `PLOP_API_KEY` | Required |
| `base_url` | `PLOP_BASE_URL` | `https://api.plop.email` |
| `timeout` | - | `30.0` seconds |

## License

MIT
ifcoder 0.1.0
IFcoder: embeddings of immunofluorescence cell images
Requires Python: >=3.10

# IFcoder

**IFcoder** is a Python package for embedding immunofluorescence cell images 
into the latent space using variational autoencoders (VAEs).

It is designed to operate seamlessly with [**CellProfiler**](https://cellprofiler.org/) 
and [**Scanpy**](https://scanpy.readthedocs.io/),
making it easy to move from image segmentation to downstream single-cell analysis.

---

## Key features

- Extracts image patches centered at cell objects based on CellProfiler segmentation.
- Learns embeddings of the image patches using a convolutional VAE.
- Stores the embeddings in a single [**AnnData**](https://anndata.readthedocs.io/) file
along with the image patches, CellProfiler measurements, and metadata.

---

## Installation
```
pip install ifcoder
```

## Input
- CellProfiler output CSV. Four columns `Location_Center_X`, `Location_Center_Y`, `ImageNumber`, `ObjectNumber` 
are mandatory. Optionally, user can append additional columns of metadata (e.g., batch, treatment, diagnosis).
- Input images of the CellProfiler pipeline. Image patches will be extracted from them.

## Example
please see [ifcoder_example.ipynb](xxx.html).

## Usage
1. **Extract image patches based on CellProfiler output**
```
ifcoder extract --cp-csv ${cellprofiler_csv} --out ${patches_h5ad}
```
This step:
- reads a CellProfiler output (e.g. Cells.csv),
- extracts image patches centered on cells,
- saves the image patches, metadata, and measurements in an AnnData file

2. **Train VAE and compute embeddings**
```
ifcoder train --data ${patches_h5ad} --out ${embeddings_h5ad}
```
This runs VAE and adds learned embeddings to the AnnData object
`adata.obsm["X_ifcoder"]`

3. **Downstream analysis**
```
import scanpy as sc

adata = sc.read_h5ad("embeddings.h5ad")
sc.pp.neighbors(adata, use_rep="X_ifcoder")
sc.tl.umap(adata)
sc.pl.umap(adata)
```
This example draws UMAP dimentionality reduction of cells.

## Output
IFcoder uses [**AnnData**](https://anndata.readthedocs.io/) as the central data structure:
- `adata.obsm["X_ifcoder"]`

    Learned VAE embeddings of cell objects.

- `adata.obsm["patches"]`

    Image patches of cell objects with dimensions (n_cells, n_channels, height, width).

- `adata.X`

    CellProfiler quantitative measurements of cell objects.
    The columns starting with `AreaShape_` and `Intensity_` in CellProfiler output are stored here.

- `adata.obs`

    Cell metadata (the columns without prefixes `AreaShape_` and `Intensity_`).
mini-search-engine 1.0.1
A simple search engine library scraping Google and DuckDuckGo.
Requires Python: >=3.6
Keywords: search, google, duckduckgo, scraping, crawler

# Mini Search Engine

A flexible Python library that scrapes Google and DuckDuckGo for search results. It supports extensive search features including pagination, safe search, and time filtering.

## Features

-   **Multi-Engine Support**: Search via Google or DuckDuckGo.
-   **Smart Fallback**: Automatically tries the next available engine if the primary one is blocked (e.g., falls back to DuckDuckGo if Google blocks).
-   **Pagination**: Retrieve as many results as you need.
-   **Safe Search**: Control safe search strictness (`strict`, `moderate`, `off`).
-   **Time Filtering**: Filter results by day, week, month, or year.
-   **No API Key Needed**: Uses direct web scraping.

## Installation

You can install the package directly from PyPI:

```bash
pip install mini-search-engine
```


## Usage

```python
from mini_search_engine import SearchEngine
import logging

# Optional: Enable logging to see what's happening under the hood
logging.basicConfig(level=logging.INFO)

engine = SearchEngine()

# Simple Search
results = engine.search("python programming")
for res in results:
    print(res['title'], res['link'])

# Advanced Search with Filters
results = engine.search(
    "latest python news",
    engine="auto",       # Try Google, then DDG
    limit=20,            # Get 20 results (handles pagination automatically)
    safe="strict",       # Strict safe search
    time_range="w"       # Past week
)

print(f"\nFound {len(results)} results:")
for i, res in enumerate(results):
    print(f"#{i+1} [{res['source']}] {res['title']}")
    print(f"Link: {res['link']}")
    print(f"Snippet: {res['snippet']}")
    print("-" * 30)
```

## API Reference

### `search(query, engine="auto", limit=10, safe="moderate", time_range=None)`

-   `query` (str): The search query.
-   `engine` (str): `'google'`, `'ddg'`, or `'auto'`. Defaults to `'auto'`.
-   `limit` (int): Number of results to return. Defaults to `10`.
-   `safe` (str): Safe search level: `'strict'`, `'moderate'`, `'off'`. Defaults to `'moderate'`.
-   `time_range` (str): `'d'` (day), `'w'` (week), `'m'` (month), `'y'` (year). Defaults to `None` (any time).

## License

MIT License

## Credits

This library was developed with extensive assistance from the Jules AI coding assistant.