semvec/pypi-packages huggingface dataset:
pyprocessors-chunk_sentences 0.5.126
Sherpa sentence chunking processor
Requires Python: >=3.8

# pyprocessors_chunk_sentences

[![license](https://img.shields.io/github/license/oterrier/pyprocessors_chunk_sentences)](https://github.com/oterrier/pyprocessors_chunk_sentences/blob/master/LICENSE)
[![tests](https://github.com/oterrier/pyprocessors_chunk_sentences/workflows/tests/badge.svg)](https://github.com/oterrier/pyprocessors_chunk_sentences/actions?query=workflow%3Atests)
[![codecov](https://img.shields.io/codecov/c/github/oterrier/pyprocessors_chunk_sentences)](https://codecov.io/gh/oterrier/pyprocessors_chunk_sentences)
[![docs](https://img.shields.io/readthedocs/pyprocessors_chunk_sentences)](https://pyprocessors_chunk_sentences.readthedocs.io)
[![version](https://img.shields.io/pypi/v/pyprocessors_chunk_sentences)](https://pypi.org/project/pyprocessors_chunk_sentences/)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pyprocessors_chunk_sentences)](https://pypi.org/project/pyprocessors_chunk_sentences/)

Create segments from annotations

## Installation

You can simply `pip install pyprocessors_chunk_sentences`.

## Developing

### Pre-requesites

You will need to install `flit` (for building the package) and `tox` (for orchestrating testing and documentation building):

```
python3 -m pip install flit tox
```

Clone the repository:

```
git clone https://github.com/oterrier/pyprocessors_chunk_sentences
```

### Running the test suite

You can run the full test suite against all supported versions of Python (3.8) with:

```
tox
```

### Building the documentation

You can build the HTML documentation with:

```
tox -e docs
```

The built documentation is available at `docs/_build/index.html.
seer-tool-hub 0.0.3
A Hub & Spoke tool selection engine for AI agents with Pinecone vector store
Requires Python: >=3.9

# Tool Hub 🎯

A "Hub & Spoke" tool selection engine for AI agents. Combines semantic search with graph-based expansion to intelligently select tools—including dependencies you didn't know you needed.

## Features

- **🧠 Smart Ingestion**: Enriches tools with LLM-generated metadata (use cases, dependencies, neighbors)
- **🔍 Hybrid Retrieval**: Vector search (Hub) + graph expansion (Spoke) for complete toolkits
- **☁️ Pinecone Backend**: Cloud-native vector store with namespace isolation for integrations
- **⚡ Async-First**: Fully async API for high-performance tool queries

## Installation

```bash
pip install -e .
pip install -e ".[dev]"  # For development dependencies
```

## Quick Start

```python
import os
from tool_hub import ToolHub

# Initialize ToolHub
hub = ToolHub(
    openai_api_key=os.getenv("OPENAI_API_KEY"),
    pinecone_index_name=os.getenv("PINECONE_INDEX_NAME"),
    pinecone_api_key=os.getenv("PINECONE_API_KEY")
)

# Ingest tools (one-time, per integration)
await hub.ingest(
    tools=tools,  # List of OpenAI-format tools
    integration_name="github",  # Namespace for this integration
    max_workers=10
)

# Query tools
results = await hub.query(
    query="list GitHub repositories",
    integration_name=["github"],  # Optional: filter by integration(s)
    top_k=5
)
```

## API Reference

**Initialization:**
```python
ToolHub(
    openai_api_key: str,           # Required
    pinecone_index_name: str,      # Required
    pinecone_api_key: str,         # Required
    llm_model: str = "gpt-5-mini",
    embedding_model: str = "text-embedding-3-small",
    embedding_dimensions: Optional[int] = None
)
```

**Methods:**

- `async ingest(tools, integration_name, max_workers=10)` - Enrich and index tools to Pinecone
- `async query(query, integration_name=None, top_k=3)` - Query tools using semantic search

## Examples

See `examples/precompute_pinecone_index.py` for complete Pinecone indexing example.

## Environment Variables

```bash
OPENAI_API_KEY=your_key
PINECONE_API_KEY=your_key
PINECONE_INDEX_NAME=your_index
```
jbxapi 3.24.0
API for Joe Sandbox
Requires Python: !=3.0,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,>=2.7
Keywords: security, malware, sandbox, sandboxing, joe

![Joe Sandbox API v2](https://raw.githubusercontent.com/joesecurity/jbxapi/master/img/logo.png)

# API Wrapper

The Joe Sandbox API Wrapper enables you to fully integrate Joe Sandbox into your malware analysis framework. Joe Sandbox is a deep malware analysis platform for analyzing malicious files.

You can use this wrapper with

 * [Joe Sandbox Cloud](https://www.joesecurity.org/joe-sandbox-cloud) — our Cloud hosted instance
 * [On-premise installations of Joe Sandbox](https://www.joesecurity.org/joe-security-products#on-premise) — for even more power and privacy

It is at the same time a powerful implementation of the Joe Sandbox API and also a command line tool for interacting with Joe Sandbox.

# License

The code is written in Python and licensed under MIT.

# Requirements

* Python 2.7 or higher
* Python 3.5 or higher

# Installation

## With Pip

    pip install jbxapi

For upgrading `jbxapi` to a more recent version, use

    pip install --upgrade jbxapi

## Manually

1. Install the python library [`requests`](https://requests.readthedocs.io/en/latest/).

        pip install requests

2. Copy `jbxapi.py` to where you need it.

# Documentation

* [Command Line Interface](docs/cli.md)
* [Python API](docs/api.md)

# Credits

* Thanks to [Pedram Amini](https://github.com/pedramamini) for a first wrapper implementation!

# Links

* [Joe Securiy LLC](https://www.joesecurity.org)
* [Joe Security Blog](https://blog.joesecurity.org)
* [Twitter @joe4security](https://twitter.com/joe4security)