semvec/pypi-packages huggingface dataset:
langchain-xparse 1.0.0
LangChain integration with xParse Pipeline API for document parsing, chunking and embedding
Requires Python: >=3.10
Keywords: langchain, xparse, document-loader, textin, parsing

# langchain-xparse

LangChain integration with [xParse Pipeline API](https://docs.textin.com/pipeline/overview) for document parsing, chunking and embedding. Supports parse / chunk / embed stages only (extract is not supported in this loader).

## Installation

From PyPI:

```bash
pip install langchain-xparse
```

Local editable install:

```bash
pip install -e .
```

## Configuration

Set your TextIn credentials (from [Textin Workspace](https://www.textin.com/console/dashboard/setting) ):

```bash
export XPARSE_APP_ID="your-app-id"
export XPARSE_SECRET_CODE="your-secret-code"
```

Or pass them when creating the loader:

```python
loader = XParseLoader(
    file_path="doc.pdf",
    app_id="your-app-id",
    secret_code="your-secret-code",
)
```

## Usage

### Basic (parse only)

```python
from langchain_xparse import XParseLoader

loader = XParseLoader(file_path="example.pdf")
docs = loader.load()
print(docs[0].page_content[:200])
print(docs[0].metadata)  # source, category, element_id, filename, page_number, ...
```

### Lazy load

```python
for doc in loader.lazy_load():
    # process(doc)
```

### Async

```python
async for doc in loader.alazy_load():
    # process(doc)
```

### Convenience params (parse + chunk, or parse + chunk + embed)

```python
loader = XParseLoader(
    file_path="doc.pdf",
    parse_provider="textin",
    chunk_strategy="by_title",
    chunk_max_characters=500,
    chunk_overlap=50,
)
# Or with embed:
loader = XParseLoader(
    file_path="doc.pdf",
    parse_provider="textin",
    chunk_strategy="basic",
    chunk_max_characters=1000,
    embed_provider="qwen",
    embed_model_name="text-embedding-v4",
)
docs = loader.load()
```

### Custom stages (advanced)

```python
loader = XParseLoader(
    file_path="doc.pdf",
    stages=[
        {"type": "parse", "config": {"provider": "textin"}},
        {"type": "chunk", "config": {"strategy": "by_page", "max_characters": 800}},
    ],
)
```

### Multiple files

```python
loader = XParseLoader(file_path=["a.pdf", "b.pdf"])
for doc in loader.lazy_load():
    print(doc.metadata.get("source"), doc.page_content[:50])
```

### File-like object

When passing a file-like object instead of a path, you must set `metadata_filename`:

```python
with open("doc.pdf", "rb") as f:
    loader = XParseLoader(file=f, metadata_filename="doc.pdf")
    docs = loader.load()
```

## References

- [xParse overview](https://docs.textin.com/pipeline/overview)
- [Pipeline API](https://docs.textin.com/api-reference/endpoint/pipeline)
reliev 0.1.1
Complementary store library for observ
Requires Python: >=3.9

# Reliev 

Complementary store library for [observ](https://github.com/fork-tongue/observ). Provides undo/redo functionality.

Leverages [patchdiff](https://github.com/fork-tongue/patchdiff) for constructing patches to apply to state for undo/redo.
ozobot-ari 0.2.1
Ozobot ARI library
Requires Python: >=3.13

# ozobot-ari

Interface for controlling Ozobot Ari. See the [monorepo](https://github.com/ozobot/python-libraries) for more details. 

**Work in progress, only a web runtime driver for Ozobot Editor available**

## Usage
```python
import asyncio
import random
from ozobot.ari import AriHandle, Ari
from ozobot.linefollower import NamedColor, LEDMask, Direction


async def monitor(it):
  async for data in it:
    print(f"Sample taken: {data.value}")


async def main():
  async with AriHandle(id="ABCDE*") as ari:
    await ari.move(100, 50)
    await ari.rotate(180, 90)

    velo_task = asyncio.create_task(ari.set_velocity(50, 0))
    await asyncio.sleep(2)
    velo_task.cancel()

    await ari.set_led(LEDMask.FRONT_CENTER | LEDMask.FRONT_LEFT | LEDMask.FRONT_RIGHT, NamedColor.BLUE)
    await ari.set_led(LEDMask.FRONT_LEFT_CENTER | LEDMask.FRONT_RIGHT_CENTER, NamedColor.RED)

    await ari.play_sound("happy")
    await ari.play_tone("A", 4, 1, 1)

    await ari.follow_line(Direction.STRAIGHT)
    intersection = await ari.data.intersection.read()
    print(f"At intersection: {intersection.value}")

    async with ari.data.intersection.watch() as intersections, ari.data.color_code.watch() as codes:
      t1 = asyncio.create_task(_monitor(intersections))
      t2 = asyncio.create_task(_monitor(codes))

      await ari.follow_line(random.choice(list(intersection.value)))

      t1.cancel()
      t2.cancel()


asyncio.run(main())
```
Evolis-SDK 9.3.0
This package is part of the Evolis SDK version 3. Documentation and examples can be found on the Evolis SDK Documentation.
Requires Python: >=3.8

Evolis SDK Pip Package
======================

This package contains resources to use Evolis printers with Python.
Import that module in your Python application to start using the SDK.

Code samples
------------

You can find some code samples and documentation in the Evolis SDK zip package at the URL: https://www2.evolis.com/sdk

Supported platforms
-------------------

This package is compatible with the following OS/CPU Architectures:

* Windows
    * x86
    * x86_64
* macOS
    * x86_64
    * arm64
* Linux
    * x86_64
    * aarch64
rich-toolkit 0.19.4
Rich toolkit for building command-line applications
Requires Python: >=3.8

# Rich Toolkit

This is a very opinionated set of components for building CLI applications.
It is based on [Rich](https://github.com/Textualize/rich)

## Installation

```bash
pip install rich-toolkit
```

## Example usage

Rich toolkit comes with an `App` class, this is used to give a consistent
style to your CLI application, it can be used as a context manager, like so:

```python
TODO: new example
```