semvec/pypi-packages huggingface dataset:
BSTPythonSDK 3.23.0.dev1
BST Flight Management SDK

This is the public SDK for the Black Swift Technologies SwiftCore flight
management system. More information on the products this works with can be
found on our website https://bst.aero

For information on using this with a gazebo multi-rotor simulation, see here:
https://gitlab.com/bstaero/sdk/-/wikis/gazebo-setup

For information interfacing with the BST SwiftFlow wind probe, see here:
https://gitlab.com/bstaero/sdk/-/wikis/swiftflow-interface

## Python SDK

### Prerequisites

Installing the Python SDK requires the following to be installed on your machine:

- swig
- python3-dev

### Install

`pip install BSTPythonSDK`

### Import

`import bst_python_sdk`

### Usage

#### Parse Log

```py
from bst_python_sdk.logparse import Parser

log_path = "path/to/log.bin"
parser = Parser()

# parsed_log will be a dict containing all packets from the provided log
parsed_log = parser.parse_log(log_path)
```

#### Log -> NetCDF

```py
from bst_python_sdk.log_to_nc import convert_to_nc

log_path = "path/to/log.bin"

# output will be a list of the converted logs in netcdf format
# Ex: ["log_010_FW0001.nc", "log_010_SwiftStation.nc"]
output = convert_to_nc(log_path)
```
webdriver-kaifuku 25.10.22
Restartable webdriver instances
Requires Python: >=3.8
Keywords: selenium

<h1 align="center"> webdriver_kaifuku </h1>
<h3 align="center"> Restartable webdriver instances </h3>

<p align="center">
    <a href="https://pypi.org/project/webdriver-kaifuku/">
    <img alt="Python Versions" src="https://img.shields.io/pypi/pyversions/webdriver-kaifuku.svg?style=flat">
    </a>
    <a href="https://pypi.org/project/webdriver_kaifuku/#history">
    <img alt="PyPI version" src="https://badge.fury.io/py/webdriver-kaifuku.svg">
    </a>
    <a href="https://codecov.io/gh/RedHatQE/webdriver_kaifuku">
      <img src="https://codecov.io/gh/RonnyPfannschmidt/webdriver_kaifuku/branch/master/graph/badge.svg" />
    </a>
    <a href="https://github.com/RonnyPfannschmidt/webdriver_kaifuku/actions/workflows/test_suite.yml">
    <img alt="github actions" src="https://github.com/RonnyPfannschmidt/webdriver_kaifuku/actions/workflows/test_suite.yml/badge.svg">
    </a>
    <a href="https://github.com/RonnyPfannschmidt/webdriver_kaifuku/blob/master/LICENSE">
    <img alt="License" src="https://img.shields.io/pypi/l/webdriver_kaifuku.svg?version=latest">
    </a>
</p>
The library provides restartable webdriver instances.

### Usage:
It support both `local` and `remote` webdriver. Some basic examples are-

- Local Browser

Make sure `webdriver` is already installed on your local machine.
```python
from webdriver_kaifuku import BrowserManager

manager = BrowserManager.from_conf({"webdriver": "Chrome"})
manager.start()
manager.close()
```
- [Selenium Container](https://github.com/RedHatQE/selenium-images)

```python
from webdriver_kaifuku import BrowserManager

manager_config = {
    "webdriver": "Remote",
    "webdriver_options": {
        "desired_capabilities": {"browserName": "firefox"},
        "command_executor": "http://localhost:<port>",
    },
}
manager = BrowserManager.from_conf(manager_config)
manager.start()
manager.close()
```
sco1-pylox 0.5.2
A Python interpreter for the Lox programming language.
Requires Python: >=3.12

# pylox
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/sco1-pylox/0.5.2?logo=python&logoColor=FFD43B)](https://pypi.org/project/sco1-pylox/)
[![PyPI](https://img.shields.io/pypi/v/sco1-pylox?logo=Python&logoColor=FFD43B)](https://pypi.org/project/sco1-pylox/)
[![PyPI - License](https://img.shields.io/pypi/l/sco1-pylox?color=magenta)](https://github.com/sco1/sco1-pylox/blob/main/LICENSE)
[![pre-commit.ci status](https://results.pre-commit.ci/badge/github/sco1/pylox/main.svg)](https://results.pre-commit.ci/latest/github/sco1/pylox/main)

## Introduction
This is my Python implementation of an interpreter for the Lox programming language from Robert Nystrom's *[Crafting Interpreters](https://craftinginterpreters.com/)*.

## Python?
While the text is implemented in Java and C as its high & low-level implementations, I have no idea how to write either of them! Instead, I'll be using Python for the high-level implementation & eventually Rust for the low-level imeplementation.

## Differences From Text
For the sake of fitting within a decently sized text, the fully implemented Lox spec omits features that users of other programming languages may miss. Often these are discussed as notes within a chapter, or presented as challenges at the end of a chapter. Significant difference in this implementation from the text reference are noted below.
### Defined by Challenges
  * (Chapter 4): Arbitrarily nested block comments (`/* ... */`)
  * (Chapter 9): `break` statements are available for `for` and `while` loops
### User Choice
  * Division by zero returns `NaN` (Python's `float('nan')`)
  * Strings may be defined using either `"` or `'`
  * Modulo operator (`%`)
  * Power operator (`^`)
  * Integer division operator (`\`)
  * Both floats and integers are represented
    * Return type from operations follows Python3's semantics
  * Containers
    * `array()`
  * A basic `include` header system
    * Supports "stdlib" imports (`<header_name>`) and path imports (`"path/to/file"`)
    * Recursive `include` not supported
    * Imported source assumed to be valid code

### Additional Built-ins:
Unless otherwise noted, behavior mirrors the similarly named Python function.

#### General
  * `input`
  * `len`
  * `ord`
  * `read_text` (via `pathlib.Path.read_text`)
  * `str2num`
  * `string_array`
    * Gives a `LoxArray` whose contents are equivalent to `collections.deque(<some string>)`

#### Math
  * `abs`
  * `ceil`
  * `divmod`
  * `floor`
  * `max`
  * `min`

#### Regex
For methods whose Python equivalent returns [Match objects](https://docs.python.org/3/library/re.html#match-objects), a `LoxArray` is returned. The first value in the array will always correspond to `match.group(0)`; if the pattern contains one or more groups then the array will match the output of `match.groups()`

  * `re_findall`
  * `re_match`
  * `re_search`
  * `re_sub`

#### Stats
  * `mean`
  * `median`
  * `mode`
  * `std`

### Pure lox headers
  * `<array_sum>`
  * `<hello_world>`
  * `<map>`
  * `<split_on>`
predipy 0.2.0
Lightweight Python library for prediction & regression
Requires Python: >=3.8

# Predipy

ML lib Python + Go.

## Setup
1. Go: cd go_backend && go mod tidy && go build -o main main.go
2. Python: pip install -e .

## Run Example
python examples/example_regression.py

## Test
pytest tests/

# Predipy

**Predipy** is a lightweight Python ML library with a Go backend for fast regression and KNN classification.  
It supports linear regression and K-Nearest Neighbors (KNN) for regression & classification.

---

## Features

- Linear regression with normal equation + optional ridge regularization.
- KNN classification with Euclidean distance.
- Lightweight, fast, and works offline.
- Go backend for computational efficiency.
- Easy Python interface.

---

## Installation

Install from PyPI:

```bash
pip install predipy
img2ascii-pro 1.3
Convert images to colored ASCII art (text + HTML)

# img2ascii_pro
Convert any image into colorful ASCII art directly in your terminal or export it as HTML or text

---

## Installation
Install from **PyPI** using:
```bash
pip install img2ascii-pro
```
---
Convert any image to ASCII art:
img2ascii_pro myphoto.jpg
---
Command Options

| Option                 | Description                                                   |
| ---------------------- | ------------------------------------------------------------- |
| `--width`              | Set the output width (default: 100)                           |
| `--preset`             | Choose a character preset: `realistic`, `minimal`, or `block` |
| `--invert`             | Invert the character brightness for dark/light reversal       |
| `--html output.html`   | Save the result as a colored HTML file                        |
| `--outfile output.txt` | Save the ASCII result to a plain text file                    |
---
Import and Use in Python

from PIL import Image
from img2ascii_pro import *

img = Image.open("photo.jpg")
ascii_lines, _, _, _ = image_to_ascii(img, width=100, chars=PRESETS["block"])

for line in ascii_lines:
    print(line)
CryptoC 1.0.0
A library for various cryptography algorithms (Caesar, Hill Cipher.)
Requires Python: >=3.6

# Cryptography Library
![Python](https://img.shields.io/badge/Python-3.6%2B-blue)
![License](https://img.shields.io/badge/License-MIT-green)
![Version](https://img.shields.io/badge/Version-1.0.0-orange)

A Python library for implementing and working with various classical encryption algorithms. This library provides a collection of ciphers that you can use to encrypt and decrypt data in educational or practical cryptography-related projects.

---

## Features
This library includes the following classical ciphers:
- **Caesar Cipher**: A substitution cipher that shifts letters by a fixed number.
- **Monoalphabetic Cipher**: A substitution cipher where each character is replaced by another character using a key.
- **Vigenere Cipher**: A polyalphabetic substitution cipher that uses a keyword to encrypt data.
- **Vernam Cipher**: A stream cipher that uses a key of the same length as the plaintext for encryption.
- **Playfair Cipher**: A digraph substitution cipher that encrypts pairs of letters.
- **Hill Cipher**: A cipher based on linear algebra that uses matrix multiplication for encryption.

---

## Installation
You can install this library using `pip`:

```bash
pip install CryptoC
```
## Usage
Here’s how to use the library in your Python project:

### Import the Cipher Classes
```bash
from CryptoC import Caesar, Monoalphabetic, Vigenere, Vernam, Playfair, HillCipher
```
### Example: Caesar Cipher
```python
# Initialize the Caesar cipher with a shift value of 3
caesar = Caesar(3)

# Encrypt a plaintext
encrypted = caesar.encrypt("HELLO")
print("Encrypted text:", encrypted)

# Decrypt the ciphertext
decrypted = caesar.decrypt(encrypted)
print("Decrypted text:", decrypted)
```
### Example: Vigenere Cipher
```python
# Initialize the Vigenere cipher with a keyword
vigenere = Vigenere("KEY")

# Encrypt a plaintext
encrypted = vigenere.encrypt("HELLO")
print("Encrypted text:", encrypted)

# Decrypt the ciphertext
decrypted = vigenere.decrypt(encrypted)
print("Decrypted text:", decrypted)
```
## Available Classes
1- Caesar:
```python
caesar = Caesar(3)
caesar.encrypt(plaintext)
caesar.decrypt(ciphertext)
```
2- Monoalphabetic:
```python
mono = Monoalphabetic("QWERTYUIOPLKJHGFDSAZXCVBNM")
mono.encrypt(plaintext)
mono.decrypt(ciphertext)

```
2- Vigenere:
```python
vigenere = Vigenere("KEY")
vigenere.encrypt(plaintext)
vigenere.decrypt(ciphertext)
```
4- Vernam:
```python
vernam = Vernam("RANDOMKEY")
vernam.encrypt(plaintext)
vernam.decrypt(ciphertext)
```
5- Playfair:
```python
playfair = Playfair("KEYWORD")
playfair.encrypt(plaintext)
playfair.decrypt(ciphertext)
```
6- HillCipher:
```python
hill = HillCipher([[2, 3], [1, 4]])
hill.encrypt(plaintext)
hill.decrypt(ciphertext)
```
## License
This library is licensed under the MIT License. See the [LICENSE](LICENSE) file for more information.
## Contributing
Contributions are welcome! Feel free to submit issues or pull requests to improve the library.
## Author
Created by Ibrahem abo kila. For any inquiries, please contact me at ibrahemabokila@gmail.com.
blobid 0.6.1
Identify bubbles/droplets based on volume of fluid (VOF) simulation data
Requires Python: >=3.10

# BlobID-Python

A python library for identifying bubbles/droplets based on volume of fluid (VOF) simulation data.

# Installation

It is suggested to install the library with [Numba](https://numba.pydata.org/) enabled:
```
pip install blobid[numba]
```

# Documentation

For the latest release: [dgaylo.github.io/blobid-python](https://dgaylo.github.io/blobid-python)

# Example

Here we load a 2D slice from a simulation of air bubbles in water near the surface, 
and then use this library to identify and label all the air bubble.
```Python Console
>>> import numpy as np
>>> from blobid import get_labels
>>> vof = 1.0 - np.load("tests/resources/fs_vof.npy")[:, 0, :]
>>> labels = get_labels(vof, periodic=[True, False])
```

Below is a rendering of the `vof` field (air is white, water is black) and the `labels` field calculated using `get_labels()`

![vof and label field](doc/example.svg)

The full script, including creating these graphics using [Matplotlib](https://matplotlib.org/), is [doc/example.py](doc/example.py).