semvec/pypi-packages huggingface dataset:
lunchsimple 0.3.1
Sync Wealthsimple with Lunch Money.
Requires Python: >=3.12

# Lunchsimple

Lunchsimple syncs your Wealthsimple activity with your Lunch Money budget.

Note: this project uses unofficial Wealthsimple APIs, which may be revoked at any time.

## Getting Started

### Prerequisites

To install Lunchsimple, you'll need:

- at least Python 3.12
- `pipx` (recommended)
- a functioning and accessible system keyring
  - should be true for most people, [read more](https://pypi.org/project/keyring/) about keyring access if you have issues

### Installing

You can install Lunchsimple from your terminal using `pipx` with:

```commandline
pipx install lunchsimple
```

Alternatively, without `pipx` you can try to use plain 'ol `pip`:

```commandline
pip install lunchsimple
```

However, doing so may require you to run as `sudo` which isn't recommended.

### Logging In

You'll need to first log in with your Wealthsimple credentials:

```commandline
lunchsimple login
```

Your login information is then stored locally on your system's keyring.

### Configuring

You must tell Lunchsimple which Wealthsimple accounts belong to which Lunch Money assets.

First, go to the [Accounts page](https://my.lunchmoney.app/accounts) in Lunch Money and create a new account for each Wealthsimple account you want to sync with.

Then, go to the [Developers page](https://my.lunchmoney.app/developers) in Lunch Money and generate an Access Token by clicking **Request New Access Token**.

Once you have the token, run the following:

```commandline
lunchsimple configure --access-token "your-access-token"
```

You can re-run `lunchsimple configure` anytime to re-configure (or switch budgets if using a test budget).

### Syncing

After logging in and configuring, you can finally push Wealthsimple activity into Lunch Money with:

```commandline
lunchsimple sync
```

By default, syncing starts from the beginning of the current month.

You can also pass a date to start syncing from:

```commandline
lunchsimple sync --start-date "2024-12-15"
```

## Contributing

Know Python? Want to improve Lunchsimple? Submit patches and let's chat.

## Credits

This project wouldn't be here without these awesome packages:

- WS-API <https://github.com/gboudreau/ws-api-python>
- Lunchable <https://github.com/juftin/lunchable>
- Typer <https://github.com/fastapi/typer>
docsloader 0.0.13
This is a documents loader.
Requires Python: >=3.11

# docsloader

## What is this?

- by: axiner
- docsloader
- This is a documents loader.

## Installation

This package can be installed using pip (Python>=3.11):
> pip install docsloader

- if you want to install all dependencies: `pip install docsloader[all]`
- if you want to install specific dependencies:
    - txt: `pip install docsloader[txt]`
    - csv: `pip install docsloader[csv]`
    - md: `pip install docsloader[md]`
    - xlsx: `pip install docsloader[xlsx]`
    - pptx: `pip install docsloader[pptx]`
    - docx: `pip install docsloader[docx]`
    - pdf: `pip install docsloader[pdf]`
    - img: `pip install docsloader[img]`
    - auto: `pip install docsloader[auto]`

## Usage

The `docsloader` package provides asynchronous document loaders for various file suffixes. It includes dedicated loaders
for specific file types and an `AutoLoader` that automatically selects the appropriate loader based on file suffix.

### Supported File Suffixes

The package supports loading documents from the following file suffixes:

- **Text Files**: `.txt`
- **CSV Files**: `.csv`
- **Markdown Files**: `.md`
- **HTML Files**: `.html`, `.htm`
- **Excel Files**: `.xlsx`, `.xls`
- **PowerPoint Files**: `.pptx`, `.ppt`
- **Word Files**: `.docx`, `.doc`
- **PDF Files**: `.pdf`
- **Image Files**: `.jpg`, `.jpeg`, `.png`

### Available Loaders

The package provides the following loader classes:

- `TxtLoader`: For Text files
- `CsvLoader`: For CSV files
- `MdLoader`: For Markdown files
- `HtmlLoader`: For HTML files
- `XlsxLoader`: For Excel files
- `PptxLoader`: For PowerPoint files
- `DocxLoader`: For Word files
- `PdfLoader`: For PDF files
- `ImgLoader`: For image files
- `AutoLoader`: Automatically selects the appropriate loader based on file suffix

All loader classes implement asynchronous `load` methods for efficient document processing.

### Example

```python
import asyncio

from docsloader import AutoLoader
from toollib.log import init_logger

logger = init_logger(__name__)


async def main(path_or_url: str):
    loader = AutoLoader(
        path_or_url=path_or_url,
        rm_tmpfile=False,
    )
    async for doc in loader.load():
        logger.info(doc)


if __name__ == "__main__":
    asyncio.run(main(path_or_url=r"E:/NewFolder/测试.docx"))
```

## License

This project is released under the MIT License (MIT). See [LICENSE](LICENSE)
marstar 0.1.1
Required NumPy,make sure that is installed.An ultimate game platform,available for Tic-Tac-Toe game and Murphy,the best number game ever.Use marstar.guide() to view the guide of this game,required NumPy.
Requires Python: >=3.7

# MarStar

    An ultimate game platform,available for Tic-Tac-Toe game and Murphy,the best number game ever.Use marstar.guide() to view the guide of this game,required NumPy.

Developer:              Marcy  huazii@gmail.com
senate-hearings 0.1.1
Scrape and clean U.S. Senate hearing transcripts.
Requires Python: >=3.11
Keywords: scraping, nlp, senate, transcripts, streamlit, quarto

# senate-hearings

Scrape, clean, and analyze U.S. Senate hearing transcripts from
[govinfo.gov](https://www.govinfo.gov/).

This package provides Python utilities for collecting Senate hearing metadata
and transcript text, expanding dynamically loaded content, and preparing
hearing data for analysis, NLP, and visualization workflows.

---

## Features

- Scrape Senate hearing metadata and transcript text
- Expand dynamically loaded “Show more” / accordion content
- Clean and normalize long transcript documents
- Extract structured fields (date, committee, title, text, etc.)
- Designed to support downstream NLP and dashboarding

---

## Installation

Basic installation:

```bash
pip install senate-hearings
```

## Documentation & demos 

### Home page (Github Pages)

https://lmikkelc5.github.io/senate-hearings/site/

### Full documentation (GitHub Pages) 

https://lmikkelc5.github.io/senate-hearings/site/documentation.html

### Tutorial (Github Pages)

https://lmikkelc5.github.io/senate-hearings/site/tutorial.html

### Technical Report

https://lmikkelc5.github.io/senate-hearings/site/technical_report.html

### Interactive EDA (Streamlit) 

Streamlit puts apps to sleep after 12 hours of inactivity, if you need us to reactivate it email me at mikkelc5@byu.edu

https://senate-hearings-555.streamlit.app/

### Source code (GitHub) 

https://github.com/lmikkelc5/senate-hearings
ipmaths 0.1.1
A Python module that performs common IPv4 addressing calculations for network engineers.
Requires Python: >=3.0
Keywords: ip, internet, networking, calculator

<!--
SPDX-FileCopyrightText: 2025 Ben Bonacci <ben at benbonacci dot com>

SPDX-License-Identifier: GPL-3.0-only
-->

# IPmaths

## About
IPmaths is a Python module that performs common IPv4 addressing calculations for network engineers. **Please note that this module is still under active development and some features may not be available or removed altogether.**

## Roadmap
As of the v0.1.0 release of this module, the following features are available:
- [ ] Calculate the best possible subnet mask for all the required hosts  
- [ ] Calculate all the usable host IPv4 addresses with the given subnet mask  
- [X] Check if the provided IPv4 address is valid  
- [X] Check if the provided subnet mask (in CIDR) is valid  
- [ ] Check if the provided subnet mask (in decimal) is valid  
- [X] Determine if the provided subnet mask is in CIDR or decimal form  
- [ ] Convert the provided subnet mask from CIDR to decimal form  
- [ ] Convert the provided subnet mask from decimal to CIDR form  
- [ ] An education mode that explains how to perform these calculations manually  

A v1.0.0 release is expected once all the following criteria has been met.

## How it works
_This section will be completed once IPmaths reaches the v1.0.0 release._

## Install
IPmaths is listed on the Python Package Index and can be download via Python's package manager, pip.

> ```pip install ipmaths```

Then, the module can be imported into the desired Python script.

> ```import ipmaths```

Alternatively, the module can be packaged and installed manually. Please consult Python's documentation for such instructions.
mcp-server-dpipblock 1.0.0
Add your description here
Requires Python: >=3.10
Keywords: ip, llm, mcp, time

Copyright (c) 2018 The Python Packaging Authority

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
llmhive 0.1.2
Python library for interacting with Large Language Models.
Requires Python: >=3.13

# llmhive

[![PyPI](https://img.shields.io/pypi/v/llmhive.svg)](https://pypi.org/project/llmhive/)
[![Python](https://img.shields.io/pypi/pyversions/llmhive.svg)](https://pypi.org/project/llmhive/)
[![License](https://img.shields.io/pypi/l/llmhive.svg)](LICENSE)

**llmhive** 是一个 Python 库，用于以统一的方式调用多种大语言模型（LLM），屏蔽底层 SDK 的差异，支持流式输出和插件式扩展。

## ✨ 特性

- 🚀 统一 API：无论是 OpenAI、Gemini、Ollama 等，都可以用相同的调用方式。
- 📡 支持流式输出：方便做实时响应的应用（如 CLI、聊天机器人、WebSocket 服务）。
- 🧩 插件化：可以很方便地扩展新的模型调用器（Caller）。
- 🔒 类型安全：基于现代 Python 类型提示，开发体验友好。
- 🛠️ 适配 [pyproject.toml] 可选依赖，按需安装。

## 📦 安装

默认安装基础库：

```bash
pip install llmhive
```

安装特定模型支持：

```bash
# OpenAI
pip install llmhive[openai]

# Google Gemini
pip install llmhive[gemini]

# Ollama (本地模型)
pip install llmhive[ollama]
```

## 🚀 快速上手

下面示例展示如何调用 OpenAI ChatGPT，并支持流式输出：

```python
from llmhive.callers.openai_caller import OpenAICaller
from llmhive.message import Message
from llmhive.caller import PromptContext

caller = OpenAICaller(model="gpt-4o-mini")

ctx = PromptContext(
    system_prompt="You are a helpful assistant.",
    history=[
        Message(role="user", content="Hello!"),
    ],
    is_stream=True,
)

for chunk in caller.call(ctx):
    print(chunk, end="", flush=True)
```

## 🌐 支持的模型提供商

| Provider | Extra Dependency          | Example Caller |
| -------- | ------------------------- | -------------- |
| OpenAI   | `pip install llmhive[openai]` | `OpenAICaller` |
| Gemini   | `pip install llmhive[gemini]` | `GeminiCaller` |
| Ollama   | `pip install llmhive[ollama]` | `OllamaCaller` |

未来计划支持：Anthropic Claude、Mistral、AWS Bedrock 等。

## 🧩 扩展新模型

要支持新的 LLM，只需继承 `Caller` 基类，实现 `call` 方法：

```python
from llmhive.caller import Caller, PromptContext
from collections.abc import Iterator

class MyLLMCaller(Caller):
    def __init__(self, model: str):
        self.model = model

    def call(self, ctx: PromptContext) -> Iterator[str]:
        # 这里实现你的模型调用逻辑
        yield "Hello from MyLLM!"
```

然后就可以像内置的 Caller 一样使用它。

## 📖 开发

克隆仓库：

```bash
git clone https://github.com/yourname/llmhive.git
cd llmhive
```

安装依赖：

```bash
pip install -e '.[openai,gemini,ollama]'
```

运行测试：

```bash
pytest
```

## 📜 许可证

本项目基于 [Apache 2.0 License](LICENSE) 开源。

---

## 🔗 相关项目

* [OpenAI Python SDK](https://github.com/openai/openai-python)
* [Google GenAI SDK](https://pypi.org/project/google-genai/)
* [Ollama](https://ollama.ai)
offapi 0.1.2
OpenAPI frontend render offline template.
Requires Python: >=3.10

# OffAPI

[![PyPI](https://img.shields.io/pypi/v/offapi.svg)](https://pypi.org/project/offapi/)

OpenAPI template files for offline usage.

This package will download the related files during the build time, and package them into the final distribution.

## Supports

- Swagger
- Redoc
- Scalar

## Installation

```bash
pip install offapi
```

## Usage

```python
from offapi import OpenAPITemplate

swagger_template = OpenAPITemplate.SWAGGER.value
swagger_template.format(spec_url="your_path_to_the_spec.json")
```

## Used by

- [spectree](https://github.com/0b01001001/spectree): API spec validator and OpenAPI document generator for Python web frameworks.
- [defspec](https://github.com/kemingy/defspec/): Create the OpenAPI spec and document from dataclass, attrs, etc.
nbs-core 0.1.0
NBS Core Utilities
Requires Python: >=3.9
Keywords: beamline, bluesky, nsls-ii

# NSLS-II Beamline Core Library

A core library providing common functionality shared across NSLS-II beamline software packages.

## Overview

nbs-core serves as the foundation for other NSLS-II beamline packages, providing:

- Common utilities and helper functions
- Shared data structures and models
- Base classes for device control
- Configuration management tools
- Core interfaces and protocols

## Usage

This package is typically used as a dependency in other nbs packages:
- `nbs-bl`: Beamline support library
- `nbs-gui`: Beamline GUI framework

## Installation

```bash
# Clone the repository
git clone https://github.com/xraygui/nbs-core.git
cd nbs-core

# Install in development mode
pip install -e .
```

## Dependencies

- Python 3.8+
- Bluesky
- Ophyd
- NumPy

## License

This project is licensed under the BSD 3-Clause License - see the [LICENSE](LICENSE) file for details.
whl-deploy 0.0.6
A deployment tool for WheelOS.
Requires Python: >=3.8
Keywords: whl-deploy, wheelos, cli-tool

## 🚀 Quick Start

`whl-deploy` simplifies Apollo deployment into two streamlined phases: **Packaging** (creating a portable release) and **Deploying** (setting up the host).

### 1. One-Step Deployment (Run/Install)

This is the standard scenario for end-users. Using a generated release bundle (e.g., `wheelos_1.0.0_ubuntu22.04_x86_64_nvidia.tar`), you can restore the entire environment—including source code, Docker images, and data—with a single command.

**The tool automates the following workflow:**
1.  📦 **Unpack**: Extracts the bundle to the workspace.
2.  📖 **Configure**: Loads the internal `manifest.yaml`.
3.  🚀 **Deploy**: Installs artifacts (Source, Docker, Maps, Models).
4.  ⚙️ **Post-Run**: Executes setup scripts (e.g., GPU checks).

```bash
# Standard installation from a release bundle
whl-deploy run --bundle wheelos_1.0.0_ubuntu22.04_x86_64_nvidia.tar

# Using aliases (Short syntax)
whl-deploy r -b wheelos_1.0.0_ubuntu22.04_x86_64_nvidia.tar
```

> **💡 Tip: Development Mode**
> If you are working in a development environment where the code is already present (git cloned) and you don't have a tarball, you can run deployment directly using the local manifest:
> ```bash
> whl-deploy run --manifest whl_deploy/manifest.yaml
> ```

---

### 2. Creating a Release (Pack)

For developers or CI/CD pipelines, `whl-deploy` consolidates all resources defined in your `manifest.yaml` into a single, distributable file.

**Key Features:**
*   **Auto-Naming**: Automatically generates names like `{project}_{ver}_{os}_{arch}_{gpu}.tar`.
*   **Smart Packing**: Fetches remote resources and standardizes directory structures.
*   **No-Double-Compression**: Uses uncompressed tar for the outer shell to speed up deployment.

```bash
# Pack using a specific manifest file
whl-deploy pack --manifest whl_deploy/manifest.yaml

# Using aliases
whl-deploy p -m whl_deploy/manifest.yaml
```

---

### 3. Configuration (Manifest)

`whl-deploy` adopts a "Configuration as Code" approach. The `manifest.yaml` defines **what** to pack (inputs) and **where** to deploy it (outputs).

📄 **View the Example Manifest:**
[👉 **whl_deploy/manifest.yaml**](https://github.com/wheelos-tools/whl-deploy/blob/main/whl_deploy/manifest.yaml)

---

### 4. Command Reference

#### Global Options
These flags apply to all commands:
*   `-m, --manifest <path>`: Specify a custom manifest file path (Default: `./manifest.yaml`).
*   `-v, --verbose`: Enable detailed debug logging.

#### Subcommands

| Command | Alias | Description | Key Flags |
| :--- | :--- | :--- | :--- |
| **`run`** | `r`, `install`, `i` | Deploy artifacts to the host system. | `-b, --bundle <path>`: Path to the `.tar` file to unpack. |
| **`pack`** | `p` | Create a consolidated release package. | N/A (Uses manifest settings) |

---

### 🤝 Contribution & Support

`whl-deploy` aims to standardize the complex deployment of autonomous driving software. If you have questions, suggestions, or wish to contribute:

*   🐛 **Report Bugs**: Submit an Issue.
*   🛠️ **Contribute**: Fork the repo and create a Pull Request.