semvec/pypi-packages huggingface dataset:
Osdental 3.12
End-to-end algorithm library
Requires Python: >=3.10

# osdental-library

`osdental-library` is a versatile and easy-to-use library for handling common tasks related to **encryption**, **hashing**, and **JWT token management**. Ideal for projects that require a secure and efficient approach to handling sensitive data.

## Features

- Generation and validation of **hashes** using modern algorithms.
- Encryption and decryption of data using secure keys.
- Creation and verification of **JWT tokens** for authentication and authorization.
- Implementations that are easy to integrate into any Python project.

## Installation

You can easily install `osdental-library` using `pip`:

```bash
pip install osdental-library
chroma-gui 0.0.26
QT Graphical User Interface wrapper of the ``omc3`` package
Requires Python: >=3.10

# Non-Linear Chromaticity GUI

The Chromaticity GUI is a tool to compute non-linear chromaticity via measurements done in the CCC.


## Running via acc-py environment

* [Create a virtual environment via `acc-py`](https://pylhc.github.io/packages/development/howto_venv.html) if you do not have one already.
* Install the package via `pip install chroma-gui[cern]` or `pip install chroma-gui[all]`
* Run the GUI via `python -m chroma_gui`

## Running via acc-py apps

Be sure to have the `/acc` directory mounted, which can be done via:

```bash
sshfs cs-ccr-dev2:/acc/ /acc'
```

Running the GUI is then very simple thanks to acc-py.

```bash
source /acc/local/share/python/acc-py/base/pro/setup.sh
acc-py app run chroma-gui
```

### Deployment via acc-py

* Change the version in [__init__.py](./chroma_gui/__init__.py)
* Update the [CHANGELOG](./CHANGELOG.md)
* Commit changes to gitlab repository (wait for CI to finish)

```bash
alias acc-py="/acc/local/share/python/acc-py/apps/acc-py-cli/pro/bin/acc-py"
acc-py app lock .
acc-py app deploy .
acc-py app promote chroma-gui <version>
```
mltb2 1.0.3
Machine Learning Toolbox 2
Requires Python: <4.0,>=3.9
Keywords: optuna, deep learning, ml, ai, machine learning, hyperparameter optimization, hyperparameter tuning, nlp, natural language processing, transformers, llm, large-language-models, openai, plot

# Machine Learning Toolbox 2 - MLTB2

[![MIT License](https://img.shields.io/github/license/telekom/mltb2)](https://github.com/telekom/mltb2/blob/main/LICENSE)
[![Python Version](https://img.shields.io/pypi/pyversions/mltb2)](https://www.python.org)
[![pypi](https://img.shields.io/pypi/v/mltb2.svg)](https://pypi.python.org/pypi/mltb2)
[![Poetry](https://img.shields.io/endpoint?url=https://python-poetry.org/badge/v0.json)](https://github.com/telekom/mltb2/blob/main/pyproject.toml)
<br/>
[![pytest](https://github.com/telekom/mltb2/actions/workflows/pytest.yml/badge.svg)](https://github.com/telekom/mltb2/actions/workflows/pytest.yml)
[![Static Code Checks](https://github.com/telekom/mltb2/actions/workflows/static_checks.yml/badge.svg)](https://github.com/telekom/mltb2/actions/workflows/static_checks.yml)
[![Build & Deploy Doc](https://github.com/telekom/mltb2/actions/workflows/build_deploy_doc.yml/badge.svg)](https://github.com/telekom/mltb2/actions/workflows/build_deploy_doc.yml)
[![GitHub issues](https://img.shields.io/github/issues-raw/telekom/mltb2)](https://github.com/telekom/mltb2/issues)

📦 A box full of machine learning tools. 📦

- [Documentation Page](https://telekom.github.io/mltb2/)
- [How to contribute](https://github.com/telekom/mltb2/blob/main/CONTRIBUTING.md)

## Installation

MLTB2 is available at [the Python Package Index (PyPI)](https://pypi.org/project/mltb2/).
It can be installed with pip:

```bash
pip install mltb2
```

For many modules optional dependencies are necessary.
Those optional dependencies must be installed when you want to use the module.
To install those module specific dependencies see
[the description of the individual modules](https://telekom.github.io/mltb2/api-reference.html).

## Licensing

Copyright (c) 2023-2024 [Philip May](https://philipmay.org)\
Copyright (c) 2023-2024 [Philip May](https://philipmay.org), [Deutsche Telekom AG](https://www.telekom.de/)\
Copyright (c) 2023-2024 Alaeddine Abdessalem, [Deutsche Telekom AG](https://www.telekom.de/)\
Copyright (c) 2025 Sijun John Tu, [Deutsche Telekom AG](https://www.telekom.de/)

Licensed under the **MIT License** (the "License"); you may not use this file except in compliance with the License.
You may obtain a copy of the License by reviewing the file
[LICENSE](https://github.com/telekom/mltb2/blob/main/LICENSE) in the repository.
json2capella 0.3.1
Importing JSON into Capella Data package
Requires Python: <3.14,>=3.10

<!--
 ~ Copyright DB InfraGO AG and contributors
 ~ SPDX-License-Identifier: Apache-2.0
 -->

# JSON2Capella

![image](https://github.com/DSD-DBS/json2capella/actions/workflows/build-test-publish.yml/badge.svg)
![image](https://github.com/DSD-DBS/json2capella/actions/workflows/lint.yml/badge.svg)

Command-line tool for importing package definitions from JSON files into a Capella model's data package.

![Showcase](https://i.imgur.com/Qwzm0In.gif)

# Documentation

Read the [full documentation on Github pages](https://dsd-dbs.github.io/json2capella).

# Examples

Apply package definition from .json file to Capella model layer's root data package:

```sh
python -m json2capella \
-i tests/data/example_jsons/package1.json \
-m tests/data/empty_project_60 \
-l la \
```

Import package definitions from folder with .json files to Capella model layer's root data package:

```sh
python -m json2capella \
-i tests/data/example_jsons \
-m tests/data/empty_project_60 \
-l la
```

# Installation

You can install the latest released version directly from PyPI.

```sh
pip install json2capella
```

To set up a development environment, clone the project and install it into a
virtual environment.

```sh
git clone https://github.com/DSD-DBS/json2capella
cd json2capella
python -m venv .venv

source .venv/bin/activate.sh  # for Linux / Mac
.venv\Scripts\activate  # for Windows

pip install -U pip pre-commit
pip install -e '.[docs,test]'
pre-commit install
```

# Contributing

We'd love to see your bug reports and improvement suggestions! Please take a
look at our [guidelines for contributors](CONTRIBUTING.md) for details.

# Licenses

This project is compliant with the
[REUSE Specification Version 3.0](https://git.fsfe.org/reuse/docs/src/commit/d173a27231a36e1a2a3af07421f5e557ae0fec46/spec.md).

Copyright DB InfraGO AG, licensed under Apache 2.0 (see full text in
[LICENSES/Apache-2.0.txt](LICENSES/Apache-2.0.txt))

Dot-files are licensed under CC0-1.0 (see full text in
[LICENSES/CC0-1.0.txt](LICENSES/CC0-1.0.txt))
minimal-pba-cli 0.0.5
A minimal command-line interface using plugin-based architecture
Requires Python: >=3.9

# Minimal command-line interface using a plugin-based architecture

This project demonstrates a minimal (but featureful) command-line interface (CLI) using a plugin-based architecture (PBA).
The CLI itself is constructed using [Typer](https://typer.tiangolo.com).

The PBA is achieved using a combination of:

- [pipx](https://pypa.github.io/pipx/)
- [importlib](https://docs.python.org/3/library/importlib.html)
- [packaging](https://packaging.pypa.io/)
- [Libraries.io](https://libraries.io/)

For a working plugin example, see [minimal-pba-cli-plugin-example](https://github.com/easy-as-python/minimal-pba-cli-plugin-example).

## Installation

Install the core CLI using the following command:

```shell
$ pipx install minimal-pba-cli
```

## Usage

List available commands using the help:

```shell
$ pba-cli --help
```

### Plugins

List available plugins using the following command (requires a Libraries.io API key):

```shell
LIBRARIES_IO_API_KEY=<your API key> pba-cli plugin catalog
```

Install a plugin using the following command:

```shell
$ pba-cli plugin install <plugin name>
```

List installed plugins using the following command:

```shell
$ pba-cli plugin list
```

Install a plugin from a local directory using the following command:

```shell
$ pba-cli plugin install-local <path to plugin directory>
```

Uninstall a plugin using the following command:

```shell
$ pba-cli plugin uninstall <plugin name>
```

### Custom scripts

To create a custom script that registers in the CLI, create an executable anywhere on your `PATH` that follows the naming convention `minimal-pba-cli-<name>`.
This script will be registered as a command named `<name>` in the CLI.

As an example, create a script named `minimal-pba-cli-hello` with the following content:

```shell
#!/usr/bin/env sh

echo "Hello, world!"
```

Make the script executable:

```shell
$ chmod +x minimal-pba-cli-hello
```

Now, if the script is located in a directory on your `PATH`, you can run it using the following command:

```shell
$ pba-cli hello
Hello, world!
```

Scripts can be written in any language, as long as they are executable and follow the naming convention:

```python
#!/usr/bin/env python

# minimal-pba-cli-quote

import json
import urllib.request


if __name__ == "__main__":
    response = urllib.request.urlopen("https://zenquotes.io/api/random")
    data = json.loads(response.read().decode("utf-8"))
    print(f"""
"{data[0]['q']}"

- {data[0]['a']}
```

```shell
$ pba-cli quote

"Educating the mind without educating the heart is no education at all."

- Aristotle
```
gitghost 1.0.4
Private version control for your Git ignored files.
Requires Python: >=3.10

# GitGhost

Private version control for your Git ignored files.

## Why use GitGhost?

- **Keep sensitive files private:** Manage secrets, configs, or personal files outside your public repo.
- **Seamless Git integration:** Works alongside your existing Git workflow.
- **Simple commands:** Easily save, check status, or discard private changes.
- **Separate private repo:** Keeps your private data secure and versioned.
- **Cross-platform:** Designed for Linux, works on any system with Python 3.10+.

## Requirements

- Python 3.10 or higher
- Git installed
- GitHub CLI (`gh`) is required for private repo automation

## Installation

Install GitGhost directly from PyPI:

```bash
pip install gitghost
```

## Commands

Initialize GitGhost in your project:

```bash
gitghost init
```

Check status of private files:

```bash
gitghost status
```

Save private changes:

```bash
gitghost save
```

Discard private changes:

```bash
gitghost discard
```

Get help and list all commands:

```bash
gitghost help
```

## How it works

- Specify private files/folders in `.gitghostinclude` (which should also be in `.gitignore`).
- GitGhost manages a **separate private repository** for these files.
- `gitghost save` commits and pushes private changes.
- `gitghost status` shows private file changes.
- Keeps private data out of your public repo, but safely versioned.

## License

This project is licensed under the **MIT License**. See the [LICENSE](https://opensource.org/licenses/MIT) file for details.
minimal-pba-cli-plugin-example 0.0.3
A minimal command-line interface plugin for minimal-pba-cli
Requires Python: >=3.9

# Minimal command-line interface plugin for [minimal-pba-cli](https://github.com/easy-as-python/minimal-pba-cli)

This is a minimal example of a plugin that can be discovered, installed, and used in a command-line interface using a plugin-based architecture.

## Key moving parts

The main components of a working plugin are:

- The distribution name: Plugins must have a distribution name with a known prefix (in the case of this project, `minimal-pba-cli-plugin-`).
- `[project.entry-points.minimal_pba_cli]`: This section must exist in `pyproject.toml` and must contain one key-value pair,
  where the key is the "proper" name of the plugin (without the distribution name prefix)
  and the value is the dotted module path of the plugin's main entry point
- The plugin entry point: This module must contain either or both of `groups` and `commands`.
  Each of these is a dictionary whose keys are the name of the command or command group that the plugin will provide to the core CLI,
  and whose values are the [Typer](https://typer.tiangolo.com/) command group objects or command objects, respectively, to execute.
cloudflare-images-mcp 0.1.0
Simple MCP server to add images to Cloudflare Images
Requires Python: <3.13,>=3.10

# Cloudflare Images MCP 🛠️

## Simple MCP Tool to add images to Cloudflare Images

### Configuration

> **ℹ️ Note:** Instead of providing `--account-id` and `--api-token` as arguments, you can also use the environment variables `CLOUDFLARE_ACCOUNT_ID` and `CLOUDFLARE_API_TOKEN` respectively.

```json
{
  "mcpServers": {
    "cloudflare-images-mcp": {
      "command": "uvx",
      "args": [
        "cloudflare-images-mcp",
        "--account-id",
        "your-account-id",
        "--api-token",
        "your-api-token"
      ]
    }
  }
}
```
modelbase-migrate 0.1.0
Migrate models between different modelbase versions
Requires Python: >=3.12
Keywords: metabolic, modelling, ode

# modelbase-migrate

Migrate models between different modelbase versions (currently v1 -> v2).

## Installation

```bash
pip install modelbase-migrate
```

## Usage

```python
from modelbase_migrate import migrate

migrate(
    model_v1,
    initial_conditions={...},
    out_file=out / "model_name.py",
)
```
canonicalwebteam.upload-assets 0.4.1
A command-line tool for uploading assets to an assets server.

# A command-line tool for managing [assets.ubuntu.com](https://github.com/canonical-web-and-design/assets.ubuntu.com)

This is intended to be a simple command-line tool for uploading assets to an <https://assets.ubuntu.com>-like assets
server.

## Installation

### Snap install

On a [snap](https://snapcraft.io/)-enabled system, you can simply:

``` bash
sudo snap install upload-assets
```

### Pip install

If you can't install the snap, you can install with pip.

First [install python3 pip](http://stackoverflow.com/questions/6587507/how-to-install-pip-with-python-3), then:

``` bash
sudo pip3 install canonicalwebteam.upload-assets
```

### Manual Install from this repo

1. Create a virtual environment and activate it

``` bash
python3 -m venv venv
source venv/bin/activate
```

2. Install local pip packages

``` bash
pip install .
```

3. Install pip packages from requirements

``` bash
pip install -r requirements.txt
```

## Usage

You should now have access to the `upload-assets` command:

``` bash
$ UPLOAD_ASSETS_API_TOKEN=XXXXXXXX upload-assets  \
    -d assets.EXAMPLE.com  \
    ~/EXAMPLE_DIRECTORY ./EXAMPLE_IMAGE.png
[
    {"url": "https://assets.ubuntu.com/v1/2071d161-EXAMPLE_IMAGE.png", "filepath": "/home/robin/EXAMPLE_IMAGE.png"},
    {"url": "https://assets.ubuntu.com/v1/2071d161-IMAGE1.png", "filepath": "/home/robin/EXAMPLE_DIRECTORY/IMAGE1.png"},
    {"url": "https://assets.ubuntu.com/v1/2071d161-IMAGE2.png", "filepath": "/home/robin/EXAMPLE_DIRECTORY/IMAGE2.png"}
]
```

## Configuration

To avoid specifying them every time, you can store both the URL and the token for the assets API in environment variables:

``` bash
$ export UPLOAD_ASSETS_API_TOKEN=<api-token>
$ export UPLOAD_ASSETS_API_DOMAIN=assets.example.com
$ upload-assets EXAMPLE_IMAGE.png
```
MP4MDL 0.1.2
Un outil pour télécharger et gérer des vidéos MP4
Requires Python: >=3.6

# Description 

This project is a library that allows you to download MP4 files with video links.

# Website Supported

- âœ… video.sibnet.ru
- âœ… vidmoly.to
- âœ… oneupload.to
- âœ… sendvid.com