semvec/pypi-packages huggingface dataset:
bokk-ai 0.0.1
AI-powered CLI accounting for developers. Swedish bokföring made simple.
Requires Python: >=3.10
Keywords: accounting, ai, bas, bokföring, cli, sie4, swedish

# 📚 Bokk — AI-Powered CLI Accounting

> Swedish bokföring for developers. Bank-statement-driven, AI-categorized, SIE4-ready.

**Coming soon.** Follow [@bokk_ai](https://x.com/bokk_ai) for updates.

## Install

```bash
pip install bokk-ai
```

## What It Will Do

```bash
bokk import bank-statement.csv   # Import bank transactions
bokk review                      # AI categorizes, you confirm
bokk log                         # Git-log style verification history
bokk status                      # Period overview
bokk export sie4 2025            # SIE4 export
bokk report balans 2025          # PDF balance report
```

## Links

- 🌐 [bokk.ai](https://bokk.ai)
- 🐙 [GitHub](https://github.com/bokk-ai/bokk)
- 🐦 [Twitter/X](https://x.com/bokk_ai)
iflow-mcp_guilhermeaumo-mcp-nano-banana 0.3.3
Um servidor MCP que gera imagens usando a Google Gemini API.
Requires Python: >=3.10

# MCP Nano Banana

[![PyPI Version](https://img.shields.io/pypi/v/mcp-nano-banana.svg)](https://pypi.org/project/mcp-nano-banana/)

This project is an MCP (Model Context Protocol) server that generates images using the Google Gemini API.

## Description

This server implements the Model Context Protocol to expose a single tool, `generate_image`, to a compatible AI model. The tool accepts a text prompt, uses the Google Gemini API to generate an image, saves the image to the `public/` directory for auditing, and returns the raw image data as a base64-encoded string.

## To use the server with Claude Desktop or other applications

You need a Google Gemini API key and ImgBB API key to use this server.

Access https://api.imgbb.com/ to generate a IMGBB API Key. This is used to store and host the image online.

```json
{
  "mcpServers": {
    "mcp-nano-banana": {
        "command": "uvx",
        "args": [
            "mcp-nano-banana"
        ],
        "env": {
            "GEMINI_API_KEY": "YOUR_API_KEY_HERE",
            "IMGBB_API_KEY": "YOUR_API_KEY_HERE"
        }
    }
  }
}
```


## Dev Setup

### 1. Dependencies

This project uses Python and its dependencies are defined in `pyproject.toml`. You can install them using `pip`:

```bash
pip install .
# Or
uv sync
```

This will install `mcp`, `google-generativeai`, and other required packages.

### 2. API Key

You need a Google Gemini API key and ImgBB API key to use this server.

Access https://api.imgbb.com/ to generate a IMGBB API Key. This is used to store and host the image online.

1.  Create a file named `.env` in the root of the project.
2.  Add your API key to the `.env` file in the following format:

```
    GEMINI_API_KEY="YOUR_API_KEY_HERE"
    IMGBB_API_KEY="YOUR_API_KEY_HERE"
```

## Running the Server

This server is designed to be run as a subprocess by an MCP client or using the `mcp` command-line tool. The server listens for requests on `stdio`.

```bash
uvx --from git+https://github.com/GuilhermeAumo/mcp-nano-banana mcp-nano-banana
```


## Publishing new pipy version
To publish a new version of this package to PyPI:

1. **Update the version**  
   Edit the `version` field in `pyproject.toml` to the new version number.

2. **Build the package**  
   Run:
   ```bash
   uv build
   ```
   This will create `.tar.gz` and `.whl` files in the `dist/` directory.

3. **Upload to PyPI**  
   ```bash
   uv publish
   ```

4. **Tag the release (optional but recommended)**  
  Commit the changes to github first, then:
  
   ```bash
   git tag v<new-version>
   git push --tags
   ```

**Note:**  
- You need a PyPI account and must be listed as a maintainer of the project.

For more details, see the [Python Packaging User Guide](https://packaging.python.org/tutorials/packaging-projects/).
redrover-api 1.15.4
Red Rover API
Keywords: OpenAPI, OpenAPI-Generator, Red Rover API

    Access Red Rover data via this REST API for Organizations that have granted you access.  # Authentication The API is protected by HTTP Basic Authentication.   Each application that connects to the API has a unique username and password that it must supply with every request.  This value needs to be supplied as an HTTP Header: &#x60;Authorization&#x3D;BASIC [hash]&#x60;. The value of [hash] is the string username:password base64 encoded.  Endpoints marked for Basic Auth can be used with the Basic Auth username and password that you have been assigned.  # API Information ## Api Key Each Red Rover organization that has authorized your application has a unique API Key for your application.  To retrieve the API Key, you can use the Organization endpoint (&#x60;api/v1/organization&#x60;) which returns an ApiKey uniquely used for each Organization.  You must supply this as an HTTP Header when accessing that organization: &#x60;apiKey&#x3D;[apiKey]&#x60;. The domains that require this &#x60;ApiKey&#x60; header are labeled as &#39;Requires an ApiKey&#39;.  ## Identifier Where an &#x60;Identifier&#x60; can be specified in the route, you may either supply the Red Rover Id of the object (numeric) or the External Id (alpha-numeric). When specifying an External Id, you will need to prepend the External Id with the pipe character&#x60;|&#x60; (e.g. &#x60;|ABC123&#x60;). Please note that this is only the case when the External Id is within the route. If the External Id is contained within the body of the request, do not append the pipe character.  ## Rate Limiting Requests are rate limited at a default rate of 100 requests per minute  ## Transaction Id Each request can be supplied with a &#x60;TransactionId&#x60; GUID which will be logged with the request. The &#x60;Transaction Id&#x60; can be supplied as an HTTP Header: &#x60;TransactionId&#x3D;[transactionId]&#x60;. If no &#x60;Transaction Id&#x60; is supplied, one will be generated for you. Please use a distinct TransactionId for each request.
crunch-node 0.1.0
Runtime engine for Crunch coordinator nodes
Requires Python: >=3.12

# crunch-node

Runtime engine for Crunch coordinator nodes. Published as `crunch-node` on PyPI, imported as `coordinator_node`.

```bash
pip install crunch-node
```

## Architecture

### Pipeline

```
Feed → Input → Prediction → Score → Snapshot → Checkpoint → On-chain
```

**Workers:**

| Worker | Purpose |
|---|---|
| `feed-data-worker` | Ingests feed data (Pyth, Binance, etc.) via WebSocket + backfill |
| `predict-worker` | Event-driven: gets data → ticks models → collects predictions |
| `score-worker` | Resolves actuals → scores predictions → writes snapshots → rebuilds leaderboard |
| `checkpoint-worker` | Aggregates snapshots → builds EmissionCheckpoint for on-chain submission |
| `report-worker` | FastAPI: leaderboard, predictions, feeds, snapshots, checkpoints, emissions |

### Contract

All type shapes and behavior are defined in a single `CrunchContract`:

```python
from coordinator_node.contracts import CrunchContract

class CrunchContract(BaseModel):
    raw_input_type: type[BaseModel] = RawInput
    output_type: type[BaseModel] = InferenceOutput
    score_type: type[BaseModel] = ScoreResult
    scope: PredictionScope = PredictionScope()
    aggregation: Aggregation = Aggregation()

    # Callables
    resolve_ground_truth: Callable = default_resolve_ground_truth
    aggregate_snapshot: Callable = default_aggregate_snapshot
    build_emission: Callable = default_build_emission
```

### Feed Dimensions

| Dimension | Example | Env var |
|---|---|---|
| `source` | pyth, binance | `FEED_SOURCE` |
| `subject` | BTC, ETH | `FEED_SUBJECTS` |
| `kind` | tick, candle | `FEED_KIND` |
| `granularity` | 1s, 1m | `FEED_GRANULARITY` |

### Status Lifecycles

```
Input:       RECEIVED → RESOLVED
Prediction:  PENDING → SCORED / FAILED / ABSENT
Checkpoint:  PENDING → SUBMITTED → CLAIMABLE → PAID
```

### Emission Checkpoints

Checkpoints produce `EmissionCheckpoint` matching the on-chain protocol:

```python
{
    "crunch": "<pubkey>",
    "cruncher_rewards": [{"cruncher_index": 0, "reward_pct": 350_000_000}, ...],
    "compute_provider_rewards": [...],
    "data_provider_rewards": [...],
}
```

`reward_pct` uses frac64 (1,000,000,000 = 100%).

### Report API

| Endpoint | Description |
|---|---|
| `GET /reports/leaderboard` | Current leaderboard |
| `GET /reports/models` | Registered models |
| `GET /reports/predictions` | Prediction history |
| `GET /reports/feeds` | Active feed subscriptions |
| `GET /reports/snapshots` | Per-model period summaries |
| `GET /reports/checkpoints` | Checkpoint history |
| `GET /reports/checkpoints/{id}/emission` | Raw emission (frac64) |
| `GET /reports/checkpoints/{id}/emission/cli-format` | CLI JSON format |
| `GET /reports/emissions/latest` | Latest emission |
| `POST /reports/checkpoints/{id}/confirm` | Record tx_hash |
| `PATCH /reports/checkpoints/{id}/status` | Advance status |

## Scaffolding

Use `crunch-cli init-workspace <name>` to create a new competition workspace from the `base/` template.

## Development

```bash
uv run pytest tests/ -q
```