semvec/pypi-packages huggingface dataset:
hexdoc-hexoverpowered 0.11.4.1.1
Python web book docgen and hexdoc plugin for HexOverpowered.
Requires Python: >=3.11
Keywords: hexdoc

# hexdoc-hexoverpowered

Python web book docgen and [hexdoc](https://pypi.org/project/hexdoc) plugin for HexOverpowered.

## Version scheme

We use [hatch-gradle-version](https://pypi.org/project/hatch-gradle-version) to generate the version number based on whichever mod version the docgen was built with.

The version is in this format: `mod-version.python-version.mod-pre.python-dev.python-post`

For example:
* Mod version: `0.11.1-7`
* Python package version: `1.0.dev0`
* Full version: `0.11.1.1.0rc7.dev0`

## Setup

Install Python 3.12.

```sh
python3.12 -m venv venv

.\venv\Scripts\activate   # Windows
. venv/bin/activate.fish  # fish
source venv/bin/activate  # everything else

# run from the repo root, not doc/
pip install -e .[dev]
```

## Usage

For local testing, create a file called `.env` in the repo root following this template:
```sh
GITHUB_REPOSITORY=YukkuriC/HexOverpowered
GITHUB_SHA=main
GITHUB_PAGES_URL=https://yukkuric.github.io/HexOverpowered/
```

Useful commands:
```sh
# show help
hexdoc -h

# build, merge, and serve the web book in watch mode
nodemon --config doc/nodemon.json

# build, merge, and serve the web book
hexdoc serve

# manually build and merge the web book
hexdoc build
hexdoc merge

# start the Python interpreter with some extra local variables
hexdoc repl
```
ag-ui-langgraph 0.0.25
Implementation of the AG-UI protocol for LangGraph.
Requires Python: <3.14,>=3.10

# ag-ui-langgraph

Implementation of the AG-UI protocol for LangGraph.

Provides a complete Python integration for LangGraph agents with the AG-UI protocol, including FastAPI endpoint creation and comprehensive event streaming.

## Installation

```bash
pip install ag-ui-langgraph
```

## Usage

```python
from langgraph.graph import StateGraph, MessagesState
from langchain_openai import ChatOpenAI
from ag_ui_langgraph import LangGraphAgent, add_langgraph_fastapi_endpoint
from fastapi import FastAPI
from my_langgraph_workflow import graph

# Add to FastAPI
app = FastAPI()
add_langgraph_fastapi_endpoint(app, graph, "/agent")
```

## Features

- **Native LangGraph integration** – Direct support for LangGraph workflows and state management
- **FastAPI endpoint creation** – Automatic HTTP endpoint generation with proper event streaming
- **Advanced event handling** – Comprehensive support for all AG-UI events including thinking, tool calls, and state updates
- **Message translation** – Seamless conversion between AG-UI and LangChain message formats

## To run the dojo examples

```bash
cd python/ag_ui_langgraph/examples
poetry install
poetry run dev
```
oiplot 1.5.5
A plotting tool for OIFITS files with some additional functionality.
Requires Python: >=3.10

[![Please don't upload to GitHub](https://nogithub.codeberg.page/badge.svg)](https://nogithub.codeberg.page)
[![License: GPLv3](https://img.shields.io/badge/License-GPLv3-yellow.svg)](https://opensource.org/license/gpl-3-0)
![PyPI Version](https://img.shields.io/pypi/v/oiplot)

# Oiplot

Oiplot is a simple and straightforward plotting software for [OIFITS](https://oifits.org/docs/about/) files. It also provides `io` as well as further plotting functionality.

* **Documentation**:
* **Bug reports**: https://codeberg.org/MBSck/oiplot/issues

## Contents

This package provides

* OIFITS `io` operations
* OIFITS `plot` functionality
* Additional `orbit` plot functionality

## Installation

```bash
pip install oiplot
```

## Credits

* The example OIFITS was procured from [oidb](https://oidb.jmmc.fr/).
signalblast 0.12.0
Broadcast bot for Signal
Requires Python: >=3.10
Keywords: Bot, Broadcast, Signal

# signalblast

Signalblast is a tool to send encrypted messages anonymously over [Signal](https://www.signal.org/) to a subscriber list. The sender does not know who the subscribers in the list are, nor the subscribers know who the sender is.

A server is required to host the bot, find instructions on how the set it up below.

The idea for this bot came from [Signalboost](https://web.archive.org/web/https://signalboost.info/), which unfortunately is no longer alive.

## Usage

Once the bot is up and running, several commands are available:
* `!subscribe` send this to sign up to the list
* `!broadcast` after subscribing any message preceded by this will be broadcasted to every subscriber
* `!unsubscribe` to stop receiving messages
* `!help` to be reminded of which commands are available
* `!admin` send a message only to the list admin, useful for getting technical support

## Installation

### Option 1: local python environment
* Set up signalbot as specified [here](https://github.com/signalbot-org/signalbot)
* Create a new virtual environment, [uv](https://docs.astral.sh/uv/) is recommended
* Install with `pip install signalblast`
* Run via `python -m signalblast.main`

### Option 2: docker compose
This will pull the project docker images from https://hub.docker.com/r/eradorta/signalblast

* Install [docker](https://www.docker.com/).
* Download the [docker-compose.yml](https://github.com/Era-Dorta/signalblast/blob/main/docker-compose.yaml) file.
* Create a data folder `mkdir -p $HOME/.local/share/signalblast`
* Define the relevant environment variables
  ```bash
  export DOCKER_TAG="The version of signalblast to run, can be latest"
  export SIGNALBLAST_PHONE_NUMBER="The phone number of the bot"
  export SIGNALBLAST_PASSWORD="The password for the admin"
  export SIGNALBLAST_HEALTHCHECK_RECEIVER="The contact or group to send health check messages"
  ```
* Run via docker compose: `docker compose up`

## Development

* Set up docker and signalbot as specified in the [installation](#installation) section.
* Clone the repo
* Install [uv](https://docs.astral.sh/uv/)
* Install the repo and the dependencies in a new virtual environment with `uv sync`
* Install the prek hook `uv run prek install`
* Run
  * Directly via `uv run python -m signalblast.main`
  * Via systemd with `systemd/signalblast.service`
    * Run once with the password in the env file.
    * From there one, the password is stored encrypted and it can be removed from the env file
* Optional: install signalbot as an editable dependency `uv add --editable ../signalbot/`

### Docker compose

The `docker/compose_build.sh` and `docker/compose_up.sh` are provide for easier development.

## Roadmap

* Make instructions clearer and add pictures to the readme
* Add unit testing
cubewerx-stratos 9.7.12
The CubeWerx Stratos Administration Interface
Requires Python: >=3.11

# CubeWerx Stratos Administration Interface

This API allows a Stratos Geospatial Data Server to be set up and
maintained remotely.  Once installed, it can be invoked with the
following Python code:

```
from cubewerx.stratos import *
stratos = Stratos(deploymentUrl, username, password)
```

where ```deploymentUrl``` is the URL of a CubeWerx Stratos deployment
(e.g., "https://somewhere.com/cubewerx/"), ```username``` is the username
(with an Administrator role) to log in as, and ```password``` is the
password of the specified username.

The documentation for this API can be found
[here](https://www.cubewerx.com/documentation/9.7/pythonApi/stratos.html).
hos-m2f 0.6.9
HOS-M2F: Markdown to Industry Standard Format Compiler Engine
Requires Python: >=3.8

HOS-M2F is a powerful compiler engine that converts Markdown files to various industry standard formats.

Key Features:
- Multiple output formats: PDF, DOCX, EPUB, and JSON
- Specialized modes for different document types:
  - Book mode for book-length documents
  - Paper mode for academic papers
  - Patent mode for patent applications
  - SOP (Standard Operating Procedure) mode for technical procedures
- Command-line interface for easy automation
- Semantic parsing for intelligent document structure
- Extensible architecture for custom renderers and modes

Use Cases:
- Convert technical documentation to professional formats
- Generate academic papers from Markdown sources
- Create standardized operating procedures
- Prepare patent applications with proper formatting
- Build eBooks from Markdown content

HOS-M2F simplifies the process of creating professionally formatted documents from plain Markdown, saving time and ensuring consistency across document types.