semvec/pypi-packages huggingface dataset:
mlflow-mage 0.1.0
MLFlow mage is a wrapper for MLFlow to allow for better logging capabilites inside Mage AI.
Requires Python: >=3.10

# mlflow-mage

MLFlow mage is a wrapper for MLFlow to allow for better logging capabilites inside Mage AI.

## MlflowSaver

The `MlflowSaver` class simplifies MLflow logging within Mage AI pipelines. It provides a context manager for automatically starting and ending MLflow runs, along with methods for logging parameters, metrics, artifacts, and models.

### Usage Example

```python
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score
from sklearn.datasets import load_iris
from mlflow_mage.mlflow_saver import MlflowSaver
from dotenv import load_dotenv

load_dotenv(".env")

iris = load_iris()
X, y = iris.data, iris.target

with MlflowSaver(run_name="end_to_end_pipeline") as logger:
    params = {
        "dataset": "iris",
        "test_size": 0.2,
        "random_state": 42
    }
    logger.log_params(params)

    with logger.create_child_run("preprocessing") as preproc_logger: # Create child runs inside the parent run, which can be usefull as in this example, and also for epoch based training.
        X_train, X_test, y_train, y_test = train_test_split(
            X, y,
            test_size=params["test_size"],
            random_state=params["random_state"]
        )

        preproc_logger.log_metrics({
            "train_samples": len(X_train),
            "test_samples": len(X_test)
        }, step=0) # Log the metrics once

        preproc_logger.log_metrics({
            "train_samples": len(X_train),
            "test_samples": len(X_test)
        }, step=1) # Log them again with the same name, but at another step

    with logger.create_child_run("model_training") as train_logger:
        # Model training
        model = RandomForestClassifier(
            n_estimators=100,
            random_state=params["random_state"]
        )
        model.fit(X_train, y_train)

        # Log hyperparameters
        train_logger.log_params(model.get_params())

        # Log training performance
        y_pred = model.predict(X_test)
        train_logger.log_metrics({
            "accuracy": accuracy_score(y_test, y_pred),
            "precision": precision_score(y_test, y_pred, average='weighted'),
            "recall": recall_score(y_test, y_pred, average='weighted'),
pymox-tools1 1.0.6
Un module avec plein d'outils utiles pour devs en PyMoX (PY-thon - MO-jo - Flet-X)
Requires Python: >=3.10

# PyMoX - GC7

Trousse à outils utiles pour devs en PyMoX

v1.06 2ème

---

## Rapide mémo

```bash
py -m venv .venv
.\.venv\Scripts\activate
pip install -r requirements.txt

py -m build
twine check dist/*
twine upload dist/* --verbose

git log --oneline

semantic-release version
semantic-release version --print

semantic-release publish

semantic-release --noop version
Cela te dira si une version serait générée.

semantic-release version --commit --tag --no-push

Cela va :
Lire les commits
Calculer la prochaine version (ex: 0.2.0)
Modifier __version__ dans gc7/__init__.py
Créer un commit et un tag localement

Remove-Item -Recurse -Force dist, src/gc7/gc7.egg-info

git commit --allow-empty -m "feat: add dummy feature for version bump"
git commit --allow-empty -m "fix: déclenchement de la release 1.0.1" 
git push origin main

voir conventional commits: https://www.conventionalcommits.org/en/v1.0.0/

En cas de volonté de revenir sur une version précédente (Problème avec PyPI: Interdit de reculer):
git revert <hash du commit> (pour ramener la main du dépôt GH)
dans le __ini__.py, mettre : __version__='x.y.z' (> au dernier de PyPI)
refaire le build + renvoi:
py -m build    
twine upload dist/*

Désinstaller tous les packages de l'env global :
pip freeze | ForEach-Object { pip uninstall -y $_ }

# 1. Crée une branche temporaire pour garder les fichiers
git checkout --orphan temp_branch

# 2. Ajoute tous les fichiers à cette nouvelle branche
git add .

# 3. Fais un commit initial
git commit -m "Initial commit"

# 4. Supprime l'ancienne branche main
git branch -D main

# 5. Renomme la branche temporaire en main
git branch -m main

# 6. Force le push vers GitHub (⚠️ cela écrase l’historique distant)
git push -f origin main

git log main --decorate --oneline

---

from pymox_tools1 import greetings as gt
from pymox_tools1 import tokens as tk

if __name__ == "__main__":
    tk.tokens()
    print(gt.hello(), "\n" + gt.bye())

```
strats-oanda 0.1.6
strats-oanda
Requires Python: >=3.9

# strats-oanda

<p>
<a href="https://github.com/kazukiyoshida/strats-oanda/actions?query=event%3Apush+branch%3Amain" target="_blank">
  <img src="https://github.com/kazukiyoshida/strats-oanda/actions/workflows/test.yaml/badge.svg" alt="Test">
</a>
<a href="https://pypi.org/project/strats-oanda" target="_blank">
  <img src="https://img.shields.io/pypi/v/strats-oanda?label=pypi%20package&color=%2334D058" alt="PyPI - Version">
</a>
</p>
idiap-devtools 2.1.0
A *pot-pourri* of various tools required to develop python packages at Idiap's GitLab infrastructure
Requires Python: >=3.11

<!--
Copyright © 2022 Idiap Research Institute <contact@idiap.ch>

SPDX-License-Identifier: BSD-3-Clause
-->

[![latest-docs](https://img.shields.io/badge/docs-v2.1.0-orange.svg)](https://idiap-devtools.readthedocs.io/en/v2.1.0/)
[![build](https://gitlab.idiap.ch/software/idiap-devtools/badges/v2.1.0/pipeline.svg)](https://gitlab.idiap.ch/software/idiap-devtools/commits/v2.1.0)
[![coverage](https://gitlab.idiap.ch/software/idiap-devtools/badges/v2.1.0/coverage.svg)](https://www.idiap.ch/software/biosignal/docs/software/idiap-devtools/v2.1.0/coverage/index.html)
[![repository](https://img.shields.io/badge/gitlab-project-0000c0.svg)](https://gitlab.idiap.ch/software/idiap-devtools)

# Development Tools

This package contains a set of small utilities to support development of Python
packages through GitLab.  It is targetted for package development at Idiap.

For installation and usage instructions, check-out our documentation.
nomad-camels-driver-andor-newton 0.1.5
This package provides everything to run an Andor Newton CCD.
Requires Python: >=3.9.6

# NOMAD-CAMELS Driver for Andor Newton CCD

This package provides a driver of the Andor Newton CCD for the measurement software [NOMAD CAMELS](https://fau-lap.github.io/NOMAD-CAMELS/).\
It uses [pylablib](https://pylablib.readthedocs.io/en/latest/devices/Andor.html#cameras-andor-sdk2) for communication.


## Features
Apart from reading out the camera, the driver allows to set the desired camera temperature, shutter mode, exposure time, and several camera-specific settings.


## Documentation

For more information and documentation visit the [CAMELS documentation](https://fau-lap.github.io/NOMAD-CAMELS/doc/instruments/instruments.html).



## Changelog
### 0.1.5
Improved metadata

### 0.1.4
Now exposure times above 99 seconds are possible.

### 0.1.3
Fix of reading which did end in an endless loop before

### 0.1.2
Fixed camera selection to actually always use the selected camera.
pyplugs 0.5.4
PyPlugs, decorator based plug-in architecture for Python
Requires Python: >=3.10
Keywords: plugin, decorator

# PyPlugs

_Decorator based plug-in architecture for Python_

[![Latest version](https://img.shields.io/pypi/v/pyplugs.svg)](https://pypi.org/project/pyplugs/)
[![Python versions](https://img.shields.io/pypi/pyversions/pyplugs.svg)](https://pypi.org/project/pyplugs/)
[![License](https://img.shields.io/pypi/l/pyplugs.svg)](https://github.com/gahjelle/pyplugs/blob/main/LICENSE)
[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
[![Linted](https://github.com/gahjelle/pyplugs/actions/workflows/lint.yml/badge.svg?branch=main)](https://github.com/gahjelle/pyplugs/actions/workflows/lint.yml)
[![Tested with Pytest](https://github.com/gahjelle/pyplugs/actions/workflows/test.yml/badge.svg?branch=main)](https://github.com/gahjelle/pyplugs/actions/workflows/test.yml)
[![Type checked with mypy](https://img.shields.io/badge/type%20checked-mypy-green)](http://mypy-lang.org/)
[![Interrogate DocStrings](https://raw.githubusercontent.com/gahjelle/pyplugs/main/docs/images/interrogate_badge.svg)](https://interrogate.readthedocs.io/)


## Installing PyPlugs

PyPlugs is available at [PyPI](https://pypi.org/project/pyplugs/). You can install it using Pip:

    $ python -m pip install pyplugs


## Using PyPlugs

...


## Installing From Source

You can always download the [latest version of PyPlugs from GitHub](https://github.com/gahjelle/pyplugs).
taskman-sv 0.8.0
A secure task management and note-taking application
Requires Python: >=3.8
Keywords: task, management, notes, productivity

# 🌟 TASKMAN-SV: A Complete CLI Task Manager  

## 🍅 Pomodoro Focus:  
- Standard (25/5), Long (45/15), or Custom intervals  
- Automatic break reminders  
- Session tracking  

## 🎯 Task Management:  
- Custom tasks & Pomodoro sessions  

## 🧠 Focus Modes:  
- Normal & HyperFocus modes  

## 📝 Notes System:  
- Modular notes & Quick notes  

## 🔐 Multi-user:  
- Secure login for each user  

## 💻 100% Command-Line Interface:  
- No GUI needed, pure terminal experience  

### 🚀 Start using TASKMAN-SV:  
Run the following command in your terminal for installation:  
```bash
pip install taskman-sv
```
pyRFtk 2.0.8
Design tool for RF antennae networks
Requires Python: >=3.8

# pyRFtk
[![DOI](https://zenodo.org/badge/702980029.svg)](https://zenodo.org/doi/10.5281/zenodo.10391750)
![logo](https://github.com/LPP-ERM-KMS/pyRFtk/blob/master/logo/logo.svg)
## About

pyRFtk is a Python library able to build and analyse RF circuits, originally designed for ICRH antennae but now widely deployable.
you can:
- Incorporate touchstone files to create your own elements
- See the currents throughout your circuit
- Compute S-matrices
- Detect Arcs
- Deembed systems
- ...
  
## Installation
pyRFtk is available as a pip package:

```sh
pip install pyRFtk
```

Or using your favorite distribution platform

## Authors
The code was developed by RF-engineer Frederic Durodie and later
on refactored, packaged and documented by Arthur Adriaens

## Example usage
This code was extensively used for the paper [An automatic matching system for the ICRF antenna at TOMAS: Development and experimental proof](https://doi.org/10.1016/j.fusengdes.2025.114840), the code for which may be found in the examples folder.
json-handler-caramajau 0.1.2
Code to make it easier to read and write to a JSON file
Requires Python: >=3.12

## JSON Handler

### Overview
Code to make it easier to read and write to a JSON file. It provides an abstraction layer, since you don't need to specify the details of how the JSON is read or written (such as file encoding, etc.). This eliminates the ability to customize how the JSON is read or written. However, most instances will probably not require such customization, so this works for most cases.

**NOTE**: The code uses utf-8 encoding only, since it is a very common encoding.

### Usage
To use the JSON handler, create an instance of the `JSONHandler` class and specify the file path in the constructor. You can then read and write to the file using the `read_json` and `write_json` methods.

The class utilizes generics, allowing you to specify the type of data you want to read or write. Make sure the data type is serializable to JSON, since the file will not be created if it is not.

**Note**: Type hints in Python are not enforced at runtime. You are responsible for ensuring that the data you pass matches the expected type and is serializable.

#### Example code
```python
from collections.abc import Mapping

from json_handler_caramajau.json_handler import JSONHandler

handler: JSONHandler[str] = JSONHandler("path/to/your/file")

data: Mapping[str, str] = {"key": "value"}
handler.write_json(data)

read_data: Mapping[str, str] = handler.read_json()
print(read_data)  # Output: {'key': 'value'}
```

### Requirements
- Python 3.12 or higher

### Installation
You can install the package using pip:
```bash
pip install json-handler-caramajau
```
### License
This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.

### Contributing
If you want to contribute to this project, feel free to open an issue or a pull request. Contributions are welcome, but since the project is so simple, I expect that there probably won't be many.

### Author
This project is maintained by Caramajau. If you have any questions or suggestions, feel free to reach out.
findpkg 0.1.2
CLI tool to locate in which virtual environment a Python package is installed.
Requires Python: >=3.6

# 🔍 findpkg

**findpkg** is a simple Python CLI tool that helps you locate which virtual environments a specific Python package is installed in.

---

## 🚀 Features

- Quickly search across local virtual environments
- Works with standard Python & virtualenv/venv environments
- Lightweight and fast

---

## 📦 Installation

### Option 1: Install via `pip`

```bash
pip install findpkg
```

### Option 2: Install from source (for development)
```bash
git clone https://github.com/<your-username>/findpkg.git
cd findpkg
pip install .
```

## 🛠 Usage
```bash
python -m findpkg <package_name>
```

### Example
- Input
```bash
python -m findpkg pandas
```

- Output
```bash
Searching for package 'pandas'...

Package 'pandas' found in the following location(s):

→ C:\Users\User\Desktop\Projects\myenv1\Lib
→ C:\Users\User\Desktop\Projects\myenv2\Lib
```

## Coming Soon
 - Unit test
 - Mac/Linux support (cross-platform paths)



## 🤝 Contributing
PRs are welcome! Please feel free to fork this repo and contribute.

## License

This project is licensed under the MIT License - see the [LICENSE](./LICENSE) file for details.
PythonLibTest201 0.0.1
This is the simplest module for quick work with files.
Requires Python: >=3.6
Keywords: files speedfiles

# Speed File Library #

## What is this? ##
The module allows you to work with files in just one line of code, without the need to manually open and close the file each time

## Quick Guide ##
The module is based on the following structure:

    
    f = open('data.txt')
    data = f.readlines()
    f.close()
    
Which Python provides by standard.


----------


### Using ###


Using the library is as simple and convenient as possible:

Let's import it first:
First, import everything from the library (use the `from `...` import *` construct).

Examples of all operations:

Writing the contents of an entire file to a variable using the `read()` function:

    temp = File(path='test.txt').read()


Writing the contents of an entire file to a variable line by line using the `readlines()` function:

    temp = File(path='test.txt').readlines()


Write only the first line from a file using the `readline()` function:

    temp = File(path='test.txt').readline()


Writing data from a variable to a file using write() (overwriting or creating a file):

    temp = "Test data"
    File(path='test.txt', data=temp).write()
    

Adding data from a variable to a file using write() (or creating a file):

    temp = "Test data"
    File(path='test.txt', data=temp).add()


----------


## Developer ##
My site: [link](https://y-a-r-i-k.github.io/)