semvec/pypi-packages huggingface dataset:
aissemble-inference-yolo 1.5.0
YOLO model family support for aiSSEMBLE Inference
Requires Python: >=3.11

# aiSSEMBLE Inference YOLO Module

YOLO model family support for the aiSSEMBLE Inference library.

## Supported Models

This module supports all YOLO versions available through the Ultralytics library:

| Family | Variants |
|--------|----------|
| YOLOv5 | yolov5n, yolov5s, yolov5m, yolov5l, yolov5x |
| YOLOv8 | yolov8n, yolov8s, yolov8m, yolov8l, yolov8x |
| YOLO11 | yolo11n, yolo11s, yolo11m, yolo11l, yolo11x |

## Installation

```bash
pip install aissemble-inference-yolo
```

This will also install the required dependencies:
- `aissemble-inference-core`
- `ultralytics` (for YOLO models)
- `mlserver` (for serving)

## Usage

### With MLServer

Create a `model-settings.json`:

```json
{
    "name": "yolo",
    "implementation": "aissemble_inference_yolo.YOLORuntime",
    "parameters": {
        "model": "yolov8n.pt"
    }
}
```

Start MLServer:

```bash
mlserver start /path/to/models
```

### With OIP Client

```python
from aissemble_inference_core.client import InferenceClient
from aissemble_inference_core.client.registry import ModuleRegistry

# The module auto-registers via entry points
print(ModuleRegistry.instance().list_available())
# {'runtimes': ['yolo'], 'translators': ['yolo'], ...}

# Use with InferenceClient
client = InferenceClient(adapter, endpoint)
result = client.detect_object("yolo").image("photo.jpg").run()
```

## Components

### YOLORuntime

MLServer-compatible runtime that wraps YOLO models:
- Accepts base64-encoded images via OIP protocol
- Returns bounding boxes, labels, and confidence scores
- Configurable model variant via parameters

### YOLOTranslator

Translator for YOLO outputs:
- Inherits from `DefaultObjectDetectionTranslator`
- Can be extended with YOLO-specific optimizations

## Entry Points

This module registers the following entry points:

| Group | Name | Class |
|-------|------|-------|
| `inference.runtimes` | yolo | `YOLORuntime` |
| `inference.translators` | yolo | `YOLOTranslator` |
aissemble-inference-core 1.5.0
Core aiSSEMBLE Inference functionality
Requires Python: >=3.9.14

# aiSSEMBLE Inference (OIP) Client
Provides a modular Python library for standardized ML model inference, promoting interoperability across diverse 
runtimes and platforms. This client allows invocation of OIP endpoints in a more natural manner by ensuring that 
inference runtime details (like tensor-specific input/output structures) as not leaked from the model implementation
into the client.

## Features

### Fluent Builder API
InferenceBuilder (abstract base class) offers a task-specific, chainable interface for configuring inference requests.
Supports model selection, adapter/translator registration, custom parameters, and streaming responses.  Extensible via 
subclasses implementing `build_predictor()` to produce a Predictor instance.

### Task-Specific Inference
The client provides specialized builders for common ML tasks with natural, task-oriented APIs:

**Object Detection**
- `client.detect_object(model_name)` - Returns `ObjectDetectionBuilder`
- Fluent methods: `.image()`, `.confidence()`, `.labels()`
- Returns `ObjectDetectionResult` with bounding boxes, labels, scores
- Supports PIL images, numpy arrays, file paths, and bytes
- Example:
  ```python
  result = client.detect_object("yolov8") \
      .image("photo.jpg") \
      .confidence(0.6) \
      .run()
  for detection in result.detections:
      print(f"{detection.label}: {detection.confidence}")
  ```

**Text Summarization**
- `client.summarize(model_name)` - Returns `SummarizationBuilder`
- Fluent methods: `.text()`, `.max_length()`, `.min_length()`
- Returns `SummarizationResult` with summary text and compression metrics
- Example:
  ```python
  result = client.summarize("bart-large") \
      .text("Very long article text here...") \
      .max_length(100) \
      .run()
  print(result.summary)
  print(f"Compressed {result.compression_ratio:.1f}x")
  ```

### Raw Inference Support 
`RawInferenceBuilder` provides a low-level, non-fluent API for direct tensor inputs and parameters, ideal for custom or
performance-critical scenarios.

### Streaming Capable
Builders support iterable responses for continuous inference outputs.
airrlogger 0.1.0
Python logging configuration library for MLCommons AIRR applications.
Requires Python: <4.0,>=3.12
Keywords: logging, internal

# airrlogger

The airrlogger package provides a standardized logging configuration for AIRR applications.

## Usage

Install in a poetry project: `poetry add airrlogger`

Near the top of any file where you want to log, do something like:

```python
from airrlogger.log_config import get_logger
logger = get_logger(__name__)
```

Then as early as possible in your program's startup, tell it how to
handle the logging:

```python
import logging
from airrlogger.log_config import configure_logging

configure_logging(app_name="myapp", level=logging.INFO)
```


You can then log like this
```python
    logger.info("some info logging")
```

The default output looks like this:

```
2026-01-09T21:14:13Z - myapp - __main__ - INFO - some info logging
```


### DefaultFormatter

A class that formats log messages with UTC timestamps and optional ANSI color codes for console output.

### configure_logging

A function that configure the root logger with console and optional file output.

```
from airrlogger.log_config import configure_logging

logger = configure_logging(app_name="modelrunner-api", file="./app.log", level=logging.DEBUG)
```

### get_config_dict

Generates logging configuration dictionaries for use with logging.config.dictConfig. By default, the app name is derived from the package name, but that can be overridden.

This is particularly useful for FastAPI applications, which can adopt this logger by using something like:

```
run(app, host="0.0.0.0", port=port, log_config=get_config_dict(app_name="modelrunner-api"))
```

## Example Output

`2025-12-19T14:10:24Z - modelrunner-api - INFO - 127.0.0.1:36054 - "GET /health HTTP/1.1" 200`