semvec/pypi-packages huggingface dataset:
ExifSort 0.2.5
ExifSort - sort media files into date-based folders by reading EXIF creation date.
Requires Python: >=3.13
Keywords: exif, auto-organization, auto-sort, photo-management, photo-organization

# ExifSort

**ExifSort** - sort media files into date-based folders by reading EXIF creation date.

## Key Features

✅ **Robust Metadata Support**: Powered by [ExifTool](https://exiftool.org/), ensuring reliable reading of EXIF/XMP creation dates from a wide variety of formats (JPG, DNG, MOV, MP4, ORF, RAW, and more).  
✅ **Flexible Organization**: Automatically moves files into date-based directory structures (e.g., `2023/20231224`) and renames them with timestamp prefixes (e.g., `20231224-180000-Image.jpg`).  
✅ **"Party Mode" (Day Shift)**: Define when a new day starts (default: 04:00 AM). Photos taken after midnight (e.g., at a party) will be sorted into the previous day's folder, keeping events together.  
✅ **Extension Normalization**: Automatically unifies file extensions to lowercase standard formats (e.g., converts `.JPEG` to `.jpg`, `.TIFF` to `.tif`).  
✅ **Time Correction**: Apply a time offset (in seconds) to fix timestamps if your camera's clock was set incorrectly.  
✅ **Safe & Secure**:  
→ **Dry-run mode (`--test`)**: Preview changes without modifying any files.  
→  **Conflict protection**: Skips files if the target destination already exists (unless overwrite is forced).  
→  **Fallback handling**: Files without metadata are safely moved to a dedicated `_UNKNOWN` folder.  
✅ **CLI Friendly**: Includes a progress bar, colorful output, and verbose mode for detailed processing logs.  

## Installation

```bash
pip install exifsort
```

## Requirements

- Python 3.13+
- [ExifTool](https://exiftool.org/) command-line tool
- [PyExifTool](https://pypi.org/project/PyExifTool/) Python library

## License

MIT License - see [LICENSE](https://github.com/barabasz/exifsort/blob/main/LICENSE) for details.

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

## Links

- **GitHub**: https://github.com/barabasz/exifsort
- **Issues**: https://github.com/barabasz/exifsort/issues
botsislabutils 1.1.0
Commonly used utilities for Botsis Lab
Requires Python: >=3.6

The Botsis Lab Utilities package provides a set of commonly used tools within projects developed at the Botsis Lab at Johns Hopkins University.

## Installation

The package can be installed using pip:

pip install botsislabutils

## Available Modules

### MySQL Interface

The `mysql_interface` module provides a set of functions for commonly used MySQL operations.

Dependencies:

- A set of environment variables for MySQL connection:
  - `DATABASE_USER`: MySQL username
  - `DATABASE_PASS`: MySQL password
  - `DATABASE_HOST`: MySQL host (default: localhost)
  - `DATABASE_PORT`: MySQL port (default: 3306)
  - `DATABASE_SCHEMA_NAME`: MySQL database name

### Configuration

The `config_manager` module provides functions for reading and writing configuration to and from a MySQL database.

Dependencies:

- MySQL database connection (using the `mysql_interface` module).
- Table `configuration` in the database, which contains two columns: `key` and `value`.

### Authorization

The `authorization_manager` module contains functions for interacting with users.

Dependencies:

- MySQL database connection (using the `mysql_interface` module).
- Table `user_role` in the database, which maps usernames to roles.

### Authentication

The `authentication_manager` module provides functions for user authentication.

Dependencies:

- MySQL database connection (using the `mysql_interface` module).
- `config_manager` module for retrieving SSO configuration.
- Table `user` in the database, which contains a username column.
- Authorization module (to retrieve user roles).

### Logging

The `logger` module provides a simple logging interface which prepends log messages with a timestamp.

### Service Utility

The `service_utility` module provides functionality used by Flask services.

Dependencies:

- `authentication_manager` module for user authentication.
- `authorization_manager` module for user authorization.
foyndation 16
Base library of foyono projects

# foyndation
Base library of foyono projects.

This README is auto-generated, see [project wiki](https://wikiwheel.net/s/foyono/w/foyndation) for details.

## API

<a id="foyndation"></a>

### foyndation

<a id="foyndation.initlogging"></a>

###### initlogging

```python
def initlogging()
```

Initialise the logging module to send debug (and higher levels) to stderr.

<a id="foyndation.innerclass"></a>

###### innerclass

```python
def innerclass(cls)
```

An instance of the decorated class may access its enclosing instance via `self`.

<a id="foyndation.invokeall"></a>

###### invokeall

```python
def invokeall(callables)
```

Invoke every callable, even if one or more of them fail. This is mostly useful for synchronising with futures.
If all succeeded return their return values as a list, otherwise raise all exceptions thrown as a chain.

<a id="foyndation.onerror"></a>

###### onerror

```python
@contextmanager
def onerror(f)
```

Context manager that runs the given function if an exception happens, like `finally` excluding the happy path.
Return a true value from `f` to declare the exception was handled i.e. prevent it from being re-raised.

<a id="foyndation.rmsuffix"></a>

###### rmsuffix

```python
def rmsuffix(text, suffix)
```

Return text with suffix removed, or `None` if text does not end with suffix.

<a id="foyndation.singleton"></a>

###### singleton

```python
def singleton(t)
```

The decorated class is replaced with a no-arg instance.
Can also be used to replace a factory function with its result.

<a id="foyndation.solo"></a>

###### solo

```python
def solo(v)
```

Assert exactly one object in the given sequence and return it.

<a id="parabject"></a>

### parabject

<a id="parabject.register"></a>

###### register

```python
def register(obj, paracls)
```

Instantiate paracls, set `obj` to be the regular object associated with the new parabject, and return the parabject.

<a id="parabject.dereference"></a>

###### dereference

```python
def dereference(parabject)
```

Get the regular object associated with `parabject` or raise UnknownParabjectException.

<a id="parabject.Parabject"></a>

#### Parabject Objects

```python
class Parabject()
```

Subclasses typically implement `__getattr__` for dynamic behaviour on attribute access, use `unmangle` there to undo name mangling.

<a id="parabject.Parabject.__neg__"></a>

###### \_\_neg\_\_

```python
def __neg__()
```

Dereference this parabject.

<a id="parabject.unmangle"></a>

###### unmangle

```python
def unmangle(name)
```

Undo name mangling.
supplychainlib 0.1.6
A private Python library for AWS service integrations in the Supply Chain project
Requires Python: >=3.8

# SupplyChainLib

SupplyChainLib is a specialized Python library designed to provide reusable AWS service integrations—such as DynamoDB, S3, SNS, and Lambda—for the Supply Chain Django web application. The library encapsulates AWS SDK interactions using OOP and best practices to facilitate robust and scalable cloud-native development.

## Features

- DynamoDB resource and client operations wrapper
- S3 file upload, download, and bucket management
- SNS topic publish and subscription management
- AWS Lambda invocation utilities
- Designed for modular and maintainable integration in Django projects

## Installation

Install from local editable source during development:
pip install -e ./supplychainlib/src/

## Usage

Import classes like:
from supplychainlib.aws_dynamodb import DynamoDBManager
from supplychainlib.aws_s3 import S3Manager

Refer to project documentation for details.

## License

MIT License
experl-core 0.1.0.dev6
Train large language models using reinforcement learning with human feedback.
Requires Python: >=3.12
Keywords: transformers, huggingface, language modeling, post-training, rlhf, sft, dpo, ppo

# 🧠 Experl — RLHF Framework for Post-Training Large Language Models

---

## 📜 Overview

Experl is a framework designed for post-training large language and foundation models using Reinforcement Learning from Human Feedback (RLHF) techniques such as Proximal Policy Optimization (PPO) and Direct Preference Optimization (DPO).

Built on top of Hugging Face TRL and Transformers, Experl provides a flexible and extensible platform for training, evaluation, and experimentation in RLHF-based fine-tuning workflows.
It integrates seamlessly with:

- 🤗 TRL – provides trainer abstractions for RL pipelines
- 🤗 Transformers – for model and tokenizer management
- ⚙️ Hydra – for structured and hierarchical configuration management
- 📊 MLflow – used for training experiment tracking, metrics logging, datasets and model versioning


Experl simplifies the complex process of RLHF post-training, allowing researchers and engineers to focus on experimentation, comparison, and innovation — rather than boilerplate code.

---
## 🚀 Getting Started

## Installation

### Python Package

Install the library using `pip`:

```bash
pip install experl-core[cuda]
```

### From source

If you want to use the latest features before an official release, you can install Experl from source:

```bash
pip install git+https://github.com/vjkhambe/experl-core.git
```

### Repository

If you want to use the examples you can clone the repository with the following command:

```bash
git clone https://github.com/vjkhambe/experl-core.git
```
---

## Command Line Interface (CLI)

You can use the Experl Command Line Interface (CLI) to quickly get started with post-training methods like Proximal Policy Optimization (PPO) or Direct Preference Optimization (DPO):

**PPO:**

```bash
experl ppo \
++model_name_or_path=google/gemma-3-270m-it \
++max_seq_length=128 \
++reward_model_name_or_path=google/gemma-3-270m-it
```

**DPO:**

```bash
experl dpo \
++model_name_or_path=google/gemma-3-270m-it \
++max_seq_length=128 \
++judge.model_name_or_path=google/gemma-3-270m-it 
```

## 🧾 Experiment Tracking with MLflow

Experl integrates seamlessly with [MLflow](https://mlflow.org/) for experiment tracking, metrics visualization, and model versioning.

During training, all runs are automatically logged to MLflow under `experl_output/mlflow_runs`.

To start the MLflow UI locally and explore your PPO/DPO results:

```bash
mlflow ui --backend-store-uri experl_output/mlflow_runs
```

## Citation

```bibtex
@misc{vjkhambe2025experl,
  author = {Vijay Khambe},
  title = {Experl: Reinforcement Learning from Human Feedback Framework},
  year = {2025},
  publisher = {GitHub},
  journal = {GitHub repository},
  howpublished = {\url{https://github.com/vjkhambe/experl-core}},
}
```

## License

This repository's source code is available under the [Apache-2.0 License](LICENSE).
graphevol 0.0.2
Evolutionary graph-based optimization library with Python bindings
Requires Python: >=3.9

# A scalable topology-evolution engine powered by a high-performance Rust backend.

<!-- [![Continuous integration](https://github.com/otyanokosaisai/graphevol/actions/workflows/build-release.yaml/badge.svg)](https://github.com/otyanokosaisai/graphevol/actions/workflows/build-release.yaml) -->
[![PyPI version](https://img.shields.io/pypi/v/graphevol)](https://pypi.org/project/graphevol/)
[![Python Versions](https://img.shields.io/pypi/pyversions/graphevol.svg)](https://pypi.org/project/graphevol/)
![License](https://img.shields.io/pypi/l/graphevol)
![PyPI - Wheel](https://img.shields.io/pypi/wheel/graphevol)
![Downloads](https://img.shields.io/pypi/dm/graphevol)

[**Features**](#features)

## What is graphevol?
<!-- `graphevol` provides fast graph-based neuroevolution in Python, with structural mutations, pruning, configurable operations, and a JAX/PyTorch/NumPy-friendly workflow. -->
graphevol is a Python library for graph-based neuroevolution with **Hierarchical Genetic Algorithm** and **memory-efficient evolutions**, designed for fast and scalable evolutinary search.

The main class **PyGenus** plays roles in reproduction and selection in Generative Algorithm. **PyGenus** manages network structures and weights, and it runs repruduction, returning *functions' strs* and *weights*. It can adapt the strs major Python numerical libraries: [Numpy](https://github.com/numpy/numpy.git), [JAX](https://github.com/jax-ml/jax.git) and [PyTorch](https://github.com/pytorch/pytorch.git). In selection, **PyGenus** recieves scores and updated weights of each set, and apply selective pressure stochastically based on each performance. 

This project is currently ongoing, therefore the design can be dramatically changed by a major update. 

---

## Installation

```bash
pip install graphevol
```

Install Graphviz for visualization:

**Linux**
```bash
sudo apt install graphviz
```
**macOS**
```bash
brew install graphviz
```

---

## Quick Start

```python
import graphevol as ge

# Generate default YAML configs (please modify them to change GA behavior and operators)
ge.generate_default_settings("ga.yaml", "ops.yaml")

genus = ge.PyGenus(
    seed=0,
    ouput_dir="outputs",
    # environmental settings
    input_dim=4,
    output_dim=2,
    # network settings
    use_bias=True, # Use bias node
    sustain_cache=True, # Whether PyGenus uses a cache to track functions already used across generations.
    # configs
    ga_config_path="ga.yaml",
    ops_path="ops.yaml",
)

genomes: list[list[str, list[float]]] = genus.next_generation() # function's expression (str) and weights (list[float])
scores: list[list[float, list[float]]] = rollout_fn(genomes) # each score (float) and updated weights(list[float])
genus.selection(scores)
```

<!-- ---

## Configuration

`graphevol` uses two YAML files:

### ga_config.yaml

### ops.yaml -->

<!-- ---

## Documentation

Full documentation & examples:  
https://github.com/otyanokosaisai/graphevol -->


<!-- ---

## Contributions

Issues & PRs are welcome. -->
pypixz 2.0.0
A solution for managing your Python dependencies
Requires Python: >=3.8
Keywords: python, package, installer, pypi, pip, manage, dependencies

> [!IMPORTANT]
> The PyPixz repository has been moved here. You can still access the [old repository](https://github.com/YourLabXYZ/PyPIxz).

# PyPIxz
A solution for managing your Python dependencies.

```python
import pypixz

# Install a package
pypixz.install_package("pypixz", version_range=">=2.0.0")

# Install dependencies listed in a requirements.txt file
pypixz.install_requirements("requirements.txt")
```

> [!TIP]
> If you want to use PyPixz to install packages that weren't installed at the beginning of your program, we recommend cloning this repository and adding it to your program.


**PyPIxz** allows you to easily and simply manage the dependencies required by your Python program while ensuring a high level of security.
It is designed to be compatible with other internal modules, such as **log management**, and ensures **compatibility** with any **Python environment from version 3.8** onwards.
**PyPIxz requires no dependencies** to be installed; it is self-contained and relies solely on the **Python standard library**.

[![Contributors](https://img.shields.io/github/contributors/zkeepr/pypixz.svg)](https://github.com/zkeepr/pypixz/graphs/contributors)
[![Issues](https://img.shields.io/github/issues/zkeepr/pypixz.svg)](https://github.com/zkeepr/pypixz/issues)
[![Pull Requests](https://img.shields.io/github/issues-pr/zkeepr/pypixz.svg)](https://github.com/zkeepr/pypixz/pulls)
[![Forks](https://img.shields.io/github/forks/zkeepr/pypixz.svg)](https://github.com/zkeepr/pypixz/network/members)

---

## Installing PyPIxz and supported versions

PyPIxz is available on PyPI :

```console
python -m pip install pypixz
```

Install with GitHub :

```console
git clone https://github.com/zkeepr/pypixz.git

# Import PyPixz into your project
cp location/of/the/pypixz/path/pypixz/src/pypixz path/where/you/want/to/place/pypixz/
rm -rf location/of/the/pypixz/path/pypixz
```

PyPIxz officially supports **Python 3.8+** :

> [!CAUTION]
> You can use PyPIxz with a version of Python lower than 3.8, but we do not
> guarantee the compatibility of the program or its updates or security.

---

## Supported Features & Best–Practices

PyPIxz is ready to meet the requirements of managing your dependencies in a
robust and reliable way, for today's needs.

- **Fast Installation**: Manage your dependencies from a `requirements.txt` file.
- **Modularity**: Compatible with other tools and libraries, such as `logging`.
- **Broad Compatibility**: Supports modern Python versions (3.8+).

## License

This project is licensed under the
[MIT License](https://github.com/zkeepr/pypixz/blob/master/LICENSE). See
the license file for more details.

---