semvec/pypi-packages huggingface dataset:
pico_acme 0.1.0
Pico ACME: tiny ACMEv2 client
Requires Python: >=3.10

# pico acme

The tiniest python package to get ACMEv2 certs from [Let's Encrypt](https://letsencrypt.org/).

Supports only single domains and DNS challenge. Currently implements AWS Route 53 but you can trivially implement your own provider.

Licensed under Apache 2.0 as this reuses some code from certbot.

## quick start

Install from PyPI:

```sh
pip install pico-acme
```

(Note that you need to install `boto3` separately to use `route53`.)

### `new.py`:

```py
ROUTE53_HOSTED_ZONE_ID = "..."
ACCOUNT_EMAIL = "domains@example.com"
DOMAIN = "example.com"

# create account, get cert, and save details
import pico_acme
from pico_acme import route53

# register an acme account
acme_client = pico_acme.register_account(ACCOUNT_EMAIL, agree_tos=True)

# create a private key and certificate signing request
key_pem = pico_acme.make_key()
csr_pem = pico_acme.make_csr(key_pem, [DOMAIN])

# get functions for upserting and cleaning up DNS records in AWS Route 53
upsert, clean = route53.route53_upsert_cleanup(ROUTE53_HOSTED_ZONE_ID)

# perform DNS-01 challenge to get the full chain as PEM
fullchain_pem = pico_acme.perform_dns01(acme_client, DOMAIN, csr_pem, upsert, clean)

# save account for later
with open("pico_acme_account.json", "w") as f:
    f.write(pico_acme.serialize_account(acme_client))

# save private key for later
with open("key.pem", "wb") as f:
    f.write(key_pem)

# save the cert for later
with open("fullchain.pem", "w") as f:
    f.write(fullchain_pem)
```

### `renew.py`:

```py
ROUTE53_HOSTED_ZONE_ID = "..."
DOMAIN = "example.com"

# later, load account, private key, and renew cert
import pico_acme
from pico_acme import route53

# load account
with open("pico_acme_account.json") as f:
    acme_client = pico_acme.deserialize_account(f.read())

# load private key
with open("key.pem", "rb") as f:
    key_pem = f.read()

# make a new certificate signing request
csr_pem = pico_acme.make_csr(key_pem, [DOMAIN])

# get functions for upserting and cleaning up DNS records in AWS Route 53
upsert, clean = route53.route53_upsert_cleanup(ROUTE53_HOSTED_ZONE_ID)

# perform DNS-01 challenge to get the full chain as PEM
fullchain_pem = pico_acme.perform_dns01(acme_client, DOMAIN, csr_pem, upsert, clean)

# save the cert for later
with open("fullchain.pem", "w") as f:
    f.write(fullchain_pem)
```

### checking if you need to renew

```py
import pico_acme

with open("fullchain.pem") as f:
    fullchain_pem = f.read()

if pico_acme.should_renew(fullchain_pem):
    print("due for renewal")
```

## architecture & features

The `perform_dns01` takes two callables, `upsert(record, value)` which should set the value `value` (the verification string) in record `record` (e.g. `_acme-challenge.example.com`), and `clean(record, value)` which should clean these up. See the `route53.py` implementation for details.

## acknowledgements

This is based very heavily on [certbot](https://github.com/certbot/certbot), with portions copied directly.
epub2md 0.2.2
Convert EPUB to clean Markdown chapters
Requires Python: >=3.8

# epub2md

Convert EPUB to clean Markdown chapters.

## Install

```bash
pip install epub2md
```

## Usage

```bash
epub2md book.epub          # Creates book/*.md and book/images/
epub2md book.epub output   # Creates output/*.md and output/images/
```

Output:
```
book/
├── 01-chapter-i.md
├── 02-chapter-ii.md
├── ...
└── images/
    └── *.jpeg
```

> Images are git-ignored by default. To commit them: `rm book/images/.gitignore`

## Requirements

- Python 3.8+
- [pandoc](https://pandoc.org/installing.html)

## License

MIT

---

[Discussion on Hacker News](https://news.ycombinator.com/item?id=45951820)
bloop-sdk 0.2.0
Python SDK for bloop error observability
Requires Python: >=3.9
Keywords: error-tracking, monitoring, observability

# @bloop/python

Python SDK for [bloop](https://github.com/your-org/bloop) error observability. Zero dependencies — uses only the Python standard library.

## Install

```bash
pip install bloop-sdk
```

## Usage

```python
from bloop import BloopClient

client = BloopClient(
    "https://bloop.example.com",
    "your-project-api-key",
    environment="production",
    release="1.0.0",
)

# Capture an error
client.capture("ValueError", "invalid input", stack="Traceback ...")

# Or use as context manager for automatic cleanup
with BloopClient("https://bloop.example.com", "key") as client:
    client.capture("TypeError", "oops")

# Auto-capture unhandled exceptions
client = BloopClient("...", "key", auto_capture=True)
```

## API

### `BloopClient(endpoint, project_key, **opts)`

- `flush_interval` (float): Seconds between automatic flushes. Default: `5.0`
- `max_buffer_size` (int): Flush when buffer reaches this size. Default: `100`
- `environment` (str): Environment tag. Default: `"production"`
- `release` (str): Release version tag. Default: `""`
- `auto_capture` (bool): Install `sys.excepthook` to capture unhandled exceptions. Default: `False`

### `client.capture(error_type, message, **kwargs)`

Buffer an error event. Keyword arguments: `source`, `stack`, `route_or_procedure`, `screen`, `metadata`.

### `client.flush()`

Send all buffered events immediately.

### `client.close()`

Flush and stop background timer.
falkordb-bin 1.4.1
Precompiled redis-server and FalkorDB module binaries
Requires Python: >=3.10

# falkordb-bin

Platform-specific binary wheels for embedded FalkorDB usage in `falkordb-py`.

This package ships:
- `redis-server` (built from Redis source)
- `falkordb.so`/`falkordb.dylib` (downloaded from FalkorDB GitHub releases)

## Install

```bash
pip install falkordb-bin
```

## Python API

```python
import falkordb_bin

redis_server = falkordb_bin.get_redis_server()
module_path = falkordb_bin.get_falkordb_module()
```

## Release model

- Wheels are platform-specific and published from CI.
- `falkordb-bin` version should mirror `falkordb` version.
pyiapws 0.6.1
pyiapws: IAPWS for python.
Requires Python: >=3.10

# Introduction

Python wrapper around the
[Fortran iapws library](https://milanskocic.github.io/iapws/index.html).
The Fortran library does not need to be installed, the python wrapper embeds all needed dependencies for Windows and MacOS.
On linux, you might have to install `libgfortran` if it is not distributed with your linux distribution. 

All functions that operate on arrays, more precisely on objects with the buffer protocol, return memory views
in order to avoid compilation dependencies on 3rd party packages.


# Installation

In a terminal, enter:

```python
pip install pyiapws
```


# Usage

[Example in python](https://milanskocic.github.io/iapws/page/examples.html#python).


# License

MIT