semvec/pypi-packages huggingface dataset:
certbot-dns-domainchief 1.2.0
Domain Chief DNS Authenticator plugin for Certbot
License: MIT
Requires Python: >=3.6

# [Certbot](https://certbot.eff.org/) [Domain Chief](https://domain.chief.app?ref=certbot-dns-domainchief) plugin

[![Snap Store Badge](https://snapcraft.io/certbot-dns-domainchief/badge.svg?version=latest)](https://snapcraft.io/certbot-dns-domainchief)
[![PyPI Version Badge](https://img.shields.io/pypi/v/certbot-dns-domainchief)](https://pypi.org/project/certbot-dns-domainchief/)

This plugin enables DNS verification with [Certbot](https://certbot.eff.org/) when using [Domain Chief](https://domain.chief.app?ref=certbot-dns-domainchief).

## Installation

If you installed certbot as a snap, then you have to install this plugin as a snap as well:

```bash
snap install certbot-dns-domainchief
snap set certbot trust-plugin-with-root=ok
snap connect certbot:plugin certbot-dns-domainchief
```

and can be upgraded using the `refresh` command:

```bash
snap refresh certbot-dns-domainchief
```

Alternatively this package can be installed with pip:

```bash
pip install certbot-dns-domainchief
```

and can be upgraded using the `--upgrade` flag

```bash
pip install --upgrade certbot-dns-domainchief
```

## Credentials

You need to supply Certbot with a Domain Chief API key, this is an example of how a credentials file can look:

```ini
# Domain Chief API credentials used by Certbot
dns_domainchief_api_key = ctp_...
```

You can create a new API key [here](https://domain.chief.app/api/token/create?ref=certbot-dns-domainchief), ensure it has the `domainchief` scope and has the correct team selected.

Keep in mind that the credentials file should be readable only by the user running Certbot and the credentials cannot be scoped, so they can be used to perform any action on your behalf if compromised.

## Examples

Simple example for a single domain:

```bash
certbot certonly \
  --authenticator dns-domainchief \
  --dns-domainchief-credentials ~/.secrets/domainchief.ini \
  -d example.com
```

Simple example for wildcard domain:

```bash
certbot certonly \
  --authenticator dns-domainchief \
  --dns-domainchief-credentials ~/.secrets/domainchief.ini \
  -d example.com \
  -d *.example.com
```

Example changing the propagation delay, although you should not have to
adjust it normally:

```bash
certbot certonly \
  --authenticator dns-domainchief \
  --dns-domainchief-credentials ~/.secrets/domainchief.ini \
  --dns-domainchief-propagation-seconds 120 \
  -d example.com
```

## Security Vulnerabilities

If you discover a security vulnerability, please send an e-mail to us at `hello@chief.app`. All security vulnerabilities will be swiftly addressed.
pearl-H 0.1.4
PEARL: Prototype-Enhanced Aligned Representation Learning
License: MIT
Requires Python: >=3.8
Keywords: machine-learning, deep-learning, embedding, prototype-learning, text-classification, representation-learning, pytorch

# PEARL (`pearl-H`)

PEARL (**P**rototype-**E**nhanced **A**ligned **R**epresentation **L**earning) is a
lightweight, label-efficient post-processing method for **refining fixed embeddings** (e.g., sentence/document
embeddings) to improve **local neighborhood geometry** for similarity-driven systems such as kNN retrieval,
case-based routing, and embedding-based classifiers.

This package implements a practical PEARL workflow:

- **Signal extraction**: learns a small refinement network to separate class-discriminative signal from residual
  variation while preserving the original embedding dimensionality.
- **Prototype-augmented features (PAF)**: fits per-class prototypes (KMeans) and augments embeddings with
  prototype/centroid similarity features (useful for downstream lightweight models).

## Installation

```bash
pip install pearl-H
```

## Quickstart (recommended)

PEARL assumes you already have embeddings `X` from a fixed encoder. You provide a small labeled subset
`(X_train, y_train)` to fit the refinement, then transform any embeddings for retrieval/classification.

```python
import numpy as np
from pearl import PEARLPipeline

# X_train: [N, D] numpy array of embeddings
# y_train: [N] integer labels in [0, n_classes)
pipeline = PEARLPipeline(n_classes=10, device="auto")

pipeline.fit(X_train, y_train, X_val=X_val, y_val=y_val, epochs=100, patience=20)

# Choose the output you want:
X_enhanced = pipeline.transform(X_test, mode="enhanced")  # same dim as input
X_paf = pipeline.transform(X_test, mode="paf")            # augmented with prototype features
```

## Core API

- `PEARLPipeline`: end-to-end training + transformation (`fit`, `transform`, `fit_transform`).
- `SignalExtractorTrainer`: trains the refinement model; produces **same-dimensional** enhanced embeddings.
- `PAFAugmentor`: appends prototype/centroid similarity features to embeddings.
- `RAGClassifierWrapper`: retrieval-augmented classifier over embeddings (kNN retrieval + cross-attention).

### Input conventions

- Embeddings: `numpy.ndarray` of shape `[N, D]` (float32/float64).
- Labels: `numpy.ndarray` of shape `[N]` with integer class ids `0..n_classes-1`.
- Device: `"auto"`, `"cuda"`, `"mps"`, `"cpu"` (or a `torch.device`).

## Paper & citation

If you use PEARL in academic work, please cite the paper:

```bibtex
@misc{zhang2026pearlprototypeenhancedalignmentlabelefficient,
      title={PEARL: Prototype-Enhanced Alignment for Label-Efficient Representation Learning with Deployment-Driven Insights from Digital Governance Communication Systems},
      author={Ruiyu Zhang and Lin Nie and Wai-Fung Lam and Qihao Wang and Xin Zhao},
      year={2026},
      eprint={2601.17495},
      archivePrefix={arXiv},
      primaryClass={cs.LG},
      url={https://arxiv.org/abs/2601.17495},
}
```

## License

MIT License. See `LICENSE`.