semvec/pypi-packages huggingface dataset:
sbcli-36 3.8.36
CLI for managing SimplyBlock cluster


# Simply Block
[![Docker Image Build](https://github.com/simplyblock-io/sbcli/actions/workflows/docker-image.yml/badge.svg)](https://github.com/simplyblock-io/sbcli/actions/workflows/docker-image.yml)

[![Python Unit Testing](https://github.com/simplyblock-io/sbcli/actions/workflows/python-testing.yml/badge.svg)](https://github.com/simplyblock-io/sbcli/actions/workflows/python-testing.yml)


## Install
Add the package repo from AWS CodeArtifact using [awscli](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)

```bash
aws codeartifact login --tool pip --repository sbcli --domain simplyblock --domain-owner 565979732541 --region eu-west-1
```
Install package
```bash
pip install --extra-index-url https://pypi.org/simple sbcli-dev
```

# Components

## Simply Block Core
Contains core logic and controllers for the simplyblock cluster

## Simply Block CLI
Please see this document
[README.md](../main/simplyblock_cli/README.md)


## Simply Block Web API
Please see this document
[README.md](../main/simplyblock_web/README.md)



### local development

FoundationDB requires a client library (libfdb_c.dylib) for the Python bindings to interact with the database.
Depending on the OS architecture, please install the appropriate version from the official github repo

```
wget https://github.com/apple/foundationdb/releases/download/7.3.3/FoundationDB-7.3.3_arm64.pkg
```

setup the code on a management node and the webApp code can be developed by building the `docker-compose-dev.yml` file.


```
sudo docker compose -f docker-compose-dev.yml up --build -d
```
hashpw 2.6.0
Universal password hash generator and verifier
Requires Python: >=3.5
Keywords: password, hash, cli

HashPW
======
This is a Python program that prompts for a password and prints the
hash.  Also has a verify mode that confirms whether or not a provided
hash matches a typed password.

This command generates a wide variety of password hashes.  Sensible use
of exceptions handle most error conditions.

Run **`hashpw --help`** for info.

Supported algorithms (hash type identifiers `highlighted`):

  + bcrypt: Portable PHP password hashing framework, a.k.a. Phpass (`$P$`)
      - see http://www.mindrot.org/projects/py-bcrypt/
  + phpBB3 bcrypt (`$H$`)
  + [Blowfish](http://en.wikipedia.org/wiki/Crypt_(Unix)#Blowfish-based_scheme)
  + Unix schemes: Crypt (two character salt), MD5 (`$1$`), blowfish (`$2a$`), SHA-256 (`$5$`), SHA-512 (`$6$`)
  + Apache: SHA1 (`{SHA}`), MD5 (`$apr1$`)
  + MySql: SHA1 (`*`), Old
  + Basic MD5
  + SSHA
  + Django: PBKDF2

Bugs
----
  + When supplying a salt (not a full hash) in verify mode, get "ext-des
    hashing does not appear to be supported on this platform"

TO-DO
-----

  + Support Drupal 7's SHA-512-based secure hash (hash type identifier = "$S$")
  + Support generic [Password-Based Key Derivation Function 2](https://en.wikipedia.org/wiki/PBKDF2)
      - http://csrc.nist.gov/publications/nistpubs/800-132/nist-sp800-132.pdf
      - $pdkdf2$ (SHA-1)
      - $pdkdf2-sha256$ (SHA-256)
      - $pdkdf2-sha512$ (SHA-512)
  + Support scrypt <https://en.wikipedia.org/wiki/Scrypt>
  + Option to generate/recognise simple hashes (e.g. BasicMD5, OldPassword) with prefixes
  + Accept password on standard input (without confirmation)
  + Support "doveadm pw" encoding scheme suffixes (.b64, .base64 and .hex); see
    http://wiki2.dovecot.org/Authentication/PasswordSchemes
  + Support Argon2i password hashing algorithm: https://wiki.php.net/rfc/argon2_password_hash
llama-toolchain 0.0.35
Llama Stack
Requires Python: >=3.10

# llama-stack

[![PyPI - Downloads](https://img.shields.io/pypi/dm/llama-stack)](https://pypi.org/project/llama-stack/)
[![Discord](https://img.shields.io/discord/1257833999603335178)](https://discord.gg/TZAAYNVtrU)

This repository contains the specifications and implementations of the APIs which are part of the Llama Stack.

The Llama Stack defines and standardizes the building blocks needed to bring generative AI applications to market. These blocks span the entire development lifecycle: from model training and fine-tuning, through product evaluation, to invoking AI agents in production. Beyond definition, we're developing open-source versions and partnering with cloud providers, ensuring developers can assemble AI solutions using consistent, interlocking pieces across platforms. The ultimate goal is to accelerate innovation in the AI space.

The Stack APIs are rapidly improving, but still very much work in progress and we invite feedback as well as direct contributions.


## APIs

The Llama Stack consists of the following set of APIs:

- Inference
- Safety
- Memory
- Agentic System
- Evaluation
- Post Training
- Synthetic Data Generation
- Reward Scoring

Each of the APIs themselves is a collection of REST endpoints.


## API Providers

A Provider is what makes the API real -- they provide the actual implementation backing the API.

As an example, for Inference, we could have the implementation be backed by open source libraries like `[ torch | vLLM | TensorRT ]` as possible options.

A provider can also be just a pointer to a remote REST service -- for example, cloud providers or dedicated inference providers could serve these APIs.


## Llama Stack Distribution

A Distribution is where APIs and Providers are assembled together to provide a consistent whole to the end application developer. You can mix-and-match providers -- some could be backed by local code and some could be remote. As a hobbyist, you can serve a small model locally, but can choose a cloud provider for a large model. Regardless, the higher level APIs your app needs to work with don't need to change at all. You can even imagine moving across the server / mobile-device boundary as well always using the same uniform set of APIs for developing Generative AI applications.


## Installation

You can install this repository as a [package](https://pypi.org/project/llama-stack/) with `pip install llama-stack`

If you want to install from source:

```bash
mkdir -p ~/local
cd ~/local
git clone git@github.com:meta-llama/llama-stack.git

conda create -n stack python=3.10
conda activate stack

cd llama-stack
$CONDA_PREFIX/bin/pip install -e .
```

## The Llama CLI

The `llama` CLI makes it easy to work with the Llama Stack set of tools, including installing and running Distributions, downloading models, studying model prompt formats, etc. Please see the [CLI reference](docs/cli_reference.md) for details.
maxent_graph 0.3.1
Add your description here
Requires Python: >=3.12

Supports:

- Bipartite Configuration Model (BiCM) [1]
- Enhanced Configuration Model (ECM) [2]
- Directed Enhanced Configuration Model (DECM) [2]
- Bipartite Weighted Configuration Model (BWCM) [3]
- Bipartite Enhanced Configuration Model (BiECM) [3]
- Reciprocal Configuration Model (RCM) [5]

See the `examples` folder for Jupyter notebook examples of usage. There is an example of using BiCM to form a projection of a bipartite network of Senators and bills. And, there is an example of using ECM to filter edges from a graph of relations between Game of Thrones characters.

The implementation of the pmf for the Poisson-Binomial distribution (used for assessing the statistical significance of the presence of V-motifs in the BiCM) is based on [4]

Todo:

- Parallelize further?
- Use degree multiplicity to speed up dc_fft using a fast binomial pmf?
- Make poibin selection more flexible
- Multiple comparison correction
- Suppress or work around some warnings

My implementation of the BiCM was inspired by https://github.com/mat701/BiCM and https://github.com/tsakim/bicm. See also: https://github.com/nicoloval/NEMtropy. One of these might meet your needs better.

---
[1] Saracco, Fabio, Mika J Straka, Riccardo Di Clemente, Andrea Gabrielli, Guido Caldarelli, and Tiziano Squartini. “Inferring Monopartite Projections of Bipartite Networks: An Entropy-Based Approach.” New Journal of Physics 19, no. 5 (May 17, 2017): 053022. https://doi.org/10.1088/1367-2630/aa6b38.

[2] Gemmetto, Valerio, Alessio Cardillo, and Diego Garlaschelli. “Irreducible Network Backbones: Unbiased Graph Filtering via Maximum Entropy.” ArXiv:1706.00230 [Physics], June 9, 2017. http://arxiv.org/abs/1706.00230.

[3] Di Gangi, Domenico, Fabrizio Lillo, and Davide Pirino. “Assessing Systemic Risk Due to Fire Sales Spillover through Maximum Entropy Network Reconstruction.” Journal of Economic Dynamics and Control 94 (September 2018): 117–41. https://doi.org/10.1016/j.jedc.2018.07.001.

[4] Biscarri, William, Sihai Dave Zhao, and Robert J. Brunner. “A Simple and Fast Method for Computing the Poisson Binomial Distribution Function.” Computational Statistics & Data Analysis 122 (June 2018): 92–100. https://doi.org/10.1016/j.csda.2018.01.007.

[5] Squartini, Tiziano, and Diego Garlaschelli. “Analytical Maximum-Likelihood Method to Detect Patterns in Real Networks.” New Journal of Physics 13, no. 8 (August 3, 2011): 083001. https://doi.org/10.1088/1367-2630/13/8/083001.
unit-bpe 0.2.0
BPE tokenizer that operates on integer sequences
Requires Python: >=3.9

# unit-bpe

![CI](https://github.com/cromz22/unit-bpe/actions/workflows/CI.yml/badge.svg)

BPE tokenizer that operates on integer sequences.
The implementation is in Rust and Python bindings are provided utilizing [pyo3](https://github.com/PyO3/pyo3) and [Maturin](https://github.com/PyO3/maturin).

## Installation

```
pip install unit-bpe
```

## Example usage from Python

```
from unit_bpe import fit_concurrent_py, encode_concurrent_py, decode_concurrent_py

units_list = [
    [0, 1, 0, 1, 2, 0, 1, 2, 3],
    [0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5]
]
vocab_size = 10
# Since there are 6 units in the training data, 10 - 6 = 4 merge operations are performed

encoded_units, merges = fit_concurrent_py(units_list, vocab_size)
print(encoded_units)  # [[6, 7, 8], [9, 9, 5]]
print(merges)  # [((0, 1), 6), ((8, 4), 9), ((7, 3), 8), ((6, 2), 7)]

units_list_to_encode = [[0, 1, 0, 1, 2, 3, 4, 5], [0, 1, 2, 0, 1, 2, 3]]
encoded = encode_concurrent_py(units_list_to_encode, merges)
print(encoded)  # [[6, 9, 5], [7, 8]]

decoded = decode_concurrent_py(encoded, merges)
print(decoded)  # [[0, 1, 0, 1, 2, 3, 4, 5], [0, 1, 2, 0, 1, 2, 3]]
```

## Development Guide

### Installation

- Rust environment
    - See https://www.rust-lang.org/learn/get-started if you don't have Rust development environment
    - Dependencies will be automatically installed when you run cargo commands

- Python environment
    - [uv](https://docs.astral.sh/uv/) is used as the package manager
    - Run `uv sync` to install dependencies

### Running tests

- Rust

    ```
    cargo test --lib
    ```

- Python

    ```
    uv run pytest
    ```

    - To install the crate as a Python module in the virtual environment, run `maturin develop`.

### Directory structure

```
unit-bpe
├── src
│   ├── lib.rs                # Rust library entry point
│   ├── core.rs               # Core logic of BPE
│   ├── concurrent.rs         # Extension of core.rs for concurrent processing
│   ├── python_bindings.rs    # Bindings to expose Rust functions to Python
│   └── test.rs               # Rust unit tests
├── tests
│   └── test_unit_bpe.py      # Python unit tests
├── .gitignore
├── Cargo.toml                # Rust dependency definitions
├── Cargo.lock                # Rust dependency lock file
├── README.md
├── pyproject.toml            # Python dependency definitions
└── uv.lock                   # Python dependency lock file

```