semvec/pypi-packages huggingface dataset:
emotional 0.6.0
A Commitizen plugin for conventional commit with emojis and integrations
License: MIT
Requires Python: >=3.10

# emotional

[![CI](https://github.com/noirbizarre/emotional/actions/workflows/ci.yml/badge.svg)](https://github.com/noirbizarre/emotional/actions/workflows/ci.yml)
[![pre-commit.ci status](https://results.pre-commit.ci/badge/github/noirbizarre/emotional/main.svg)](https://results.pre-commit.ci/latest/github/noirbizarre/emotional/main)
[![codecov](https://codecov.io/gh/noirbizarre/emotional/graph/badge.svg?token=Iha48GODCy)](https://codecov.io/gh/noirbizarre/emotional)

A [Commitizen][commitizen] template for [conventional commit][conventional-commit] with emojis and integrations.

## Installation

```shell
pip install emotional
```

Then set `emotional` as the Commitizen template:

```toml
[tool.commitizen]
name = "emotional"
```

## Configuration

As a starter, remember that all [Commitizen configuration][commitizen-config]
is available.

### Changelog

By default, changes by types are kept in order of commit and ignore the scope for ordering.
You can however force scope to be sorted first by setting `order_by_scope`:

```toml
[tool.commitizen]
name = "emotional"
order_by_scope = true
```

You can also group changes into subsections by scope by setting `group_by_scope`:

```toml
[tool.commitizen]
name = "emotional"
group_by_scope = true
```

### Github integration

To enable [github](https://github.com) integration, just provide your github repository as `github` setting:

```toml
[tool.commitizen]
name = "emotional"
github = "author/repository"
```

For github enterprise, you can use the full repository URL:

```toml
[tool.commitizen]
name = "emotional"
github = "https://git.company.com/author/repository"
```

### Gitlab integration

To enable [gitlab](https://gitlab.com) integration, just provide your gitlab repository as `gitlab` setting:

```toml
[tool.commitizen]
name = "emotional"
gitlab = "author/repository"
```

Use the full URL for hosted gitlab instances:

```toml
[tool.commitizen]
name = "emotional"
gitlab = "https://git.company.com/author/repository"
```

### Jira integration

To enable [Jira](https://www.atlassian.com/fr/software/jira) integration,
provide your JIRA instance URL as `jira_url` setting
and the list of project prefix you want ho be processed in `jira_prefixes`:

```toml
[tool.commitizen]
name = "emotional"
jira_url = "https://emotional.atlassian.net"
jira_prefixes = [
  "EMO-",
  "PRJ-",
]
```

### Multiple integrations

While it is totally possible to mix integrations,
keep in mind than `jira` is compatible with both `github` and `gitlab`
while `github` and `gitlab` are conflicting because they use the same format.


[commitizen]: https://commitizen-tools.github.io/commitizen/
[commitizen-config]: https://commitizen-tools.github.io/commitizen/config/
[conventional-commit]: https://www.conventionalcommits.org/
phi-loader 0.1.0
Generic remote module loader with API key authentication
License: MIT
Requires Python: >=3.8

# phi-loader

Generic remote module loader with API key authentication.

## Installation

```bash
pip install phi-loader
```

## Usage

```python
from phi_loader import configure, load

# Configure endpoint and API key
configure(
    endpoint="https://your-server.com/modules",
    api_key="your-secret-key"
)

# Load and execute a remote module
result = load("module_name", arg1="value1")
```

Or via environment variables:

```bash
export PHI_ENDPOINT="https://your-server.com/modules"
export PHI_API_KEY="your-secret-key"
```

```python
from phi_loader import load
result = load("module_name")
```

## How it works

1. Fetches `{endpoint}/{module_name}.py` with Bearer auth
2. Executes module in isolated namespace
3. Calls `main(**kwargs)` if present
4. Returns result

## License

MIT
llm-drift-ctl 0.1.2
Production-grade LLM output validation package. Validates LLM outputs using your own LLM when needed — and no LLM when not.
License: MIT
Requires Python: >=3.8
Keywords: llm, validation, drift, quality, guard

# llm-drift-ctl (Python)

> **llm-drift-ctl is a drop-in guard that validates LLM outputs using your own LLM when needed — and no LLM when not.**

Production-grade LLM output validation package for Python. This package **does NOT generate content**. It **validates LLM outputs** after they are produced.

## Installation

```bash
pip install llm-drift-ctl
```

## Quick Start

### FORMAT Mode (LLM-free, fully offline)

```python
from llm_drift_ctl import DriftGuard, DriftGuardConfig

guard = DriftGuard(DriftGuardConfig(pipeline_id="my-pipeline"))

# Check JSON format (using keyword arguments)
result = await guard.check(
    json={"name": "John", "age": 30},
    mode="FORMAT"
)

# Or using CheckInput object
from llm_drift_ctl import CheckInput
result = await guard.check(
    CheckInput(json={"name": "John", "age": 30}, mode="FORMAT")
)

print(result)
# CheckResult(
#     block=False,
#     decision='ALLOW',
#     severity='LOW',
#     scores={'format': 1.0},
#     where=[]
# )
```

### CONTENT Mode (requires your LLM)

```python
from llm_drift_ctl import DriftGuard, DriftGuardConfig, UserLLM

# Implement your LLM adapter
class MyLLM(UserLLM):
    async def generate(self, prompt, text=None, json=None):
        # Call OpenAI, Gemini, Claude, or your custom LLM
        # You provide your own API key
        return "response from your LLM"

guard = DriftGuard(DriftGuardConfig(
    pipeline_id="my-pipeline",
    llm=MyLLM(),
    api_key="your-license-key"  # for cloud license verification
))

# Accept a baseline (approved output)
await guard.accept_baseline(json={"name": "John", "age": 30})

# Check against baseline
result = await guard.check(
    json={"name": "Jane", "age": 25},
    mode="CONTENT"
)
```

## API Reference

See the main [README.md](../README.md) for full documentation.

The Python API mirrors the Node.js API exactly.

## License

MIT