semvec/pypi-packages huggingface dataset:
cohdl 0.2.4
A Python to VHDL compiler
Requires Python: >=3.11

# CoHDL

CoHDL is a hardware description language embedded in Python. It translates a subset of Python into synthesizable VHDL.

---

## examples/introduction

You can find an introduction and many examples in this [documentation repository](https://github.com/alexander-forster/cohdl_documentation).

## features

At its core CoHDLs language model is very similar to VHDL. Designs are made up of signals and variables built from types like `Bit` and `BitVector`. There are concurrent contexts, for expressions that would appear in the architecture scope of VHDL entities and sequential contexts equivalent to VHDL processes.

Code that uses only basic features also found in VHDL (if-statements, signal/variable assignments, arithmetic operators and so on) essentially looks like VHDL written in Python syntax. On top of that CoHDL supplies many additional features


### coroutines

The initial motivation for CoHDL was to explore how well coroutines, found in many modern programming languages, translate to the domain of hardware description languages.

CoHDL turns Pythons async/await style coroutines into VHDL state machines. This process is completely deterministic and allows clock accurate modeling of sequential processes. The main advantage over explicit state machine implementations is, that coroutines are reusable.

Common sequences such as AXI transactions can be defined once and instantiated whenever needed.

### supported Python subset

The following is an incomplete list of Python constructs supported in synthesizable contexts

* statements
    * if
    * for
    * if expressions
    * generator expressions
    * most operators
* functions
    * arbitrary argument types
    * default arguments
    * keyword arguments
    * variadic arguments
    * compile time recursion
    * compile time evaluated builtin functions
* classes
    * member access
    * methods
    * operator overloading
    * inheritance
    * overriding methods
* python container types
    * list
    * dict
* coroutines

### meta programming

Since CoHDL is embedded in Python, it is possible to run arbitrary code before and after the compilation. This can be used to load configuration files or run external programs like simulators or synthesis tools on the generated VHDL.

For a working example of this checkout [cohdl_xil](https://github.com/alexander-forster/cohdl_xil). It generates Makefile projects for CoHDL designs targeting Xilinx FPGAs.

---
## getting started

CoHDL requires Python3.11 or higher and has no further dependencies. You can install it by running

```shell
python3 -m pip install cohdl
```

in a terminal window. You should then be able to run the code snippets, found in the [introduction repository](https://github.com/alexander-forster/cohdl_documentation) and implement own designs.
c-four-five-classifier 0.1.0
Python implementation of C4.5 decision tree algorithm
Requires Python: >=3.6

# C4.5 Classifier

[![PyPI Version](https://img.shields.io/pypi/v/c-four-five-classifier.svg)](https://pypi.org/project/c-four-five-classifier/)
[![Python Version](https://img.shields.io/badge/python-3.6%2B-blue.svg)](https://www.python.org/downloads/)

A Python implementation of the C4.5 decision tree algorithm with pruning support.

## Features

- C4.5 algorithm with gain ratio splitting criterion
- Pre-pruning via minimum samples and gain ratio thresholds
- Tree visualization using Graphviz
- Pandas DataFrame integration

## Installation

```bash
pip install c_four_five_classifier
mcp-server-moralis 0.1.2
基于Model Context Protocol (MCP)的Moralis区块链API服务器
Requires Python: >=3.12

# Moralis API MCP 服务

这是一个基于 Model Context Protocol (MCP) 的 Moralis API 集成服务，提供全面的区块链数据访问功能。该服务允许 AI 助手（如 Claude）查询和分析区块链数据，包括钱包信息、代币数据、NFT 资产和 DeFi 活动等。

## 功能

* 钱包分析：交易历史、代币余额、NFT 持有等
* 代币工具：价格查询、元数据获取、转账记录等
* NFT 功能：元数据查询、所有权分析、交易记录等
* DeFi 分析：协议摘要、持仓信息等
* 区块链工具：区块查询、交易解析等

## 环境要求

* Python 3.12 或更高版本
* mcp 库 >= 1.6.0
* fastmcp >= 2.2.0
* 有效的 Moralis API 密钥

## 安装

1. 克隆本仓库
```bash
git clone <仓库地址>
cd mcp-server-moralis
```

2. 创建并激活虚拟环境
```bash
python -m venv .venv
.venv\Scripts\activate  # Windows
source .venv/bin/activate  # Linux/Mac
```

3. 安装依赖
```bash
pip install -e .
```

4. 创建 `.env` 文件并添加 Moralis API 密钥
```
MORALIS_API_KEY=您的密钥
DEFAULT_CHAIN=eth
DEFAULT_LIMIT=100
```

## 使用方法

### 使用 MCP CLI 运行服务

```bash
mcp dev main.py
```

这将使用 MCP Inspector 启动服务，可通过本地网页界面测试其功能。

### 安装到 Claude Desktop

要在 Claude Desktop 中使用此服务：

```bash
mcp install main.py --name "Moralis API"
```

### 直接执行

```bash
python main.py
```

## 可用的工具

### 钱包相关工具

1. `get_wallet_balance` - 获取钱包的代币余额
2. `get_wallet_transactions` - 获取钱包的交易历史
3. `get_wallet_nfts` - 获取钱包持有的 NFT
4. `get_wallet_token_transfers` - 获取钱包的代币转账记录

### 代币相关工具

1. `get_token_price` - 获取代币当前价格
2. `get_token_metadata` - 获取代币元数据信息
3. `get_token_transfers` - 获取代币的转账记录
4. `get_token_holders` - 获取代币的持有者列表

### NFT 相关工具

1. `get_nft_metadata` - 获取 NFT 元数据
2. `get_nft_transfers` - 获取 NFT 的转账记录
3. `get_nft_owners` - 获取 NFT 的所有者列表
4. `get_nft_collections` - 获取钱包拥有的 NFT 合集

### DeFi 相关工具

1. `get_defi_positions` - 获取钱包的 DeFi 持仓
2. `get_defi_protocol_positions` - 获取钱包在特定协议的持仓
3. `get_defi_summary` - 获取钱包的 DeFi 活动摘要

### 区块链工具

1. `get_block_by_number` - 获取区块信息
2. `get_transaction_by_hash` - 获取交易详情
3. `get_logs_by_address` - 获取合约日志

## 示例使用场景

使用 Claude 与此 MCP 服务的交互示例：

1. 查询钱包余额：「请查询钱包地址 0x123...abc 的 ETH 余额」
2. 分析 NFT 持有：「分析钱包 0x456...def 拥有的 NFT 资产」
3. 跟踪代币价格：「获取 USDT 的最新价格信息」
4. 了解交易详情：「解析交易哈希 0xabc...123 的详细信息」
5. DeFi 分析：「查看钱包 0x789...ghi 在 Uniswap 的流动性提供情况」

## 支持的区块链

- Ethereum (eth)
- BSC (bsc)
- Polygon (polygon)
- Avalanche (avalanche)
- Fantom (fantom)
- Cronos (cronos)
- Arbitrum (arbitrum)

## 注意事项

* 你需要一个有效的 Moralis API 密钥才能使用此服务
* 某些 API 调用可能受到 Moralis 的速率限制
* 确保遵守 Moralis 的服务条款和 API 使用政策

## 开发与测试

项目包含 examples 目录中的客户端示例代码，可用于了解如何从 Python 程序中调用此 MCP 服务。
tests 目录包含基本的单元测试，可确保服务核心功能正常工作。

## 许可证

MIT
vtx-yyjson 4.3.0
JSON parser & serializer built on yyjson
Keywords: json, parser, serializer, patcher

![PyPI - License](https://img.shields.io/pypi/l/yyjson.svg?style=flat-square)
![Tests](https://github.com/TkTech/py_yyjson/workflows/Run%20tests/badge.svg)

# py_yyjson

![py_yyjson Logo](misc/logo_small.png)

Fast and flexible Python JSON parsing built on the excellent [yyjson][]
project.

![GitHub Sponsors](https://img.shields.io/github/sponsors/tktech)
![PyPI - License](https://img.shields.io/pypi/l/yyjson)
![PyPI - Version](https://img.shields.io/pypi/v/yyjson)

- **Fast**: `yyjson` is several times faster than the builtin JSON module, and
  is [faster than most other JSON libraries][fast].
- **Flexible**: Parse JSON with strict specification compliance, or with
  extensions such as comments, trailing commas, Inf/NaN, numbers of any size,
  and more.
- **Lightweight**: `yyjson` is a lightweight project dependency with low
  maintenance overhead. It's written in C, and has no dependencies other than
  a C89 compiler. Built wheels are between 50kb and 800kb depending on the
  platform.
- **Portable**: Binary wheels are available for many versions of Python
  on many architectures, such as x86, x86_64, ARM, and ARM64, PowerPC, IBM Z,
  and more. PyPy is also supported. Supports Python 3.9 and newer.
- **Manipulate documents**: The fastest JSON Merge-Patch (RFC 7386), JSON Patch
  (RFC 6902), and JSON Pointer (RFC 6901) implementations available for Python
  allow you to manipulate JSON documents without deserializing them into Python
  objects.
- **Traceable**: `yyjson` uses Python's memory allocator by default, so you can
  trace memory leaks and other memory issues using Python's built-in tools.

## Documentation

Find the latest documentation at https://tkte.ch/py_yyjson.

[yyjson]: https://github.com/ibireme/yyjson
[fast]: https://github.com/tktech/json_benchmark
guidewd-sitemap-seo-tool 0.1.0
Analyze sitemap XML files for SEO optimization with suggestions using Streamlit.
Requires Python: >=3.6

# Guidewd Sitemap SEO Tool

**Guidewd** is a Sitemap SEO Analysis tool that helps you analyze XML sitemaps for SEO optimization.  
It extracts titles, descriptions, keywords, and suggests improvements.

---

## Features

- Analyze sitemap URLs for SEO metadata
- Check title and description lengths
- Suggest improvements for SEO
- Streamlit web interface
- Command-line usage support

---

## Installation

```bash
pip install guidewd-sitemap-seo-tool
Usage

1. Command Line
To analyze your sitemap directly:

```bash
guidewd-analyze --file uploaded_sitemap.xml
This will output a CSV file with SEO analysis.

2. Streamlit Web App
To launch the Streamlit interface locally:

```bash
streamlit run guidewd/streamlit_app.py
Then open the given localhost URL in your browser.

Input
Upload a .xml sitemap file that contains URLs.

Output
* Table of SEO metadata: Title, Description, Keywords

* SEO improvement suggestions

* Downloadable report (CSV)
idThree-classifier 0.1.1
A Python implementation of the ID3 decision tree algorithm
Requires Python: >=3.6

# idThree_classifier

[![Python Version](https://img.shields.io/badge/python-3.6%2B-blue.svg)](https://www.python.org/downloads/)
[![PyPI Version](https://img.shields.io/pypi/v/idThree-classifier.svg)](https://pypi.org/project/idThree-classifier/)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

A Python implementation of the ID3 decision tree algorithm with visualization capabilities.

## Features

- Pure Python implementation of ID3 algorithm
- Handles both categorical and numerical data
- Built-in tree visualization using Graphviz
- Simple API similar to scikit-learn
- Pandas DataFrame integration

## Installation

```bash
pip install idThree_classifier
quqfin 0.1.0
A quantum-accelerated quantitative finance library
Requires Python: >=3.8

# QuQFin: Quantum-Accelerated Quantitative Finance Library

QuQFin is a high-performance quantitative finance library that leverages NVIDIA's quantum computing frameworks (cuQuantum, custatevector, and cutensornet) to accelerate financial computations.

## Features

- **Options Pricing**
  - Black-Scholes model
  - Monte Carlo simulations
  - Exotic options (Asian, Barrier, Lookback)
  - Greeks calculations

- **Portfolio Optimization**
  - Markowitz optimization
  - Risk parity
  - Black-Litterman model

- **Risk Management**
  - Value at Risk (VaR)
  - Conditional VaR
  - Stress testing

- **Market Making**
  - Order book management
  - Market making strategies

- **Time Series Analysis**
  - GARCH models
  - Kalman filtering

## Installation

```bash
pip install quqfin
```

## License
This project is licensed under the MIT License - see the LICENSE file for details

## Citation

If you use QuQfin in your research, please cite the following paper:

``` bibtex
@software{quqfin2023,
  title = {QuQFin: A Quantum-Accelerated Quantitative Finance Library},
  year = {2025},
  url = {https://github.com/zazabap/quqfin}
}
```
viz-lower-limb 0.1.0
A simple Python template
Requires Python: <3.14,>=3.12

# template-python
Simple README.md for a Python project template.

## Install
To install the library run: `pip install change-me`

## Development
0. Install [Poetry](https://python-poetry.org/docs/#installing-with-the-official-installer)
1. `make init` to create the virtual environment and install dependencies
2. `make format` to format the code and check for errors
3. `make test` to run the test suite
4. `make clean` to delete the temporary files and directories
5. `poetry publish --build` to build and publish to https://pypi.org/project/change-me


## Usage
```
"""Basic docstring for my module."""

from loguru import logger

def main() -> None:
    """Run a simple demonstration."""
logger.info("Hello World!")

if __name__ == "__main__":
    main()
```
postcash 0.1.1
Asynchronous Notifications made easy with.
Requires Python: >=3.13

# postcash
Postcash – A lightweight, async-first notification library for Python and FastAPI. Send Emails (SMTP), Discord, and Telegram messages easily, with pluggable backends.


## Example usage

```python
import asyncio
from postcash import send_email

async def main():
    await send_email(
        to_email="someone@example.com",
        subject="Welcome!",
        body="Thanks for registering!",
    )

asyncio.run(main())
```
codespector 1.0.1
Assistant for reviewing your code
Requires Python: >=3.10

# CodeSpector

CodeSpector is a Python package designed to review code changes for quality and security issues using AI chat agents. It supports different chat agents like Codestral and ChatGPT.

## Features

- Automated code review using AI chat agents.
- Supports multiple chat agents and models.
- Generates detailed review reports in markdown format.
- Configurable via environment variables and command-line options.

## Installation

To install the package, use the following command:

```sh
pip install codespector
```

```sh
uv add codespector
```

## Usage

### Command-Line Interface

You can use the `codespector` command to start a code review. Below are the available options:

```sh
Usage: codespector [OPTIONS]

Options:
  --chat-token TEXT          Chat agent token  [env var: CODESPECTOR_CHAT_TOKEN]
  --chat-model TEXT          Choose the chat model to use  [env var: CODESPECTOR_CHAT_MODEL]
  --chat-agent TEXT          Choose the chat agent to use (codestral, chatgpt, deepseek)
                            or set your own  [env var: CODESPECTOR_CHAT_AGENT]
  -b, --compare-branch TEXT  Select the branch to compare the current one with
  --output-dir TEXT         Select the output directory  [default: codespector]
                            [env var: CODESPECTOR_OUTPUT_DIR]
  --system-content TEXT     Content which used in system field for agent
                            [env var: CODESPECTOR_SYSTEM_CONTENT]
  --prompt-content TEXT     Prompt content which included to review prompt
                            [env var: CODESPECTOR_PROMPT_CONTENT]
  --result-file TEXT        Set file for saving the result
                            [env var: CODESPECTOR_RESULT_FILE]
  --exclude-file-ext LIST   Exclude file extensions from the review
                            [env var: CODESPECTOR_EXCLUDE_FILE_EXT]
  --version                 Show the version and exit.
  --help                    Show this message and exit.
```

### Example

To run a code review, use the following command:

```sh
codespector --chat-token YOUR_CHAT_TOKEN --chat-agent codestral --compare-branch develop --result-file result.md --system-content "system content" --prompt-content "prompt content"
```

## Configuration

You can also configure CodeSpector using environment variables. Create a `.env` file in the root directory of your project with the following content:

```
CODESPECTOR_CHAT_TOKEN=your_token
CODESPECTOR_OUTPUT_DIR=codespector
CODESPECTOR_SYSTEM_CONTENT="Ты код ревьювер. Отвечай на русском"
CODESPECTOR_PROMPT_CONTENT="Оцени код на безопасноть, соблюдение лучших техник"
CODESPECTOR_RESULT_FILE="result.md"
CODESPECTOR_CHAT_AGENT=codestral
CODESPECTOR_CHAT_MODEL=your_model
CODESPECTOR_EXCLUDE_FILE_EXT=.pyc,.pyo
```

## Makefile Commands

- `lint`: Run linting and formatting checks.
- `format`: Format the code.
- `fix`: Fix linting issues and format the code.
- `test`: Run the tests.

## License

This project is licensed under the MIT License. See the `LICENSE` file for more details.
baseint 0.0.8
A Python class for handling integers in arbitrary bases.
Requires Python: >=3.6

# baseint
BaseInt is a small Python library for converting numbers in arbitrary bases.

## Features
- Create BaseInt instances from integers, strings, lists and tuples.
- Convert between bases easily.
- Supports custom character maps.

## Example

```py
from baseint import BaseInt

b = BaseInt("1111", 2)
print(b.toDecimal())        # 15
print(f"{b.sconvert(8)!r}") # BI:8:17
```
clapikit 0.1.0
CLI tool for OpenAPI specifications
Requires Python: >=3.10

# clapikit

CLI tool for OpenAPI specifications.

## Description

clapikit (CLI + API + Kit) is a command-line tool that parses OpenAPI YAML/JSON files and provides a CLI interface to interact with APIs defined in those specifications. It dynamically generates subcommands based on the endpoints defined in the OpenAPI specification.

## Installation

```bash
# Install with uvx
uvx clapikit

# Or install with pip
pip install clapikit
```

## Usage

```bash
# List available commands from an OpenAPI specification
clapikit --spec https://example.com/openapi.yaml

# Execute an API endpoint
clapikit --spec https://example.com/openapi.yaml getUserInfo

# Override server URL
clapikit --spec https://example.com/openapi.yaml --server http://custom-server:8080 getUserInfo

# Enable debug output
clapikit --spec https://example.com/openapi.yaml --debug getUserInfo

# Send data with a request
clapikit --spec https://example.com/openapi.yaml createUser --data '{"name": "John", "email": "john@example.com"}'

# Specify query parameters
clapikit --spec https://example.com/openapi.yaml searchUsers --params '{"role": "admin", "limit": 10}'

# Set custom headers
clapikit --spec https://example.com/openapi.yaml getUserInfo --headers '{"Authorization": "Bearer token123"}'

# Control output format
clapikit --spec https://example.com/openapi.yaml getUserInfo --output text
```

## Features

- Parse OpenAPI YAML/JSON files from local paths or URLs
- Dynamically generate subcommands based on API endpoints
- Execute API requests directly from the command line
- Override server URL from command line
- Debug mode for detailed logging
- Support for request data, query parameters, and headers
- JSON and text output formats

## Development

```bash
# Clone the repository
git clone https://github.com/youyo/clapikit.git
cd clapikit

# Install development dependencies
uv pip install -e .

# Run tests
python test_cli.py
```

## Mock Server for Testing

You can use Prism to run a mock server for testing:

```bash
npx @stoplight/prism-cli mock https://learn.openapis.org/examples/v3.0/api-with-examples.yaml
```

## License

See the LICENSE file for details.