semvec/pypi-packages huggingface dataset:
BuscoPhylo 0.2.2
BuscoPhylo is a free, online pipeline for performing BUSCO-based phylogenomic analysis. It quickly analyzes genome sequences in FASTA format and provides results ready for publication. The user-friendly interface makes it accessible for anyone to use.

This is a new code that creates a Python module "buscophylo" for tree-based phylogenetics. It has functions to set and retrieve token, project name, lineage, mode, project group, and directory information. The run function checks if all required information is set and raises a "ValueError" if any information is missing. It then validates the token by making a post request to the "https://buscophylo.inra.org.ma/api/post.php" API endpoint with the token as data. If the response is equal to "valid", the token is valid and a message is printed to the console indicating this. If the response is not equal to "valid", a "ValueError" is raised indicating that the token is not valid. The code also sets up color formatting for console messages on Windows and non-Windows systems. To use the module, import it and set all required information with the respective functions before calling buscophylo.run().
reactionmechanismgenerator 0.0.0a0
Reaction Mechanism Generator

# ATTENTION:
## This is an alpha release of ReactionMechanismGenerator and is NOT suitable for general use NOR development.
To install RMG, follow the install instructions on [the Official RMG page](https://reactionmechanismgenerator.github.io/RMG-Py/users/rmg/installation/index.html).
Lab93-TradeClient 0.0.3
Manage Lab funding through risk management.
Requires Python: >=3.7

# Alpaca Account Data
Retrieve and prepare data related to an alpaca.market trading account.  Uses Alpaca-Py and CredentialManagement.

## Positions
Positions refer to any non-fiat assets held by the account.  This could be bitcoin, or other
currencies, or stocks i.e., us securities.  The position tells you the nominal units being held,
their initial buy-in price, their current market value, the resulting profit/loss, and current
going price.
base16 0.1.2
base16 is like hexadecimal, but with an alphabet chosen to minimise human transcription errors.

# Base16

A human-readable, compact binary data representation. Base16 is the hexidecimal system with a different character set - chosen to minimize ambiguity between letters. It is useful for high entropy inputs like voucher codes and confirmation codes. By default, when an alphanumeric character outside the base16 character set is decoded it is first replaced with the most similar valid character. The main goal is to minimise user frustration around these types of data input.


# Character Set

| Hexidecimal | Base16 |
|:-----------:|:------:|
|      0      |   A    |
|      1      |   B    |
|      2      |   C    |
|      3      |   D    |
|      4      |   E    |
|      5      |   G    |
|      6      |   H    |
|      7      |   K    |
|      8      |   P    |
|      9      |   R    |
|      a      |   S    |
|      b      |   T    |
|      c      |   W    |
|      d      |   X    |
|      e      |   Y    |
|      f      |   Z    |


# Usage

## Install
```bash
pip install base16
```

## Python
```python3
>>> import base16

>>> base16.encode(b'Hello, World!')
b'EPHGHWHWHZCWCAKKHZKCHWHECB'

>>> base16.decode(b'EPHGHWHWHZCWCAKKHZKCHWHECB')
b'Hello, World!'

>>> base16.random(16)
b'BABKXPWCBBPZDGPB'
```

## Command Line
```bash
> bash16 --encode "Hello, World!"
EPHGHWHWHZCWCAKKHZKCHWHECB

> bash16 --decode "EPHGHWHWHZCWCAKKHZKCHWHECB"
Hello, World!

> base16 --random 32
PKCTPECYBZGGXKRATBCCHGWDDECKCWCA

> echo "some piped data" | base16 --encode
KDHZHXHGCAKAHRKAHGHECAHEHBKEHB

> echo "KDHZHXHGCAKAHRKAHGHECAHEHBKEHB" | base16 --decode
some piped data

```


# Decoding Incorrect Characters

If the user tries to decode a character not included in the base16 character set, we first replace it with the most-likely intended valid character. These replacement characters were chosen from a 1983 study [1] of four male university students' transcription errors. When a more representative study is found, these values can be safely changed later.

| Invalid | Valid |
|:-------:|:-----:|
|    0    |   D   |
|    1    |   T   |
|    2    |   Z   |
|    3    |   E   |
|    4    |   A   |
|    5    |   S   |
|    6    |   G   |
|    7    |   T   |
|    8    |   B   |
|    9    |   P   |
|    F    |   E   |
|    I    |   T   |
|    J    |   T   |
|    L    |   E   |
|    M    |   W   |
|    N    |   H   |
|    O    |   D   |
|    Q    |   D   |
|    U    |   W   |
|    V    |   Y   |


# References

[1] Gupta, S.M. et al., Proceedings of the SIGCHI Conference on Human Factors in Computing Systems, 1983, 83, 144-149
python-iso4217 0.0.8
Lightweight ISO 4217 currency package
Requires Python: >=3.6,<4.0

# `python-iso4217`: fast currency data package for Python

---

This python package automatically updates its own
currency data using github actions and immediately release
new version of package with updates. So it's super fast and at the same time always contains fresh data.

## Installation

### Pip

```bash
pip install python-iso4217
```

### Poetry

```bash
poetry add python-iso4217
```

## Usage

```python
from iso4217 import find_currency, iter_currency

# Filters that could be applied:
#   * currency_name
#   * alphabetical_code
#   * entity
#   * decimal_places
#   * numeric_code
#   * withdrawal_date
# The filters correspond to attributes of `Currency` class

# accept arbitrary filters as key/value pairs
currency = find_currency(currency_name="usd")

# if currency was not found, the lib will immediately raise CurrencyNotFoundError
defunct_currency = find_currency(currency_name="abc123")

# You need generator to lazy iter currencies? Ok

for c in iter_currency():
# do something
```

## Advanced


### Work with pydantic

```python
import inspect

from iso4217 import Currency as _Currency, find_currency
from pydantic import BaseModel, root_validator, StrictInt


class Currency(BaseModel, _Currency):
    __root__: StrictInt

    @root_validator(skip_on_failure=True)
    def humanize(cls, values):
        currency_numeric_code: int = values.get("__root__")
        # inspect.getfullargspec(_Currency.__init__) will contain `self`, so we cut it off
        orig_currency_cls_dunder_init_arg_names = inspect.getfullargspec(_Currency.__init__).args[1:]
        currency = find_currency(numeric_code=currency_numeric_code)
        return {
            k: getattr(currency, k, None)
            for k in orig_currency_cls_dunder_init_arg_names
        }
```
ansible-output-parser 0.1.0
Parser for Ansible output
Requires Python: >=3.9

Ansible Parser
==============

The Ansible Parser is intended to parse the output that Ansible returns.

Installation
------------

Simply install using:

.. code-block:: sh

    pip install ansible-output-parser

Usage
-----

.. code-block:: python

    from ansible_parser.play import Play
    play = "" # populate with play output
    ansible = Play(play_output=play)
    failures = ansible.failures()

Alternatively the following can be executed to read from a log file:

.. code-block:: python

    from ansible_parser.logs import Logs
    log_file = "" # path to log file
    log_plays = Logs(log_file=log_file)

Reading from a log file will result in multiple plays as it may process plays with the same
name.