semvec/pypi-packages huggingface dataset:
vickycalulator 0.3.0
A Python package offering basic math calculations
Requires Python: >=3.6

# vickycalulator

**vickycalulator** is a Python package that provides a handful of basic math operationsâ€”`add`, `subtract`, `multiply`, and `divide`. Perfect for simple arithmetic in your scripts or notebooks.

![Calculator Illustration](https://via.placeholder.com/500x150?text=Calculator+Image)

## Installation

You can install the latest release directly from [PyPI](https://pypi.org/) using `pip`:

```bash
pip install vickycalulator
```

## Usage

```python
import vickycalulator

print(vickycalulator.add(10, 5))       # 15
print(vickycalulator.subtract(10, 5))  # 5
print(vickycalulator.multiply(10, 5))  # 50
print(vickycalulator.divide(10, 5))    # 2.0
```

### Example
```python
import vickycalulator

a, b = 12, 3
sum_result      = vickycalulator.add(a, b)
difference      = vickycalulator.subtract(a, b)
product         = vickycalulator.multiply(a, b)
quotient        = vickycalulator.divide(a, b)

print(f"{a} + {b} = {sum_result}")
print(f"{a} - {b} = {difference}")
print(f"{a} x {b} = {product}")
print(f"{a} / {b} = {quotient}")
```
sqlgbm 0.2.0
Convert tree-based ML models to SQL queries
Requires Python: >=3.7

## sqlgbm

⚠️ Warning: This library is in a very early development stage. The API and functionality will improve significantly over time. Not ready for production use yet.

sqlgbm is a Python library that converts tree-based machine learning models into SQL queries.
This allows you to deploy your ML models directly in your database without any additional infrastructure.

![sqlgbm in action](assets/image.png)

### installation
```bash
pip install sqlgbm
```

### overview

sqlgbm takes your trained tree-based models and generates SQL code that reproduces the model's predictions. This enables you to:

- Run predictions directly in your database
- Eliminate latency from API calls between your database and ML serving infrastructure
- Simplify your production architecture by removing additional serving components

### supported models

Currently supported models:
- LightGBM
- XGBoost

### usage

#### basic example

```python
from sqlgbm import SQLGBM
import lightgbm as lgb
import pandas as pd

# Load titanic dataset
titanic = pd.read_csv('titanic.csv')
features = ['pclass', 'sex', 'age', 'fare']
X = titanic[features]
X['sex'] = X['sex'].astype('category')
y = titanic['survived']

# Train model
clf = lgb.LGBMClassifier(n_estimators=3, max_depth=3)
clf.fit(X, y, categorical_feature=['sex'])

# Convert to SQL
sqlgbm = SQLGBM(clf, cat_features=['sex'])
sql = sqlgbm.generate_query('titanic', 'probability')

print(sql)
```

#### xgboost example

```python
import xgboost as xgb
from sqlgbm import SQLGBM

# Prepare data and train model
# ...

# Convert XGBoost model to SQL
model = xgb.XGBClassifier(n_estimators=3, max_depth=3, base_score=0.5)
model.fit(X, y)

sqlgbm = SQLGBM(model, X=X)  # X used to infer categorical features
sql = sqlgbm.generate_query('my_table', 'all')
```

#### output types

sqlgbm supports different output formats through the `output_type` parameter:

- `raw`: Returns the raw model output
- `probability`: Returns the probability (after sigmoid transformation)
- `prediction`: Returns the binary prediction (0 or 1) based on a 0.5 threshold
- `all`: Returns all three outputs

Additional options:
- `fast_sigmoid`: Use a faster approximation of the sigmoid function

## roadmap

- [ ] Add support for CatBoost
- [ ] Optimize SQL generation for large models
- [ ] Add support for multiclass classification
- [ ] Provide specialized optimizations for different database engines

## license

MIT
bellande-rust-executable 0.3.7
Bellande Rust Executable is a library that makes rust code into an executable (BRE) library
Requires Python: >=3.0
Keywords: package, setuptools

# Bellande Rust Executable

## Bellande Rust Executable is a library that makes rust code into an executable (BRE) library
- "-d", "--dep-file", required=True, help="Path to the dependencies file (dependencies.bellande)"
- "-s", "--src-dir", required=True, help="Source directory containing Rust files"
- "-m", "--main-file", required=True, help="Main Rust file name (e.g., main.rs)"
- "-o", "--output", required=True, help="Output path for the compiled executable"

## Website PYPI
- https://pypi.org/project/bellande_rust_executable

### Installation
- `$ pip install bellande_rust_executable`

### Upgrade (if not upgraded)
- `$ pip install --upgrade bellande_rust_executable`

```
Name: bellande_rust_executable
Summary: File type Formats
Company-page: git@git.bellande-technologies.com/BAMRI/bellande_rust_executable
Home-page: github.com/Architecture-Mechanism/bellande_rust_executable
Author: Ronaldson Bellande
Author-email: ronaldsonbellande@gmail.com
License: GNU General Public License v3.0
```

## License
Bellande Rust Executable Packages is distributed under the [GNU General Public License v3.0](https://www.gnu.org/licenses/gpl-3.0.en.html), see [LICENSE](https://github.com/Architecture-Mechanism/bellande_rust_executable/blob/main/LICENSE) and [NOTICE](https://github.com/Architecture-Mechanism/bellande_rust_executable/blob/main/LICENSE) for more information.

## Code of Conduct
Bellande Rust Executable Packages is distributed under the [CODE_OF_CONDUCT](https://github.com/Architecture-Mechanism/bellande_rust_executable/blob/main/CODE_OF_CONDUCT.md) and [NOTICE](https://github.com/Architecture-Mechanism/bellande_rust_executable/blob/main/CODE_OF_CONDUCT.md) for more information.
pyopticon 0.2.1
A laboratory GUI, data acquisition, and automation package.
Requires Python: >=3.7

# pyopticon

PyOpticon is a software tool for lab controls and automation. It was developed by Richard Randall at Stanford University.
It provides a GUI interface with data logging and automation capability for devices connected to a computer's serial ports.
One uses Python to write the 'widgets' that represent each device and to configure multiple instances of widgets into 'dashboards'.
The detailed documentation should be at pyopticon.readthedocs.io .