semvec/pypi-packages huggingface dataset:
ctxs 0.0.1
Extra helpers for python contextmanager
Requires Python: >=3.11

ctxs - extra helpers for python "with ..."
==========================================

The [with](https://docs.python.org/3/reference/compound_stmts.html#with)
statement available in python makes it possible to add context and cleanup to
resources, which is useful when working with shared resources that needs to be
released afterwards.

This adds some extra tools to make usage easier.

ContextObject
-------------

When working with multiple contexts at the same time, it is possible to use
multiple context managers in the same `with` statement:

```py

with ResourceA() as a, ResourceB() as b:
    a.do_something()
    b.do_something()

```

But if something needs to be added to the scope later, or dynamically add
resources to the same context, it is not possible.

`ContextObject()` managed the context, and new resources can be added later,
using the `<<`-operator.

The above statement is equivalent to:

```py
from ctxs import ContextObject

with ContextObject() as ctx:
    a = ctx << ResourceA()
    b = ctx << ResourceB()

    a.do_something()
    b.do_something()
```

with the addition that resources can be added later, and dynamically.


ContextThread
-------------

[threading](https://docs.python.org/3/library/threading.html) adds the
possibilty to create threads easily. However, synchronizing execution is still
based upon function calls to the thread object.

In many cases, some thread should be running only within the scope of a certain
block. For example, a temporary server thread only available when a system is
in a certain state.

`ContextThread` makes it possible to create a thread that is running within a
given context, with or without `ContextObject` above.

To create a `ContextThread`, extend the `ContextThread` and implement the
`run()` function, which is executed when the thread enters the context.

Within the context, the `self.is_running` is `True` while running, and when
exiting the context, it will be set to `False`.

```py
from ctxs import ContextThread
import time

class MyThread(ContextThread):
    def __init__(self) -> None:
        pass

    def run(self) -> None:
        while self.is_running:
            print("Tick...")
            time.sleep(1.0)

# Create and run in parallel
with MyThread():
    for i in range(10):
        time.sleep(0.7)
        print("Tock...")

print("Has it stopped?")
time.sleep(4.0)
print("Who knows...")
```

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

ctxs is available on [pypi](https://pypi.org/project/ctxs/)

To install:

```sh
pip install ctxs
```

Feedback
--------

The goal of this library is to keep as clean as possible, while still complement
the builtin behaviour.

If you have any thoughts about what it should added.


Roadmap / Ideas
---------------

- `ContextObject` initialized by collections, to make it possible to enter
  a set/list/dict of context managers.
- Add `ContextObject` to other objects, to support nested contexts. For example
  a server (implemented as a `ContextThread`) can spawn it's client threads
  within the parents context.
nwkfmt 0.4.1
Simple Newick tree validator and formatter
Requires Python: >=3.11

# Newick Tree Validator and Formatter

Simple utility to validate and format Newick trees.

The main use of this utility is to validate constraint trees used with IQtree2.

IQtree2 can throw hard to understand errors when using constraint trees even if the tree is technically a valid Newick tree.

This utility will catch many of those errors and provide a more detailed error message.

## Installation

You can install the utility using pip:

```bash
pip install nwkfmt
```

## Usage

Validation without formatting:

```bash
./main.py <tree.nwk>
```

In place formatting:

```bash
./main.py <tree.nwk> --inplace
```

Outputting formatted tree to a separate file:

```bash
./main.py <tree.nwk> --outfile <output.nwk>
```

Outputting list of terminal nodes into a text file:

```bash
./main.py <tree.nwk> --terminals <terminals.txt>
```

Formatting even if validation fails:

```bash
./main.py <tree.nwk> --inplace --no-validate
```

## Release

This project uses [Poetry](https://python-poetry.org/) for dependency management and packaging.

To build a release, run:

```bash
poetry build
```

To publish a release to PyPI, run:

```bash
poetry publish
```

To publish the release to Github, run:

```bash
gh release create 0.4.1 dist/*
```
srlp 0.0.1
Software Repos Local Profile
Requires Python: >=3.11

# Software Repos Local Profile

A temporary scripts collection for local software:

* [x] apk
  * [x] alpine
* [x] deb
  * [x] debian
  * [x] docker-ce
  * [x] gitlab-runner
  * [x] incus
* [ ] msys2
  * [ ] distrib
  * [x] mingw64
  * [x] msys
* [ ] py
  * [ ] python
  * [ ] pypi
* [x] rpm
  * [x] alma
  * [x] epel
learnify-ml 0.0.28
A package for auto preprocessing and training machine learning models
Requires Python: >=3.11

# learnify-ml

**learnify-ml** is a lightweight and modular Python package designed to **automate preprocessing pipelines** for machine learning datasets. With minimal configuration, it applies standard best practices to clean, transform, and prepare data for training.

---

## Features

### Data Preprocessing
-  Automatically detects and fills missing values
-  Identifies and handles outliers
-  Applies skewness correction to numeric features
-  Scales numerical data using standard scaling
-  Encodes categorical variables using label encoding
-  Removes low-variance features
-  Performs VIF analysis to reduce multicollinearity
-  Balances imbalanced datasets using SMOTE
-  Supports feature selection methods

### Model Training & Evaluation
-  Trains multiple machine learning models (e.g., Random Forest, XGBoost, Logistic Regression)
-  Automatically selects the best-performing model based on scoring metrics
-  Tracks performance with metrics like accuracy, F1-score
-  Saves trained model and evaluation report as artifacts

### Hyperparameter Optimization
-  Supports both **GridSearchCV** and **RandomizedSearchCV**
-  Configurable search space for each model
-  Automatically selects best hyperparameters and retrains final model
---

## Installation

```bash
pip install learnify-ml
```

If the package is not yet on PyPI, you can install locally:

```
git clone https://github.com/yourusername/learnify-ml.git
cd learnify-ml
pip install -e .
```

## Usage
🔹 1. Import the main pipeline class

```python
from learnify_ml import AutoMLPipeline
```

🔹 2. Run the pipeline

```python
trainer = AutoMLPipeline(target_column="target_column",
                      use_case="regression",
                      apply_hyperparameter_tuning=True,
                      hyperparameter_tuning_method="randomized",
                      apply_tf_idf=False,
                      apply_scale=True,
                      apply_feature_selection=True,
                      apply_outlier=True,
                      apply_vif=True,
                      apply_skewness=True,
                      apply_smote=False,
                      test_size=0.2,
                      impute_strategy="mean",
                      ).run_pipeline()
trainer.run_pipeline()
```

## Example Functions

```python
df = trainer.remove_outliers(df)
df = trainer.handle_missing_values(df)
df = trainer.scale_numeric_features(df)
```

Each method is modular and can be used independently or inside run_pipeline().
flux-arcane-mage 0.1.0
Automation helper for Fluxnodes
Requires Python: >=3.12

## Arcane Mage - Automated Fluxnode ArcaneOS Installation

### Introduction

Arcane Mage is a suite of tools designed to ease the installation (and configuration) burden of installing a Fluxnode.

The following is available via the GUI, or CLI:

* Fully automated A to Z Proxmox installs, including Secure Boot key enrollment.
* Mutlicast config broadcast on LANs - fully automated installs, except Secure Boot Key enrollemnt.
* USB stick creation for plug and play automated installs on bare metal

### Configuration Options

See the `examples` directory for sample configurations.

Any option can be easily set via a yaml configuration file, for example, for Proxmox, start on VM creation, rate limits, etc.

It can also reboot direct into `systemd-boot` for systems that allow easy enrollment of keys (usually bare metal systems)

### Installation

Install `uv` - https://docs.astral.sh/uv/getting-started/installation/

To use the default config file `fluxnodes.yaml` in the directory you are in:

```bash
uvx -m arcane-mage
```

Run the following for help:

```bash
uvx -m arcane-mage --help
```

### Hypervisor Setup - Proxmox Automation

In order to use `Arcane Mage` with Proxmox, the following needs to be set up on your hypervisor:

* A user for the API
* An API token (strongly recommended)
* Nginx reverse proxy (strongly recommended)

To set up your Proxmox Instance behind an Nginx reverse proxy, follow these instructions, it doesn't take much effort:

https://pve.proxmox.com/wiki/Web_Interface_Via_Nginx_Proxy

If you don't reverse proxy the api, you can run into connection issues.

To set up your user, go to "Datacenter" on the Proxmox GUI and add a user:

![Proxmox User Page ](proxmox_user.png)

Next, add an api token for your user:

![Proxmox Api Token ](proxmox_user_api_token.png)

Finally, give **BOTH** your user and api token `PVEAdmin` permissions:

![Proxmox Permissions ](proxmox_permissions.png)

You're now good to run Arcane Mage.