semvec/pypi-packages huggingface dataset:
pico-acme 0.0.5
Pico ACME: tiny ACMEv2 client
Requires Python: >=3.8

# 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.
exact-cover-samples 0.0.8
Some exact cover problems and their solutions
Requires Python: >=3.10

# exact cover samples

contains some exact cover samples together with their solutions.

## installation

```bash
pip install exact-cover-samples
```

## usage

### problems

```python
from exact_cover_samples import problems
```

`problems` is a dictionary with the following structure:

```python
{ "shortname": function, ... }
```

where `shortname` is a string and `function` is a function that in turn returns
a dictionary with the following structure:

```python
{
    "shortname": str,               # short name of the problem
    "name": str,                    # long name of the problem
    "data": np.ndarray,             # of ndim=2 and dtype=bool
    "solutions": list[list[int]]    # each solution is a list of indices in data
}
```

in some cases `solutions` is an nd-array too - see below how to canonicalize for
comparing solutions.

### summary

you can display a summary of the available problems by running the following code:

```python
from exact_cover_samples import summary

summary()
```

will show all known problems
```
# you can also filter a bit
summary("pent")
->
the problems whose name contains 'pent' are:
===================== p3x20 ======================
size = (1236, 72),  8 solutions full_name=pentominos-3-20
===================== p4x15 ======================
size = (1696, 72),  1472 solutions full_name=pentominos-4-15
```

### canonical representation

```python
from exact_cover_samples import problems, canonical

p = problems["knuth2000"]()
s = p["solutions"]
type(s)
-> list
type(s[0])
-> tuple
type(canonical(s))
-> set

p = problems["p8x8"]()
s = p["solutions"]
type(s)
-> numpy.ndarray
type(canonical(s))
-> set
```

so that as long as your code produces solutions as an iterable of iterables,
you should be able to use `canonical` to compare them like so

```
# import this module
import exact_cover_samples as ecs
# import a solver module
from exact_cover_py import exact_covers

# get a problem
p = ecs.problems["knuth2000"]()
# get the expected solutions
expected = p["solutions"]
# get the computed solutions
computed = exact_covers(p["data"])
# compare them
assert ecs.canonical(expected) == ecs.canonical(computed)
```

and so you can write a very decent test suite for your exact cover solver by
simply iterating over the problems in `problems` and comparing the expected
solutions with the computed ones.
wave-chunk-parser 1.5.0
Parses and writes WAVE file chunks
Requires Python: >=3.7

# Wave Chunk Parser

Parses wave files chunks in order to extract metadata and audio. Also provides an option to write a bunch of given chunks back into a coherent file.

# Installation

    pip install wave-chunk-parser

# Reading a file / IO stream

    from wave_chunk_parser.chunks import RiffChunk

    with open("file.wav", "rb") as file:
        riff_chunk = RiffChunk.from_file(file)

From there you can access the sub chunks from riff_chunk.sub_chunks. The data chunk uses a numpy array to hold the vectors of audio samples.

Format (fmt) and data chunks are critical. Cart chunk is optional but provides those markers we need for handling broadcast audio.

# Writing a file / IO stream

You will need to build the chunks individually and supply them in a list of:

    chunks = [FormatChunk, DataChunk, CartChunk]

The format chunk must come before the data chunk (we need to know how to en/decode it). Cart chunk can appear anywhere in the list or even not exist at all.

To get a blob for writing to disk (or wherever), simply:

    riff_chunk = RiffChunk(chunks)
    blob = riff_chunk.to_bytes()

The to_bytes function exists on every chunk type. So, if you particularly desire, you can turn a standalone format chunk into a blob.

## Numpy on macOS

We need openblas to make Numpy work on macOS:

    pip uninstall numpy
    brew install openblas
    OPENBLAS="$(brew --prefix openblas)" pip install numpy --no-cache-dir

# Building the package for deployment

To build the package for deployment:

    poetry run python setup.py sdist bdist_wheel
    poetry run twine upload --repository testpypi dist/*
arcaea-offline 0.2.2
Manage your local Arcaea score database.
Requires Python: >=3.8

# Arcaea Offline

English | [简体中文](./README.zh_Hans.md)

<span>
  <img src="./assets/banner.png" style="height: 175px; object-fit: contain;">
</span>

> Accept <i><b>lr</b><sub>lowiro</sub></i>

## WIP

> **Warning**
> This project is under active development, thus it is unstable and API may change frequently.

## What is this？

This is the core library of `Arcaea Offline`, designed to manage player scores, calculate their potential, and provide various useful tools.

## How to use this？

This repository is a python library.

For general users, if you don't know what is a "library", you may be interested about [this GUI](https://github.com/283375/arcaea-offline-pyside-ui).

For developers, the documentation is under construction. Check back later!

## License

This file is part of arcaea-offline.

arcaea-offline is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

arcaea-offline is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with arcaea-offline. If not, see <https://www.gnu.org/licenses/>.

## Credits

[Arcaea-Infinity/ArcaeaSongDatabase](https://github.com/Arcaea-Infinity/ArcaeaSongDatabase)
my-tgcf 0.0.3
telegram forward
Requires Python: <3.12,>=3.10

# 介绍
- telegram转发 修改自:[tgcf](https://github.com/aahnik/tgcf)
- 支持代理设置,如需代理请设置环境变量,例如:`export TG_PROXY="socks5://127.0.0.1:7890"`
- 只支持linux上运行,不支持windows
# 安装示例
```shell
apt install -y python3
RUN sudo apt install -y pipx
RUN pipx ensurepath
pipx install my-tgcf
```
# 使用
1. 设置环境变量 密码:`export PASSWORD="123456"` 可选设置代理:`export TG_PROXY="123456"`
2. `tgw`
3. 浏览器打开:http://localhost:8501
causalimpsct-reloaded 1.0.0
A clone of R version CausalImpact developed by Google
Requires Python: >=3.8

#### A Python package for causal inference using Bayesian structural time-series models

This is a port of the R package CausalImpact, see: https://github.com/google/CausalImpact.

This package implements an approach to estimating the causal effect of a designed intervention on a time series. For example, how many additional daily clicks were generated by an advertising campaign? Answering a question like this can be difficult when a randomized experiment is not available. The package aims to address this difficulty using a structural Bayesian time-series model to estimate how the response metric might have evolved after the intervention if the intervention had not occurred.

As with all approaches to causal inference on non-experimental data, valid conclusions require strong assumptions. The CausalImpact package, in particular, assumes that the outcome time series can be explained in terms of a set of control time series that were themselves not affected by the intervention. Furthermore, the relation between treated series and control series is assumed to be stable during the post-intervention period. Understanding and checking these assumptions for any given application is critical for obtaining valid conclusions.

#### Try it out in the browser

[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/yaseenesmaeelpour/pycausalimpact/HEAD?labpath=GettingStarted.ipynb)

#### Installation

install the latest release via pip

```bash
pip install py-causalimpact
```

#### Getting started

[Documentation and examples](https://nbviewer.org/github/yaseenesmaeelpour/pycausalimpact/blob/master/GettingStarted.ipynb)

#### Further resources

- Manuscript: [Brodersen et al., Annals of Applied Statistics (2015)](http://research.google.com/pubs/pub41854.html)

#### Bugs

The issue tracker is at https://github.com/yaseenesmaeelpour/pycausalimpact/issues. Please report any bugs that you find. Or, even better, fork the repository on GitHub and create a pull request.