semvec/pypi-packages huggingface dataset:
pdf-segmentation 2.1.1
Using langraph to parse a pdf into semenatic chunks 
Requires Python: <4.0.0,>=3.11

# PDF Segmentation

**PDF Segmentation** is a utility for parsing PDFs into **structured page-range chunks** using **LLMs**, designed for downstream processing such as image conversion, question extraction, derivations, and document analysis.

It is intended to sit at the **front of a PDF processing pipeline**, handling segmentation and orchestration.

---

## Features

* LLM-driven PDF segmentation into page ranges
* Schema-validated, structured outputs
* PDF → image conversion utilities
* PDF page and range splitting
* Multimodal (PDF + image) LLM support

---

## Core Components

### Segmentation Graph

```python
from graph.graph import (
    graph as PDFSegmentation,
    Section,
    ListOutput,
    State as SegmentationInput,
)
```

* **`PDFSegmentation`** – main graph entry point
* **`Section`** – base class for output units
* **`ListOutput[T]`** – typed LLM output container
* **`State`** – input configuration for segmentation

The graph:

* Accepts a PDF (path or bytes)
* Invokes an LLM
* Returns schema-validated segmentation results

---

### PDF Utilities

**PDF → Images**

```python
from pdf_image_converter import PDFImageConverter
```

**PDF Page Splitting**

```python
from pdf_seperator import PDFSeperator
```

**Multimodal LLM Invocation**

```python
from pdf_llm import PDFMultiModalLLM
```

---

## Example

### Define an Output Schema

```python
from typing import Literal, List
from pydantic import BaseModel
from graph.graph import Section, ListOutput

class MySection(Section, BaseModel):
    title: str
    description: str
    section_type: Literal["derivation", "question"]

class MySections(ListOutput[MySection]):
    items: List[MySection]
```

---

### Run Segmentation

```python
from pathlib import Path
from graph.graph import graph, State

result = graph.invoke(
    State(
        pdf=Path("data/Lecture_02_03.pdf"),
        prompt="Extract the content into these chunks",
        output_schema=MySections,
    )
)
```

---

## Input State

```python
class State(BaseModel, Generic[T]):
    pdf: str | Path
    prompt: str
    pdf_bytes: bytes | None = None

    output_schema: Type[ListOutput[T]] = Field(exclude=True)
    raw_output: List[T] = []
    parsed: list[ParsedUnit[T]] = Field(default_factory=list)

    @field_serializer("pdf_bytes")
    def serialize_pdf_bytes(self, value: bytes):
        return base64.b64encode(value).decode("ascii")
```

**Notes**

* Provide either `pdf` or `pdf_bytes`
* `output_schema` controls the LLM output structure
* `parsed` contains validated segmentation results

---

## Typical Pipeline

```text
PDF → LLM Segmentation → Page Ranges
   → PDF Splitter
   → PDF → Image Conversion
   → Downstream Processing
```

Common use cases include lecture parsing, educational content generation, and document analysis.

---
manifests 0.1.0
Add your description here
Requires Python: >=3.11

# manifests

Initial PyPI package scaffold for `manifests`, using `uv` for build and publish.

## Local workflow

```bash
uv build
uv publish
```

`uv publish` reads `UV_PUBLISH_TOKEN` automatically.

If your token is stored as `PYPI_TOKEN`, run:

```bash
export UV_PUBLISH_TOKEN="$PYPI_TOKEN"
uv publish
```

## TestPyPI

```bash
uv publish --publish-url https://test.pypi.org/legacy/
```
cookbooks 0.1.0
Add your description here
Requires Python: >=3.11

# cookbooks

Initial PyPI package scaffold for `cookbooks`, using `uv` for build and publish.

## Local workflow

```bash
uv build
uv publish
```

`uv publish` reads `UV_PUBLISH_TOKEN` automatically.

If your token is stored as `PYPI_TOKEN`, run:

```bash
export UV_PUBLISH_TOKEN="$PYPI_TOKEN"
uv publish
```

## TestPyPI

```bash
uv publish --publish-url https://test.pypi.org/legacy/
```
pdf-invoke 0.2.1
A LLM utility for working with pdfs
Requires Python: <4.0.0,>=3.10



# 📄 pdf-invoke

`pdf-invoke` is a lightweight utility for invoking multimodal LLMs using PDF files or image inputs.

It converts PDFs to images, prepares base64-encoded payloads, and sends them to a LangChain-compatible chat model with optional structured output support.

---

## Features

* Convert PDFs to images automatically
* Accept raw image bytes or file paths
* Prepare multimodal LLM payloads
* Support structured output via Pydantic models
* Sync and async invocation
* MIME type validation for image safety

---

## Installation

```bash
pip install pdf-invoke
```

---

## Quick Example

```python
from langchain_openai import ChatOpenAI
from pdf_invoke import MultiModalLLM

llm = ChatOpenAI(model="gpt-4o")

mm = MultiModalLLM(
    prompt="Extract the key information from this document.",
    model=llm,
)

response = mm.invoke(pdf="example.pdf")

print(response)
```

---

## Structured Output Example

```python
from pydantic import BaseModel

class ExtractedData(BaseModel):
    title: str
    summary: str

response = mm.invoke(
    pdf="example.pdf",
    output_model=ExtractedData,
)

print(response.title)
```

---

## Async Usage

```python
response = await mm.ainvoke(pdf="example.pdf")
```

---

## Accepted Inputs

You may provide:

* `pdf` → file path, `Path`, or raw PDF bytes
* `images` → list of image paths or image bytes

Only one of `pdf` or `images` may be provided per invocation.

---

## How It Works

1. PDF inputs are converted to images.
2. Images are validated and base64 encoded.
3. A multimodal payload is created.
4. The payload is sent to a LangChain chat model.
5. Optional structured output is enforced via Pydantic.

---

## Requirements

* Python 3.10+
* LangChain-compatible chat model
* Pydantic

---

## License

MIT License

---
photoshop-connection 0.3.1
Python package for Photoshop Connection
Requires Python: <3.15,>=3.10

Photoshop connection
====================

Python package to remotely execute ExtendScript_ in Adobe Photoshop.

.. _ExtendScript: https://www.adobe.com/devnet/photoshop/scripting.html

.. image:: https://github.com/kyamagu/photoshop-connection/actions/workflows/ci.yaml/badge.svg?branch=main&event=push
    :target: https://github.com/kyamagu/photoshop-connection/actions/workflows/ci.yaml
    :alt: Build
.. image:: https://readthedocs.org/projects/photoshop-connection/badge/?version=latest
    :target: https://photoshop-connection.readthedocs.io/en/latest/?badge=latest
    :alt: Documentation Status
.. image:: https://img.shields.io/pypi/v/photoshop-connection?color=success
    :target: https://pypi.org/project/photoshop-connection/
    :alt: PyPI

Prerequisites
-------------

Photoshop must be configured to accept remote connection.

Open the plug-ins dialog from the `Preferences` > `Plug-ins...` menu in
Photoshop, and check `Enable Remote Connections` option. Enter password to the
given field, and click `OK` button and restart Photoshop.

Photoshop must be launched and running for the package to work.

Install
-------

.. code-block:: bash

    pip install photoshop-connection

Usage
-----

Example:

.. code-block:: python

    from photoshop import PhotoshopConnection

    with PhotoshopConnection(password='secret') as conn:
        conn.execute('alert("hello")')
        jpeg_binary = conn.get_document_thumbnail()

Check out documentation_ for details.

.. _documentation: https://photoshop-connection.readthedocs.io/en/latest/
proceedings 0.1.0
Add your description here
Requires Python: >=3.11

# proceedings

Initial PyPI package scaffold for `proceedings`, using `uv` for build and publish.

## Local workflow

```bash
uv build
uv publish
```

`uv publish` reads `UV_PUBLISH_TOKEN` automatically.

If your token is stored as `PYPI_TOKEN`, run:

```bash
export UV_PUBLISH_TOKEN="$PYPI_TOKEN"
uv publish
```

## TestPyPI

```bash
uv publish --publish-url https://test.pypi.org/legacy/
```
proceeedings 0.1.0
Add your description here
Requires Python: >=3.11

# proceeedings

Initial PyPI package scaffold for `proceeedings`, using `uv` for build and publish.

## Local workflow

```bash
uv build
uv publish
```

`uv publish` reads `UV_PUBLISH_TOKEN` automatically.

If your token is stored as `PYPI_TOKEN`, run:

```bash
export UV_PUBLISH_TOKEN="$PYPI_TOKEN"
uv publish
```

## TestPyPI

```bash
uv publish --publish-url https://test.pypi.org/legacy/
```
tracksdata 0.1.0rc1
A Python library for multi-object tracking data structures and algorithms
Requires Python: >=3.10
Keywords: cell-tracking, computer-vision, graph, machine-learning, multi-object-tracking, tracking

# TracksData

[![PyPI - License](https://img.shields.io/pypi/l/tracksdata.svg?color=green)](https://github.com/royerlab/tracksdata/raw/main/LICENSE)
[![PyPI - Version](https://img.shields.io/pypi/v/tracksdata.svg)](https://pypi.org/project/tracksdata)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/tracksdata.svg)](https://pypi.org/project/tracksdata)
[![CI](https://github.com/royerlab/tracksdata/actions/workflows/ci.yml/badge.svg)](https://github.com/royerlab/tracksdata/actions/workflows/ci.yml)
[![codecov](https://codecov.io/gh/royerlab/tracksdata/branch/main/graph/badge.svg)](https://codecov.io/gh/royerlab/tracksdata)

A common data structure and basic tools for multi-object tracking.

## Features

- Graph-based representation of tracking problems
- In-memory (RustWorkX) and database-backed (SQL) graph backends
- Nodes and edges can take arbitrary attributes
- SQLGraph backend can index frequently queried attributes for faster filtering
- Standardize API for node operators (e.g. defining objects and their attributes)
- Standardize API for edge operators (e.g. creating edges between nodes)
- Basic tracking solvers: nearest neighbors and integer linear programming
- Compatible with Cell Tracking Challenge (CTC) format
- Efficient subgraphing based on attributes on any graph backend
- Integration with cell tracking evaluation metrics

## Installation

```console
pip install tracksdata
```

## Why tracksdata?

TracksData provides a common data structure for multi-object tracking problems.
It uses graphs to represent detections (nodes) and their connections (edges), making it easier to work with tracking data across different algorithms.

Key benefits:
- Consistent data representation for tracking problems
- Modular components that can be combined as needed
- Support for both small datasets (in-memory) and large datasets (database)

## Documentation

- [Full Documentation](https://royerlab.github.io/tracksdata/)
- [Installation](https://royerlab.github.io/tracksdata/installation/)
- [Core Concepts](https://royerlab.github.io/tracksdata/concepts/)
- [Getting Started](https://royerlab.github.io/tracksdata/getting_started/)
- [API Reference](https://royerlab.github.io/tracksdata/reference/tracksdata/)
- [FAQ](https://royerlab.github.io/tracksdata/faq/)
llama-agents-client 0.2.0rc0
HTTP client for connecting to and interacting with LlamaIndex workflow servers
Requires Python: >=3.9

# LlamaAgents Client

Async HTTP client for interacting with deployed [`llama-agents-server`](https://pypi.org/project/llama-agents-server/) instances.

## Installation

```bash
pip install llama-agents-client
```

## Quick Start

```python
import asyncio
from llama_agents.client import WorkflowClient

async def main():
    client = WorkflowClient(base_url="http://localhost:8080")

    # Run a workflow asynchronously
    handler = await client.run_workflow_nowait("my_workflow")

    # Stream events as they are produced
    async for event in client.get_workflow_events(handler.handler_id):
        print(f"Event: {event.type} -> {event.value}")

    # Get the final result
    result = await client.get_handler(handler.handler_id)
    print(f"Result: {result.result} (status: {result.status})")

asyncio.run(main())
```

## Features

- Run workflows synchronously or asynchronously
- Stream events in real-time as a workflow executes
- Human-in-the-loop support via `send_event` for injecting events into running workflows
- Bring your own `httpx.AsyncClient` for custom auth, headers, or transport

## Documentation

See the full [deployment guide](https://developers.llamaindex.ai/python/llamaagents/workflows/deployment/) for detailed usage and API reference.
llama-agents-dbos 0.1.0rc0
DBOS durable runtime plugin for LlamaIndex Workflows
Requires Python: >=3.9

# LlamaAgents DBOS Runtime

DBOS durable runtime plugin for LlamaIndex Workflows.

## Installation

```bash
pip install llama-agents-dbos
```

## Usage

```python
from llama_agents.dbos import DBOSRuntime
from dbos import DBOS, DBOSConfig
from workflows import Workflow, step, StartEvent, StopEvent

# Configure DBOS
config: DBOSConfig = {
    "name": "my-app",
    "system_database_url": "postgresql://...",
}
DBOS(config=config)

# Create runtime and workflow
runtime = DBOSRuntime()

class MyWorkflow(Workflow):
    @step
    async def my_step(self, ev: StartEvent) -> StopEvent:
        return StopEvent(result="done")

workflow = MyWorkflow(runtime=runtime)

# Launch runtime and run workflow
runtime.launch()
result = await workflow.run()
```

## Features

- Durable workflow execution backed by DBOS
- Automatic step recording and replay
- Distributed workers and recovery support