semvec/pypi-packages huggingface dataset:
iflow-mcp_cnitlrt-headless-ida-mcp-server 0.1.0
Add your description here
Requires Python: >=3.11

# Acknowledgments

This project builds upon the work of:
- Tools code adapted from [ida-pro-mcp](https://github.com/mrexodia/ida-pro-mcp) by mrexodia
- Utilizes the [headless-ida](https://github.com/DennyDai/headless-ida) library by DennyDai

# Headless IDA MCP Server

If you want to run the server directly as a cli app, rather than an IDA plugin interactively,you can chose it.

## Project Description

This project uses IDA Pro's headless mode to analyze binary files and provides a suite of tools via MCP to manage and manipulate functions, variables, and more.

## Prerequisites

- Python 3.12 or higher
- IDA Pro with headless support (idat) https://github.com/DennyDai/headless-ida

## Installation

1. Clone the project locally:

   ```bash
   git clone https://github.com/cnitlrt/headless-ida-mcp-server.git 
   cd headless-ida-mcp-server
   ```

2. Install dependencies:

   ```bash
   uv python install 3.12
   uv venv --python 3.12
   uv pip install -e .
   ```

## Configuration

1. Copy the example environment file:
   ```bash
   cp .env_example .env
   ```

2. Configure the following environment variables in `.env`:

   - `IDA_PATH`: Path to IDA Pro's headless executable (idat), e.g., `/home/ubuntu/idapro/idat`
   - `PORT`: Port number for the MCP server, e.g., `8888`
   - `HOST`: Host address for the MCP server, e.g., `127.0.0.1`
   - `TRANSPORT`: MCP transport mode (`sse` or `stdio`)

## Usage

1. Start the server:
   ```bash
   uv run headless_ida_mcp_server
   ```

2. Connect to the server using an MCP client:

   Debug it: 
   ```bash
   npx -y @modelcontextprotocol/inspector
   ```
   or
   ```json
   {
   "mcpServers": {
      "ida": {
         "command": "/path/to/uv",
         "args": ["--directory","path/to/headless-ida-mcp-server","run","headless_ida_mcp_server"]
      }
   }
   }
   ```
![](./images/pic.png)

![](./images/pic2.png)
iflow-mcp_showkeyjar-robot-mcp-server 0.1.0
为大语言模型提供机器人控制能力的MCP服务器
Requires Python: >=3.10

# robot-mcp-server

为大语言模型提供机器人控制能力的MCP服务器

[![Python Version](https://img.shields.io/badge/python-3.10%2B-blue)](https://www.python.org/)
[![License](https://img.shields.io/badge/license-MIT-green)](LICENSE)

## 功能特性

- ✅ 支持宇树机器人运动控制
- ✅ 支持大疆无人机起飞/降落控制
- ✅ 基于Model Context Protocol (MCP) 的标准接口
- 📡 实时状态监控
- 🛑 紧急停止机制
- 📊 完善的日志记录

## 安装指南

### 前置要求
- Python 3.10+
- 宇树机器人SDK2 (自动安装)
- 大疆Tello无人机SDK (自动安装)

```bash
# 创建并激活虚拟环境
python -m venv .venv
.venv\Scripts\activate

# 安装依赖
pip install git+https://github.com/unitreerobotics/unitree_sdk2_python.git
pip install djitellopy
```

## 快速开始

```python
from modelcontextprotocol import Client

# 连接MCP服务
client = Client.connect_stdio()

# 控制宇树机器人
client.call_tool("unitree_connect", {})
client.call_tool("unitree_move", {"velocity": 1.5})

# 控制大疆无人机
client.call_tool("dji_connect", {})
client.call_tool("dji_takeoff", {"height": 2.0})
```

## API文档

### 宇树机器人工具
- `unitree_connect`: 建立机器人连接
- `unitree_move(velocity: float, duration: float)`: 控制移动
- `unitree_stop()`: 紧急停止

### 大疆无人机工具
- `dji_connect`: 建立无人机连接
- `dji_takeoff(height: float)`: 起飞到指定高度
- `dji_land()`: 安全降落

## 开发指南

项目结构：
```
├── src/
│   ├── main.py          # 主服务入口
│   ├── unitree_adapter.py # 宇树机器人适配器
│   └── dji_adapter.py   # 大疆无人机适配器
├── examples/            # 使用示例
├── requirements.txt     # 依赖列表
└── README.md            # 项目文档
```

## 贡献
欢迎提交Issue和PR，请遵循现有代码风格并添加适当测试。

## 授权协议
[MIT License](LICENSE)
easy-sm 1.0.2
Easy SageMaker Ops
Requires Python: >=3.13

This package makes it easier to work with SageMaker by enabling rapid prototyping with local training, processing, and deployment.
Provides seamless integration between local Docker-based development and AWS SageMaker cloud operations.
Features include: local training/processing/deployment, cloud job management, endpoint management, and job monitoring.
This is an experimental package and API is likely to evolve and may break.
Recommended to validate before updating.
metahq-core 1.0.0
Core API for the meta-hq CLI.
Requires Python: >=3.12
Keywords: Data Curation, Database, Public Biomedical Data

# metahq-core

![Core Tests](https://github.com/krishnanlab/meta-hq/workflows/Core%20Tests/badge.svg)
![Python](https://img.shields.io/badge/python-3.12+-blue.svg)
![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)
![pypi](https://img.shields.io/pypi/v/metahq-core.svg)
[![License](https://img.shields.io/badge/License-BSD_3--Clause-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)

Backend package for `metahq-cli` which is also available on PyPI. Currently this package
is solely intended to be used through the MetaHQ CLI.

## Docs

Documentation: [https://meta-hq.readthedocs.io/en/latest](https://meta-hq.readthedocs.io/en/latest/)

Source Code: [https://github.com/krishnanlab/meta-hq/tree/main/packages/core](https://github.com/krishnanlab/meta-hq/tree/main/packages/core)

## Install

```bash
pip install metahq-core
```
iflow-mcp_huangzelincute-github-mcp-server 0.1.0
Add your description here
Requires Python: >=3.11

# GitHub API MCP Server

用于GitHub搜索API的MCP。

## 环境要求

- [uv](https://docs.astral.sh/uv/) - 一个项目管理工具，可以很方便管理依赖。

## 使用方法

1、安装依赖

```
uv PyGithub python-dotenv
```

2、在Client里配置Server

```json
{
  "mcpServers": {
    "github_server": {
      "command": "uv",
      "args": [
        "--directory",
        "D:/blog/github-mcp-server",
        "run",
        "github_server.py"
      ]
    }
  }
}

```

3、在Client里使用
bedrock_bio 1.1.0
Open-Access Computational Biology Datasets
Requires Python: >=3.10


# bedrockbio

Open-Access Computational Biology Datasets

## Description

Efficiently access a curated library of open-access computational biology 
datasets. Datasets support predicate pushdown and projection to the cloud 
storage backend, enabling quick, iterative access to otherwise massive, 
unwieldy datasets.

`bedrock_bio` consists of two user-facing functions:

- `list_datasets()`: returns a list of available datasets
- `load_dataset('<name>')`: takes a dataset name and returns a lazily-evaluated
  data frame. 
  
`polars` verbs (`filter`, `select`) can be used on the data frame returned by
`load_dataset` to push down row filters and column selections to the storage 
backend. This means that only a subset of rows and columns need to be actually
downloaded and read into memory.

## Installation

To install the latest release from [PyPI](https://pypi.org/project/bedrock_bio/):

```bash
pip install bedrock-bio
```

To install the current development version from 
[GitHub](https://github.com/bedrock-bio/bedrock-bio-client/python):

```bash
pip install git+https://github.com/bedrock-bio/bedrock-bio-client.git@main#subdirectory=python
```

## Examples

Load the package (and `polars` for downstream data frame manipulation):

```python
import bedrock_bio as bb
import polars as pl
```

List available datasets:

```python
bb.list_datasets()
```

Lazily load a dataset:

```python
lf = bb.load_dataset('ukb_ppp/pqtls')
```

Inspect the contents of a dataset before downloading and collecting into 
memory:

```python
print(lf.collect_schema())
```

Filter rows, select columns, and collect the relevant subset into an 
in-memory data frame:

```python
df = lf \
  .filter(
    pl.col('ancestry') == 'EUR', 
    pl.col('protein') == 'A0FGR8'
  ) \
  .select(
    'chromosome', 
    'position', 
    'effect_allele', 
    'other_allele', 
    'beta', 
    'neg_log_10_p_value'
  ) \
  .collect()
```

## Dataset Requests

To request the addition of a new dataset to the library, open an
[issue on GitHub](https://github.com/bedrock-bio/bedrock-bio-client/issues).
composo 0.2.50
Composo Python SDK
Requires Python: >=3.9

# Composo Python SDK

Composo provides a Python SDK for evaluating LLM applications.

## Installation

```bash
pip install composo
```

## Quick Start

```python
from composo import Composo

composo_client = Composo()

result = composo_client.evaluate(
    messages=[
        {"role": "user", "content": "Hello"},
        {"role": "assistant", "content": "Hello! How can I help you today?"}
    ],
    criteria="Reward responses that are friendly"
)

print(f"Score: {result.score}")
print(f"Explanation: {result.explanation}")
```

## Documentation

For detailed documentation, API reference, examples, and guides, please visit [docs.composo.ai](https://docs.composo.ai).
yara-x 1.13.0
Python bindings for YARA-X
Requires Python: >=3.9
Keywords: pattern-matching, cybersecurity, forensics, malware, yara

![PyPI - Version](https://img.shields.io/pypi/v/yara-x)
![PyPI - License](https://img.shields.io/pypi/l/yara-x)
[![Documentation](https://img.shields.io/badge/doc-latest-blue.svg)](https://virustotal.github.io/yara-x/docs/api/python)
[![Downloads](https://pepy.tech/badge/yara-x)](https://pepy.tech/project/yara-x)
[![Downloads per week](https://pepy.tech/badge/yara-x/week)](https://pepy.tech/project/yara-x)
![GitHub Repo stars](https://img.shields.io/github/stars/VirusTotal/yara-x)

The official Python library for [YARA-X](https://virustotal.github.io/yara-x).
Supports Python 3.9+ in Linux, MacOS and Windows.

```python
import yara_x

rules = yara_x.compile('''
  rule test { 
    strings: 
      $a = "foobar" 
    condition: 
      $a
  }''')

results = rules.scan(b"foobar")

assert results.matching_rules[0].identifier == "test"
assert results.matching_rules[0].patterns[0].identifier == "$a"
assert results.matching_rules[0].patterns[0].matches[0].offset == 0
assert results.matching_rules[0].patterns[0].matches[0].length == 6
```

For more information about how to use this library, please check
the [documentation](https://virustotal.github.io/yara-x/docs/api/python).
Splatlogger 1.5.2
A PID/PNID grabber and match logger for Splatoon using TCPGecko.
Requires Python: >=3.11

# Splatlogger
A PID/PNID grabber and match logger for Splatoon using TCPGecko, written in Python.

## Prerequisites
You'll need a modded Wii U running either the Tiramisu or Aroma environment, as well as Python 3.11 or newer installed on your system (on Android devices you can use Termux).

On Tiramisu, use [TCPGecko](https://github.com/BullyWiiPlaza/tcpgecko) (Geckiine or SDGeckiine will work as well).

On Aroma, install the [TCPGecko Aroma plugin](https://github.com/spoongaming61/TCPGeckoAroma).

## Installation
Install the package from PyPI:
```
python -m pip install Splatlogger
```

Or download and install the latest release from GitHub:
```
python -m pip install /path/to/Splatlogger-1.x.zip
```

Alternatively, you can skip the installation and instead run the module directly from the source code.

## Usage
Run Splatlogger with:
```
python -m splatlogger -ip IP [options]
```
where `IP` is your Wii U's LAN IP address
(if you have your scripts directory in your PATH, you can also run `splatlogger -ip IP [options]`).

Options:
- `-log-level [option]` - Set how much data should be logged.
  - `none` - Don't create a log file (default).
  - `basic` - Log only basic player information (name, PID, PNID, region).
  - `full` - Log all player information (basic + team, level, rank, appearance, gear, weapons).
  - `stats` - Log all player information and player stats (points, kills, deaths). Requires the match to end to finish logging.

- `-auto [option]` - Enable auto logging. When enabled will automatically log every match you play (log level must be at least `basic`).
  - `all` - Save a log of all matches you play (default).
  - `latest` - Save a log of only the latest match

- `-aroma` - Enable Aroma mode.

- `-silent` - Disable printing logs to the console.

Logs are saved in `/[User]/Documents/Splatlogger/logs/[Date]`.

To always run with the same IP and options, create an `args.txt` file in `/[User]/Documents/Splatlogger` and put all the arguments in there.
Afterward run without any arguments.

Only one program can be connected to TCPGecko at a time. If you have something else connected, disconnect it beforehand.

## Credits
- [pyGecko](https://github.com/wiiudev/pyGecko) authors for most of `tcpgecko.py`.

- Everyone who contributed to [PNIDGrab](https://github.com/JerrySM64/PNIDGrab) and other similar PID grabbers as those were used as a reference.
django-tasks-db 0.12.0
An ORM-based backend for Django Tasks
Requires Python: >=3.10

# Django Tasks DB

[![CI](https://github.com/RealOrangeOne/django-tasks-db/actions/workflows/ci.yml/badge.svg)](https://github.com/RealOrangeOne/django-tasks-db/actions/workflows/ci.yml)
![PyPI](https://img.shields.io/pypi/v/django-tasks-db.svg)
![PyPI - Python Version](https://img.shields.io/pypi/pyversions/django-tasks-db.svg)
![PyPI - Status](https://img.shields.io/pypi/status/django-tasks-db.svg)
![PyPI - License](https://img.shields.io/pypi/l/django-tasks-db.svg)


A [Django Tasks](https://docs.djangoproject.com/en/stable/topics/tasks/) backend which uses Django's ORM to store tasks in the database.

## Installation

```
python -m pip install django-tasks
```

First, add `django_tasks_db` to your `INSTALLED_APPS`:

```python
INSTALLED_APPS = [
    # ...
    "django_tasks_db",
]
```

Finally, add it to your `TASKS` configuration:

```python
TASKS = {
    "default": {
        "BACKEND": "django_tasks_db.DatabaseBackend",
        "QUEUES": ["default"]
    }
}
```

## Usage

### Worker

You can run the `db_worker` command to run tasks as they're created. Check the `--help` for more options.

```shell
./manage.py db_worker
```

In `DEBUG`, the worker will automatically reload when code is changed (or by using `--reload`). This is not recommended in production environments as tasks may not be stopped cleanly.

### Pruning old tasks

After a while, tasks may start to build up in your database. This can be managed using the `prune_db_task_results` management command, which deletes completed tasks according to the given retention policy. Check the `--help` for the available options.

### Customizing the task id

By default, the database worker uses `uuid.uuid4` to generate a task id. This can be customized using the `id_function` option:

```python
TASKS = {
    "default": {
        "BACKEND": "django_tasks_db.DatabaseBackend",
        "OPTIONS": {
            "id_function": "uuid.uuid7"
        }
    }
}
```

The `id_function` must return a UUID (either `uuid.UUID` or string representation). Additionally, the PostgreSQL-specific [`RandomUUID`](https://docs.djangoproject.com/en/stable/ref/contrib/postgres/functions/#django.contrib.postgres.functions.RandomUUID) or other database expressions are supported on Django 6.0+.

## Contributing

See [CONTRIBUTING.md](./CONTRIBUTING.md) for information on how to contribute.

Note: Prior to `0.12.0`, this backend was included in [`django-tasks`](https://github.com/RealOrangeOne/django-tasks/). Whilst the commit history was cleaned up, it's still quite messy. Don't look too closely.
iflow-mcp_parsedark-mcp_stock 0.1.0
Stock Analysis MCP Server - Provides various tools for accessing and analyzing stock market data
Requires Python: >=3.8

# Stock Analysis MCP Server

This project is a server built using the `FastMCP` framework, providing various tools for accessing and analyzing stock market data.

## Features

The server exposes the following tools:

*   **Concept Power Tools (`/stock`)**: Analyzes the strength of stock concept sectors based on fund flow and price change.
*   **Finance Tools (`/finance`)**: Provides access to stock financial core indicators and company information.
*   **Stock F10 Tools (`/f10`)**: Fetches and summarizes Stock F10 information.
*   **Market Emotion Tools (`/market`)**: Retrieves and summarizes A-share market emotion indicators.
*   **Stock Keep Up Tools (`/stockUp`)**: Provides lists of continuous limit-up stocks and limit-up stocks.
*   **Web Search Tools (Tavily) (`/websearch`)**: Provides a web search tool.

## Setup and Installation

1.  **Clone the repository:**

    ```bash
    git clone <repository_url>
    cd mcp_stock
    ```

2.  **Create a virtual environment (recommended):**

    ```bash
    python -m venv venv
    source venv/bin/activate
    ```

3.  **Install dependencies:**

    Install the required packages using pip:

    ```bash
    pip install -r requirements.txt
    playwright install
    ```

4.  **Configuration:**

    Some tools might require API keys or other configuration. Please refer to the `config.py` file and potentially create a `.env` file if necessary (based on `os.getenv` usage in `server.py`).
    ```
    TAVILY_API_KEY=
    ```

5.  **Run the server:**

    You can run the server using the `server.py` script. The server will listen on the port specified by the `PORT` environment variable, defaulting to 8000.

    ```bash
    fastmcp run server.py --transport=sse --port=8000 --host=0.0.0.0
    ```

    To run on a specific port:

    ```bash
    fastmcp run server.py --transport=sse --port=8000 --host=0.0.0.0
    ```

## Usage

Once the server is running, you can interact with the tools via the `/mcp` prefix followed by the tool's mount path (e.g., `/mcp/stock`, `/mcp/finance`). The specific endpoints and expected parameters for each tool can be found by examining the tool definitions within each tool's Python file.
django-tasks-rq 0.12.0
A Django Tasks backend which uses RQ as its underlying queue
Requires Python: >=3.10

# Django Tasks RQ

[![CI](https://github.com/RealOrangeOne/django-tasks-rq/actions/workflows/ci.yml/badge.svg)](https://github.com/RealOrangeOne/django-tasks-rq/actions/workflows/ci.yml)
![PyPI](https://img.shields.io/pypi/v/django-tasks-rq.svg)
![PyPI - Python Version](https://img.shields.io/pypi/pyversions/django-tasks-rq.svg)
![PyPI - Status](https://img.shields.io/pypi/status/django-tasks-rq.svg)
![PyPI - License](https://img.shields.io/pypi/l/django-tasks-rq.svg)


A [Django Tasks](https://docs.djangoproject.com/en/stable/topics/tasks/) backend which uses RQ as its underlying queue.

## Installation

```
python -m pip install django-tasks
```

First, add `django_tasks_rq` to your `INSTALLED_APPS`:

```python
INSTALLED_APPS = [
    # ...
    "django_tasks_rq",
]
```

Finally, add it to your `TASKS` configuration:

```python
TASKS = {
    "default": {
        "BACKEND": "django_tasks_rq.RQBackend",
        "QUEUES": ["default"]
    }
}
```

## Usage

The RQ-based backend acts as an interface between [Django's tasks interface](https://docs.djangoproject.com/en/stable/topics/tasks/) and `RQ`, allowing tasks to be defined and enqueued using `django.tasks`, but stored in Redis and executed using RQ's workers.

Any queues defined in `QUEUES` must also be defined in `django-rq`'s `RQ_QUEUES` setting.

### Job class

To use `rq` with `django-tasks-rq`, a custom `Job` class must be used. This can be passed to the worker using `--job-class`:

```shell
./manage.py rqworker --job-class django_tasks_rq.Job
```

### Priorities

`rq` has no native concept of priorities - instead relying on workers to define which queues they should pop tasks from in order. Therefore, `task.priority` has little effect on execution priority.

If a task has a priority of `100`, it is enqueued at the top of the queue, and will be the next task executed by a worker. All other priorities will enqueue the task to the back of the queue. The queue value is not stored, and will always be `0`.

## Contributing

See [CONTRIBUTING.md](./CONTRIBUTING.md) for information on how to contribute.

Note: Prior to `0.12.0`, this backend was included in [`django-tasks`](https://github.com/RealOrangeOne/django-tasks/). Whilst the commit history was cleaned up, it's still quite messy. Don't look too closely.
ipykernel 7.2.0
IPython Kernel for Jupyter
Requires Python: >=3.10
Keywords: Interactive, Interpreter, Shell, Web

# IPython Kernel for Jupyter

[![Build Status](https://github.com/ipython/ipykernel/actions/workflows/ci.yml/badge.svg?query=branch%3Amain++)](https://github.com/ipython/ipykernel/actions/workflows/ci.yml/badge.svg?query=branch%3Amain++)
[![Documentation Status](https://readthedocs.org/projects/ipykernel/badge/?version=latest)](http://ipykernel.readthedocs.io/en/latest/?badge=latest)

This package provides the IPython kernel for Jupyter.

## Installation from source

1. `git clone`
1. `cd ipykernel`
1. `pip install -e ".[test]"`

After that, all normal `ipython` commands will use this newly-installed version of the kernel.

## Running tests

Follow the instructions from `Installation from source`.

and then from the root directory

```bash
pytest
```

## Running tests with coverage

Follow the instructions from `Installation from source`.

and then from the root directory

```bash
pytest -vv -s --cov ipykernel --cov-branch --cov-report term-missing:skip-covered --durations 10
```

## About the IPython Development Team

The IPython Development Team is the set of all contributors to the IPython project.
This includes all of the IPython subprojects.

The core team that coordinates development on GitHub can be found here:
https://github.com/ipython/.

## Our Copyright Policy

IPython uses a shared copyright model. Each contributor maintains copyright
over their contributions to IPython. But, it is important to note that these
contributions are typically only changes to the repositories. Thus, the IPython
source code, in its entirety is not the copyright of any single person or
institution. Instead, it is the collective copyright of the entire IPython
Development Team. If individual contributors want to maintain a record of what
changes/contributions they have specific copyright on, they should indicate
their copyright in the commit message of the change, when they commit the
change to one of the IPython repositories.

With this in mind, the following banner should be used in any source code file
to indicate the copyright and license terms:

```
# Copyright (c) IPython Development Team.
# Distributed under the terms of the Modified BSD License.
```
Flask-Multipass 0.11.2
A pluggable solution for multi-backend authentication with Flask
Requires Python: ~=3.10

Flask-Multipass
===============

.. image:: https://raw.githubusercontent.com/indico/flask-multipass/master/artwork/flask-multipass.png

.. image:: https://readthedocs.org/projects/flask-multipass/badge/?version=latest
    :target: https://flask-multipass.readthedocs.org/
.. image:: https://github.com/indico/flask-multipass/workflows/Tests/badge.svg
    :target: https://github.com/indico/flask-multipass/actions

Flask-Multipass provides Flask with a user authentication/identity
system which can use different backends (such as local users,
LDAP and OAuth) simultaneously.

It was developed at CERN and is currently used in production by `Indico <https://github.com/indico/indico>`_.

There are bult-in authentication and identity providers for:

 * `Static (hardcoded) credentials <https://github.com/indico/flask-multipass/blob/master/flask_multipass/providers/static.py>`_
 * `Local (SQLAlchemy DB) authentication <https://github.com/indico/flask-multipass/blob/master/flask_multipass/providers/sqlalchemy.py>`_
 * `Authlib (OAuth/OIDC) <https://github.com/indico/flask-multipass/blob/master/flask_multipass/providers/authlib.py>`_
 * `SAML <https://github.com/indico/flask-multipass/blob/master/flask_multipass/providers/saml.py>`_
 * `Shibboleth <https://github.com/indico/flask-multipass/blob/master/flask_multipass/providers/shibboleth.py>`_
 * `LDAP <https://github.com/indico/flask-multipass/blob/master/flask_multipass/providers/ldap/providers.py>`_

Those can be used simultaneously and interchangeably (e.g. authenticate with OAuth and search users with LDAP).

Documentation is available at https://flask-multipass.readthedocs.org