semvec/pypi-packages huggingface dataset:
langgraph-utils 0.0.7.4
Utilities for Langchain and langgraph
Requires Python: >=3.10

# LangChain Tools JSON Converter

This module provides utility functions to convert LangChain tool objects into JSON format and vice versa. It helps serialize and deserialize structured tool definitions for easier storage and transport.

## Features
- **`create_tools_json`**: Converts a list of LangChain tool objects into a JSON string.
- **`json_to_structured_tools`**: Converts a JSON representation of LangChain tools back into `StructuredTool` objects.

## Installation
Ensure you have `langchain_core` installed before using this module:
```bash
pip install langchain-core
```

## Usage
### Converting Tools to JSON
```python
from langchain_core.tools import StructuredTool

# Example tool
example_tool = StructuredTool(
    name="example_tool",
    description="An example tool",
    func=None,
    args_schema={}
)

# Convert to JSON
json_output = create_tools_json([example_tool])
print(json_output)
```

### Converting JSON to Structured Tools
```python
json_tools = [
    {
        "name": "example_tool",
        "description": "An example tool",
        "args_schema": {}
    }
]

structured_tools = json_to_structured_tools(json_tools)
print(structured_tools)
```

## Function Details
### `create_tools_json(tools)`
**Description:** Converts a list of LangChain tool objects into a JSON string.

**Parameters:**
- `tools` (List of `StructuredTool` objects): List of tool objects to be serialized.

**Returns:**
- `str`: JSON string representation of the tools.

### `json_to_structured_tools(json_tools)`
**Description:** Converts JSON-formatted LangChain tools into `StructuredTool` objects.

**Parameters:**
- `json_tools` (list or dict): A list or single JSON object representing tools.

**Returns:**
- `StructuredTool` or List of `StructuredTool` objects.

## Notes
- The `func` attribute is set to `None` when reconstructing `StructuredTool` objects from JSON.
- Ensure that the `args_schema` matches the expected schema format for LangChain.

## License
This module is open-source and can be modified as needed.
omron-connect-api 0.1.1
Library to communicate with OMRON connect API
Requires Python: >=3.13

[![Build, test and publish](https://github.com/happydev-ca/omron-connect-api/actions/workflows/publish.yml/badge.svg)](https://github.com/happydev-ca/omron-connect-api/actions/workflows/publish.yml)

# omron-connect-api

Library to communicate with OMRON connect API.

Only the blood pressure readings are provided in the current version.

## Usage

```python
import aiohttp
import asyncio
import os

from omron_connect_api import OmronConnectApi


async def run():
    async with aiohttp.ClientSession() as session:
        api = OmronConnectApi(os.environ['EMAIL'], os.environ['PASSWORD'], os.environ['COUNTRY_CODE'], session)
        blood_pressure_readings = await api.async_get_blood_pressure_readings()
        print(blood_pressure_readings)


asyncio.run(run())
```

### Build and test locally

```shell
make venv
source .venv/bin/activate
make test
make build
```

### Release version

```shell
make release bump=patch|minor|major
```
package-formula-report-vl 0.0.1
A package for processing log files and generating Formula 1 racing reports
Requires Python: >=3.9

# Formula 1 Report Package

This is a simple Python package for processing log files and generating Formula 1 racing reports.

## Installation

To install the package locally from the project root, run the following command in your terminal: 

```bash
pip install .
```

Alternative installation option:

```bash
pip install package-formula-report-vl
```
## Usage

After installation, you can use the package as follows:
```
from report.formula_report import build_report, print_report

report = build_report(folder_path='report/data', order='asc')
print_report(report)
    
```
## CLI Usage
 
After installing the package, you can use the command-line interface:

```
python -m report --path <folder_path>

```
llm-fragments-tmux 0.1.0a2
llm plugins for loading tmux panes
Requires Python: >=3.10

# llm-fragments-tmux

[![PyPI](https://img.shields.io/pypi/v/llm-fragments-tmux.svg)](https://pypi.org/project/llm-fragments-tmux/)
[![Changelog](https://img.shields.io/github/v/release/kj-9/llm-fragments-tmux?include_prereleases&label=changelog)](https://github.com/kj-9/llm-fragments-tmux/releases)
[![Tests](https://github.com/kj-9/llm-fragments-tmux/actions/workflows/test.yml/badge.svg)](https://github.com/kj-9/llm-fragments-tmux/actions/workflows/test.yml)
[![License](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](https://github.com/kj-9/llm-fragments-tmux/blob/main/LICENSE)

A plugin for [LLM](https://llm.datasette.io/) that provides fragments from tmux panes. It allows you to capture the content of a tmux pane and use it as a fragment in LLM prompts, or list available tmux panes for selection.

## Installation

Install this plugin in the same environment as [LLM](https://llm.datasette.io/).
```bash
llm install llm-fragments-tmux
```

## Example

Here's a step-by-step example of how you might use this plugin in practice:

1. Open tmux
```bash
tmux
```
2. Run a command in your tmux pane
```bash
echo "Hello, world! This is a test."
```
3. Use LLM with the tmux fragment to explain what happened
```bash
llm -f tmux: "Explain what happened in this terminal session."
```
This will capture the output from your current tmux pane and send it to LLM for explanation.


## Usage

This plugin provides a tmux fragment for use with LLM's `-f`/`--fragment` option.

You can use the content of one or more tmux panes directly in your LLM prompts using positional arguments:

```bash
llm -f tmux:1,2:20 "Summarize the following terminal output:"
```
- The first field (before the colon) is a comma-separated list of tmux pane ids (e.g., `1,2`). Omit for the current pane.
- The second field (after the colon) is the number of lines from the bottom of the pane(s) to capture (e.g., `20`). Omit for all lines.
- Examples:
  - `tmux:1,2:20` — panes 1 and 2, last 20 lines
  - `tmux:1` — pane 1, all lines
  - `tmux::20` — current pane, last 20 lines
  - `tmux:` — current pane, all lines (default)

You can also use the fragment in other LLM commands that support `-f`/`--fragment`.


## Development

To set up this plugin locally, first checkout the code. Then create a new virtual environment:
```bash
cd llm-fragments-tmux
python -m venv venv
source venv/bin/activate
```
Now install the dependencies and test dependencies:
```bash
python -m pip install -e '.[test]'
```
To run the tests:
```bash
python -m pytest
```
boto3-pydantic-xray 1.0.2
Pydantic models for AWS Xray
Requires Python: <4.0,>=3.9
Keywords: aws, boto3, pydantic, models, xray

# boto3-pydantic-xray

This package was automatically generated by aws-resource-validator repository.

For more information, visit:
- Package homepage: https://coreoxide.github.io/aws_resource_validator/
- GitHub repository: https://github.com/CoreOxide/aws_resource_validator
- PyPI project: https://pypi.org/project/aws-resource-validator/

Pydantic models for AWS Xray.