semvec/pypi-packages huggingface dataset:
mkmapdiary 0.0.2b1
A travel journal generator
Requires Python: >=3.8

# mkmapdiary

[![PyPI - Version](https://img.shields.io/pypi/v/mkmapdiary.svg)](https://pypi.org/project/mkmapdiary)
![PyPI - License](https://img.shields.io/pypi/l/mkmapdiary)
![PyPI - Status](https://img.shields.io/pypi/status/mkmapdiary)

![PyPI - Python Version](https://img.shields.io/pypi/pyversions/mkmapdiary)


-----

A travel journal generator.

## Installation

```console
pipx install mkmapdiary[all]
```

## Quick start

Set up a directory containing all your sources, e.g. `traveljournal`. Then run:

```bash
mkmapdiary traveljournal
x-www-browser traveljournal_dist/index.html # Open the page
```

Mkmapdiary will then create a directory `traveljournal_dist`, containing the output as a website.

For the full reference of commandline options run `mkmapdiary --help`.

## Running mkmapdiary on placeholder data

Mkmapdiary can generate a project with placeholder data:

```bash
mkmapdiary -T demo
mkmapdiary demo
x-www-browser demo/index.html
```

This is for debugging/demonstration purposes only! Images by https://picsum.photos/.

## Running the dev version

Within the project root, run:

```bash
pipx install hatch taskipy pre-commit
pre-commit install
hatch run mkmapdiary --help
```

## Documentation

See https://bytehexe.github.io/mkmapdiary/

## License

`mkmapdiary` is distributed under the terms of the [PolyForm Noncommercial License 1.0.0](https://polyformproject.org/licenses/noncommercial/1.0.0/) license.

> Required Notice: Copyright Janna Hopp (https://github.com/bytehexe)

## Bon voyage!

Have fun travelling and stay safe!
dask-stubs 0.1.6
Typing stubs for the Dask ecosystem.
Requires Python: >=3.12
Keywords: typing, type-stubs, dask

# dask-stubs

`dask-stubs` provides third-party typing information for the Dask project. The
goal is to fill the gaps left by the runtime package so that type checkers such
as Mypy and Pyright can reason about typical Dask usage with confidence.

## Project layout

The repository separates runtime helpers from the stub definitions:

- `src/dask-stubs/` holds `.pyi` files that mirror the public Dask API.
- `tests/typecheck/samples/` provides runtime-free Python snippets that mypy
  validates to guard the stubs.
- `noxfile.py` defines automation for linting, type checking, and stub sanity
  checks.

## Quick start

1. Install development dependencies with `uv` (Python 3.12+):

   ```bash
   uv sync --group dev
   ```

2. Run the default automation via `uv`:

   ```bash
   uv run nox
   ```

   This runs Ruff, Mypy against the stubs, and the sample type-check tests.

## Contribution guidelines

1. Prefer working against small slices of the API. It is easier to review and
   iterate on focused modules.
2. Each new stub should be paired with a usage example under
   `tests/typecheck/samples/` (tested via mypy).
3. Keep the stubs faithful to the runtime signatures. Where the runtime is
   dynamic, fall back to `Any` but leave a `TODO` for future improvement.
4. Run the full `uv run nox` suite before sending a pull request.

See `CONTRIBUTING.md` for more detail on project conventions and coding
standards.
iflow-mcp_mcp-searxng 0.1.0
MCP server for connecting agentic systems to search systems via searXNG
Requires Python: >=3.12

# MCP-searxng

An MCP server for connecting agentic systems to search systems via [searXNG](https://docs.searxng.org/).

<p align="center">
  <a href="https://glama.ai/mcp/servers/sl2zl8vaz8">
    <img width="380" height="200" src="https://glama.ai/mcp/servers/sl2zl8vaz8/badge" alt="MCP SearxNG Badge"/>
  </a>
</p>

## Tools

Search the web with SearXNG

## Prompts

```python
search(query: str) -> f"Searching for {query} using searXNG"
```

## Usage

### via uvx

1) configure your client JSON like

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

### via git clone

1) Add the server to claude desktop (the entrypoint is main.py)

Clone the repo and add this JSON to claude desktop

you can run this server with `uvx mcp-searxng`, or use a local copy of the repo

```json
{
  "mcpServers": {
    "searxng": {
      "command": "uv", 
      "args": [
        "--project",
        "/absoloute/path/to/MCP-searxng/",
        "run",
        "/absoloute/path/to/MCP-searxng/mcp-searxng/main.py"
      ]
    }
  }
}
```

you will need to change the paths to match your environment

### Custom SearXNG URL

2) set the environment variable `SEARXNG_URL` to the URL of the searxng server (default is `http://localhost:8080`)

3) run your MCP client and you should be able to search the web with searxng

Note: if you are using claude desktop make sure to kill the process (task manager or equivalent) before running the server again
dataprepX 0.1.0
An automatic data cleaning and preprocessing library for ML
Requires Python: >=3.8

# dataprepX

**dataprepX** is an automatic data cleaning and preprocessing library that makes your dataset ready for machine learning with a single command.

## Installation

```bash
pip install dataprepX

from dataprepX.cleaner import DataPrepX
import pandas as pd

df = pd.read_csv('data.csv')
dp = DataPrepX()
clean_df = dp.fit_transform(df)

Features

Handles missing values

Encodes categorical data

Scales numerical columns

Removes outliers

Generates simple data reports


---

## ⚙️ Step 5: Build your package

Terminal me jao (folder jisme `setup.py` hai) aur likho:

```bash
pip install build twine
python -m build
iflow-mcp_mcp-browser-use 0.1.0
A MCP server project
Requires Python: >=3.12

# browser-use MCP server

A MCP server project

## Components

### Resources

The server implements a simple note storage system with:
- Custom note:// URI scheme for accessing individual notes
- Each note resource has a name, description and text/plain mimetype

### Prompts

The server provides a single prompt:
- summarize-notes: Creates summaries of all stored notes
  - Optional "style" argument to control detail level (brief/detailed)
  - Generates prompt combining all current notes with style preference

### Tools

The server implements one tool:
- add-note: Adds a new note to the server
  - Takes "name" and "content" as required string arguments
  - Updates server state and notifies clients of resource changes

## Configuration

[TODO: Add configuration details specific to your implementation]

## Quickstart

### Install

#### Claude Desktop

On MacOS: `~/Library/Application\ Support/Claude/claude_desktop_config.json`
On Windows: `%APPDATA%/Claude/claude_desktop_config.json`

<details>
  <summary>Development/Unpublished Servers Configuration</summary>
  ```
  "mcpServers": {
    "browser-use": {
      "command": "uv",
      "args": [
        "--directory",
        "/Users/adamholsinger/mcp-servers/browser-use",
        "run",
        "browser-use"
      ]
    }
  }
  ```
</details>

<details>
  <summary>Published Servers Configuration</summary>
  ```
  "mcpServers": {
    "browser-use": {
      "command": "uvx",
      "args": [
        "browser-use"
      ]
    }
  }
  ```
</details>

## Development

### Building and Publishing

To prepare the package for distribution:

1. Sync dependencies and update lockfile:
```bash
uv sync
```

2. Build package distributions:
```bash
uv build
```

This will create source and wheel distributions in the `dist/` directory.

3. Publish to PyPI:
```bash
uv publish
```

Note: You'll need to set PyPI credentials via environment variables or command flags:
- Token: `--token` or `UV_PUBLISH_TOKEN`
- Or username/password: `--username`/`UV_PUBLISH_USERNAME` and `--password`/`UV_PUBLISH_PASSWORD`

### Debugging

Since MCP servers run over stdio, debugging can be challenging. For the best debugging
experience, we strongly recommend using the [MCP Inspector](https://github.com/modelcontextprotocol/inspector).


You can launch the MCP Inspector via [`npm`](https://docs.npmjs.com/downloading-and-installing-node-js-and-npm) with this command:

```bash
npx @modelcontextprotocol/inspector uv --directory /Users/adamholsinger/mcp-servers/browser-use run browser-use
```


Upon launching, the Inspector will display a URL that you can access in your browser to begin debugging.
iflow-mcp_mcp-server-macos-defaults 0.1.2
MCP server for reading/writing macOS defaults (settings)
Requires Python: >=3.13

# mcp-server-macos-defaults MCP server

MCP server for reading/writing macOS defaults (settings)

## Components

### Tools

- `list-domains`:
  - equivalent to running `defaults domains`
- `find`:
  - equivalent to running `defaults find <word>`
- `defaults-read`:
  - equivalent to running `defaults read <domain> <key>`
  - if `key` is not provided, the entire domain is read
- `defaults-write`:
  - equivalent to running `defaults write <domain> <key> <value>`

## Quickstart

### Install

#### Claude Desktop

On MacOS: `~/Library/Application\ Support/Claude/claude_desktop_config.json`
On Windows: `%APPDATA%/Claude/claude_desktop_config.json`

<details>
  <summary>Development/Unpublished Servers Configuration</summary>
  ```
  "mcpServers": {
    "mcp-server-macos-defaults": {
      "command": "uv",
      "args": [
        "--directory",
        "/path/to/mcp-server-macos-defaults",
        "run",
        "mcp-server-macos-defaults"
      ]
    }
  }
  ```
</details>

<details>
  <summary>Published Servers Configuration</summary>
  ```
  "mcpServers": {
    "mcp-server-macos-defaults": {
      "command": "uvx",
      "args": [
        "mcp-server-macos-defaults"
      ]
    }
  }
  ```
</details>

## Development

### Building and Publishing

To prepare the package for distribution:

1. Sync dependencies and update lockfile:
```bash
uv sync
```

2. Build package distributions:
```bash
uv build
```

This will create source and wheel distributions in the `dist/` directory.

3. Publish to PyPI:
```bash
uv publish
```

Note: You'll need to set PyPI credentials via environment variables or command flags:
- Token: `--token` or `UV_PUBLISH_TOKEN`
- Or username/password: `--username`/`UV_PUBLISH_USERNAME` and `--password`/`UV_PUBLISH_PASSWORD`

### Debugging

Since MCP servers run over stdio, debugging can be challenging. For the best debugging
experience, we strongly recommend using the [MCP Inspector](https://github.com/modelcontextprotocol/inspector).


You can launch the MCP Inspector via [`npm`](https://docs.npmjs.com/downloading-and-installing-node-js-and-npm) with this command:

```bash
npx @modelcontextprotocol/inspector uv --directory /path/to/mcp-server-macos-defaults run mcp-server-macos-defaults
```


Upon launching, the Inspector will display a URL that you can access in your browser to begin debugging.
llama-index-llms-fireworks 0.4.5
llama-index llms fireworks integration
Requires Python: <4.0,>=3.9

# LlamaIndex Llms Integration: Fireworks

## Installation

1. Install the required Python packages:

   ```bash
   %pip install llama-index-llms-fireworks
   %pip install llama-index
   ```

2. Set the Fireworks API key as an environment variable or pass it directly to the class constructor.

## Usage

### Basic Completion

To generate a simple completion, use the `complete` method:

```python
from llama_index.llms.fireworks import Fireworks

resp = Fireworks().complete("Paul Graham is ")
print(resp)
```

Example output:

```
Paul Graham is a well-known essayist, programmer, and startup entrepreneur. He co-founded Y Combinator, which supported startups like Dropbox, Airbnb, and Reddit.
```

### Basic Chat

To simulate a chat with multiple messages:

```python
from llama_index.core.llms import ChatMessage
from llama_index.llms.fireworks import Fireworks

messages = [
    ChatMessage(
        role="system", content="You are a pirate with a colorful personality"
    ),
    ChatMessage(role="user", content="What is your name"),
]
resp = Fireworks().chat(messages)
print(resp)
```

Example output:

```
Arr matey, ye be askin' for me name? Well, I be known as Captain Redbeard the Terrible!
```

### Streaming Completion

To stream a response in real-time using `stream_complete`:

```python
from llama_index.llms.fireworks import Fireworks

llm = Fireworks()
resp = llm.stream_complete("Paul Graham is ")

for r in resp:
    print(r.delta, end="")
```

Example output (partial):

```
Paul Graham is a well-known essayist, programmer, and venture capitalist...
```

### Streaming Chat

For a streamed conversation, use `stream_chat`:

```python
from llama_index.llms.fireworks import Fireworks
from llama_index.core.llms import ChatMessage

llm = Fireworks()
messages = [
    ChatMessage(
        role="system", content="You are a pirate with a colorful personality"
    ),
    ChatMessage(role="user", content="What is your name"),
]
resp = llm.stream_chat(messages)

for r in resp:
    print(r.delta, end="")
```

Example output (partial):

```
Arr matey, ye be askin' for me name? Well, I be known as Captain Redbeard the Terrible...
```

### Model Configuration

To configure the model for more specific behavior:

```python
from llama_index.llms.fireworks import Fireworks

llm = Fireworks(model="accounts/fireworks/models/kimi-k2-instruct-0905")
resp = llm.complete("Paul Graham is ")
print(resp)
```

Example output:

```
Paul Graham is an English-American computer scientist, entrepreneur, venture capitalist, and blogger.
```

For a full list of models, check the [Fireworks website](https://app.fireworks.ai/models).

### API Key Configuration

To use separate API keys for different instances:

```python
from llama_index.llms.fireworks import Fireworks

llm = Fireworks(
    model="accounts/fireworks/models/kimi-k2-instruct-0905",
    api_key="YOUR_API_KEY",
)
resp = llm.complete("Paul Graham is ")
print(resp)
```

### LLM Implementation example

https://docs.llamaindex.ai/en/stable/examples/llm/fireworks/
innov8r 6.0.5
Python-based GUI application designed to streamline software development workflows with innovative tools and utilities. It provides developers with an intuitive and user-friendly interface for building efficient and scalable solutions

# innov8r

**innov8r** is a Python-based GUI application designed to streamline software development workflows with innovative tools and utilities. It provides developers with an intuitive and user-friendly interface for building efficient and scalable solutions.

---

## Installation

Install the application using pip:

```bash
pip install innov8r
```

## Script to run and start

```python
from innov8r import launch, report_time
from innov8r.flask_app import startFlaskApp


startFlaskApp()
report_time("Before launch")
launch()
```
abattlemetrics 0.7.1
An asyncio wrapper for the battlemetrics API.
Requires Python: >=3.8

# abattlemetrics

[![PyPI](https://img.shields.io/pypi/v/abattlemetrics?label=View%20on%20pypi&style=flat-square)](https://pypi.org/project/abattlemetrics/)
[![](https://img.shields.io/github/actions/workflow/status/thegamecracks/abattlemetrics/publish.yml?style=flat-square&logo=uv&label=build)](https://docs.astral.sh/uv/)
[![](https://img.shields.io/github/actions/workflow/status/thegamecracks/abattlemetrics/pyright-lint.yml?style=flat-square&label=pyright)](https://microsoft.github.io/pyright/#/)
[![](https://img.shields.io/github/actions/workflow/status/thegamecracks/abattlemetrics/ruff-check.yml?style=flat-square&logo=ruff&label=lints)](https://docs.astral.sh/ruff/)
[![](https://img.shields.io/github/actions/workflow/status/thegamecracks/abattlemetrics/ruff-format.yml?style=flat-square&logo=ruff&label=style)](https://docs.astral.sh/ruff/)

An asyncio wrapper for the battlemetrics API.

## Installation

To install the latest release from PyPI (requires Python 3.8 or above):

```sh
pip install abattlemetrics
```

To install the development version from GitHub (requires Git):

```sh
pip install git+https://github.com/thegamecracks/abattlemetrics
```

## Notice

I am currently not maintaining this project as this wrapper has
been sufficient for my needs. Many endpoints have not been implemented,
but I will still accept PRs following the [contributing guide](CONTRIBUTING.md).

## License

This project uses the [MIT](LICENSE) license.
meshdb 0.1.2
A python package for managing a Meshtastic node database.
Requires Python: <3.14,>=3.9

# meshdb

A lightweight Python library for storing Meshtastic node, telemetry, and message data in per-node SQLite databases.

## Installation

Install from source within a virtual environment:

```bash
git clone https://github.com/pdxlocations/meshdb.git
cd meshdb
pip install -e .
```

Or install via Poetry:

```bash
poetry install
```

## Quick Usage Example

Set a default database path and handle incoming packets:

```python
from meshdb import handle_packet, set_default_db_path

set_default_db_path("./data")

packet = {
    "from": 12345678,
    "rxTime": 1700000000,
    "decoded": {
        "portnum": "NODEINFO_APP",
        "user": {"longName": "TestNode"}
    }
}

handle_packet(packet, node_database_number=12345678)
```

## Viewing Stored Data

You can run:

```bash
python -m meshdb --db ./data
```

This prints a JSON summary of all known nodes and their latest telemetry, if available.

## Lookups in Code

```python
import meshdb

node = meshdb.get_node(12345678, owner_node_num=12345678)
battery = meshdb.get_node_metric("TestNode", "battery_level", owner_node_num=12345678)
```

## Project Status

Early development. Schema and API changes may occur.
nonebot-plugin-docs 2.4.4
View NoneBot2 Docs Locally
Requires Python: <4.0,>=3.9
Keywords: nonebot, nonebot2, docs

<p align="center">
  <a href="https://nonebot.dev/"><img src="https://nonebot.dev/logo.png" width="200" height="200" alt="nonebot"></a>
</p>

<div align="center">

# nonebot-plugin-docs

_✨ NoneBot 本地文档插件 ✨_

</div>

<p align="center">
  <a href="https://raw.githubusercontent.com/nonebot/nonebot2/master/LICENSE">
    <img src="https://img.shields.io/github/license/nonebot/nonebot2.svg" alt="license">
  </a>
  <a href="https://pypi.python.org/pypi/nonebot-plugin-docs">
    <img src="https://img.shields.io/pypi/v/nonebot-plugin-docs.svg" alt="pypi">
  </a>
  <img src="https://img.shields.io/badge/python-3.9+-blue.svg" alt="python">
</p>

## 使用方式

加载插件并启动 Bot ，在浏览器内打开 `http://host:port/website/`。

具体网址会在控制台内输出。
toologan 0.1.1
Add your description here
Requires Python: >=3.11

# Toologan

## A General Toolbag for Logan:


This is a collection of functions, tools, and things I find helpful to have in python. I have worked in the language and there are things I do and don't like about the language. 

Main things that I dislike (and thus, these tools might try to fix):
 
 - Exceptions: They are sort of a nightmare to keep track of and since Python lacks an enforced type or reporting of exception throwing, any function call from a library could potentially bring your program to crash with little to no wanring. 
 - A Lack of Type Enforcement: pretty self explanatory.
 - PODS: Dataclasses are a good step by they lack a lot of potential functionality (like dict-style access by default).


The tools here address issues outside of those gripes, but much of this toolbag has been made to address these issues. 


## Contribution:

Though I appreciate the interest, this is a tool bag for me and the chance of getting code in here that I don't write myself it minimal. 

But please reach out!

### Contact: 

bsky: @doing-fine-thanks