semvec/pypi-packages huggingface dataset:
asciidocwriter 0.0.3.3
Asciidoctor generator

# AsciidocWriter
[![PyPI Latest Release](https://img.shields.io/pypi/v/asciidocwriter.svg)](https://pypi.org/project/asciidocwriter/)

## What is it?

**AsciidocWriter** is a Python module for creating AsciiDoc files

## Where to get it
The source code is currently hosted on GitHub at:
https://github.com/vidigalp/asciidocwriter


Binary installers for the latest released version are available at the [Python
Package Index (PyPI)](https://pypi.org/project/asciidocwriter).

```sh
# or PyPI
pip install asciidocwriter
```

## How to Run

```python
python asciidocwriter ...
```

## Dependencies
- [Pandas - pandas is a fast, powerful, flexible and easy to use open source data analysis and manipulation tool, built on top of the Python programming language.](https://pandas.pydata.org)
- [NumPy - Adds support for large, multi-dimensional arrays, matrices and high-level mathematical functions to operate on these arrays](https://www.numpy.org)
- [python-dateutil - Provides powerful extensions to the standard datetime module](https://dateutil.readthedocs.io/en/stable/index.html)
- [pytz - Brings the Olson tz database into Python which allows accurate and cross platform timezone calculations](https://github.com/stub42/pytz)
- [Click - Click is a Python package for creating beautiful command line interfaces in a composable way with as little code as necessary.](https://click.palletsprojects.com/)
- [tqdm - Instantly make your loops show a smart progress meter - just wrap any iterable with tqdm(iterable), and you're done!](https://tqdm.github.io)
unimatrix.ext.crypto 0.24.0
Enter a description for this Unimatrix package

# Cryptographic Abstraction Layer

The `unimatrix.ext.crypto` package provides an abstraction layer to
apply cryptographic algorithms independent of the key management technology
used.

Install `unimatrix.ext.crypto`:

```
$ $ pip install --upgrade unimatrix.ext.crypto
```

Make sure that your local environment satisfies the [specified prequisites](#prequisites).

Head over to the  [development section](#developing) if you plan to contribute
to this project. The technical documentation is available at
https://unimatrixone.gitlab.io/libraries/python-unimatrix/crypto/.


## Prequisites

The following Python version(s) are compatible with the `unimatrix.ext.crypto` package:

- 3.8
- 3.9

To install or upgrade Python, visit https://www.python.org/downloads/ and
choose one of the supported releases.

## Developing ##

Clone the source code repository:

```
$ git clone git@gitlab.com:unimatrixone/libraries/python-unimatrix/crypto.git
```

- Run `make env` to set up the local development environment.
- Run `make console` to start a Python interpreter.
- If new requirements are added to the project (see `git log requirements.txt`),
  run `make depsrebuild`.
- Export the environment variables to a file with `make .env`. Use this command
  when integrating with third-party IDEs such as Eclipse or VSCode. Do not check
  in this file to the version control system - it is local to your environment
  only.
- Build the technical documentation with `make documentation`.
- Additional targets may be specified in [`config.mk`](./config.mk).

## License

Proprietary

[Click or tap here for licensing requests](mailto:cochise.ruhulessin@unimatrixone.io).

## Author information

This Python package was created by **Cochise Ruhulessin** for the
[Unimatrix One](https://cloud.unimatrixone.io) project.

- [Send me an email](mailto:cochise.ruhulessin@unimatrixone.io)
- [GitLab](https://gitlab.com/unimatrixone)
- [GitHub](https://github.com/cochiseruhulessin)
- [LinkedIn](https://www.linkedin.com/in/cochise-ruhulessin-0b48358a/)
- [Twitter](https://twitter.com/magicalcochise)
numberpartitioning 0.0.2
Pure Python solver for the multi-way partition problem
Requires Python: >=3.7

# Partition problem solvers in Python

This repository includes an implementation of the [Karmarkar--Karp algorithm](https://en.wikipedia.org/wiki/Largest_differencing_method) (also known as the largest differencing method) for the [multiway number partitioning optimization problem](https://en.wikipedia.org/wiki/Multiway_number_partitioning), as well as some greedy algorithms.

## The problem

Concretely, the problem we solve is the following: Suppose *S* is some collection of integers, and *k* is some positive integer, find a partition of *S* into *k* parts so that the sums of the integers in each part are as close as possible.

The objective function describing "closeness" is usually taken to be the difference between the largest and smallest sum among all parts. The optimization version is NP-hard, and the bundled algorithm only aims to provide a good solution in short time. This also means that they can be useful for other objective functions such as, say, the variance of all sums.

## Installation

The package is available from [PyPI](https://pypi.org/project/numberpartitioning/):

```sh
pip install numberpartitioning
```

It can also be obtained from [conda-forge](https://anaconda.org/conda-forge/numberpartitioning):

```sh
mamba install -c conda-forge numberpartitioning
```

## Examples

Suppose we want to split the collection `[4, 6, 7, 5, 8]` into three parts. We can achieve that as follows:

```python
from numberpartitioning import karmarkar_karp
numbers = [4, 6, 7, 5, 8]
result = karmarkar_karp(numbers, num_parts=3)
```

Here, `result.partition` becomes `[[8], [4, 7], [5, 6]]`, and `result.sizes` are the sums of each part, `[8, 11, 11]`. This happens to be optimal.

As noted [on Wikipedia](https://en.wikipedia.org/wiki/Largest_differencing_method), an example where this approach does not give the optimal result is the following:

```python
from numberpartitioning import karmarkar_karp
numbers = [5, 5, 5, 4, 4, 3, 3, 1]
result = karmarkar_karp(numbers, num_parts=3)
```

Here, `result.sizes` is `[9, 10, 11]` but it is possible to achieve a solution in which the sums of each part is 10.