semvec/pypi-packages huggingface dataset:
sardana-config 3.6.0
Sardana configuration system
Requires Python: >=3.9

# Sardana config

*Sardana config* is a commandline tool for managing Sardana (https://sardana-controls.org) 
configurations. It is based around a YAML file format.

This repo contains a separate "fork" of the configuration tool currently built in to 
Sardana  The idea is to decouple the development of this still rather new tool from the 
rest of Sardana which can move quite slowly.

For documentation, for now you are referred to the main Sardana documentation https://sardana-controls.org/users/configuration/index.html

This project depends on Sardana, and will replace the built in version of
the config tool with its own. So you can run it with the main `sardanactl`
script, e.g.

    $ sardanactl config
    
There is also a separate script called `sardana-config`.


## Future of this repo

This repo is an experiment to see if we can speed up development in the short term. 
There is currently no exact plan for the future, we might keep development here and
merge back into Sardana for each release, or the project may live here and be a
dependency of Sardana long term. Or it may eventually completely merge back into
the Sardana codebase.
sqgen-risk 0.1.0
This is a template repository for Python projects that use uv for their dependency management.
Requires Python: <3.12,>=3.9
Keywords: python

# sqgen_risk

[![Release](https://img.shields.io/github/v/release/SquareGen-LLC/sqgen-risk)](https://img.shields.io/github/v/release/SquareGen-LLC/sqgen-risk)
[![Build status](https://img.shields.io/github/actions/workflow/status/SquareGen-LLC/sqgen-risk/ci.yml?branch=main)](https://github.com/SquareGen-LLC/sqgen-risk/actions/workflows/ci.yml?query=branch%3Amain)
[![Commit activity](https://img.shields.io/github/commit-activity/m/SquareGen-LLC/sqgen-risk)](https://img.shields.io/github/commit-activity/m/SquareGen-LLC/sqgen-risk)
[![License](https://img.shields.io/github/license/SquareGen-LLC/sqgen-risk)](https://img.shields.io/github/license/SquareGen-LLC/sqgen-risk)

This is a template repository for Python projects that use uv for their dependency management.

- **Github repository**: <https://github.com/SquareGen-LLC/saas-sdk/>
- **Documentation** <https://github.com/SquareGen-LLC/saas-sdk/blob/main/README.md>


## Installation

```bash
pip install sqgen-risk
```

With [`uv`](https://docs.astral.sh/uv/):

```bash
uv add sqgen-risk
```

## Basic Usage Example

Below is a basic example of how to use the SDK to authenticate, list models, submit an inference, and retrieve results:

```python
from os import getenv
from sqgen_risk.client import Client

# Initialize the client
client = Client()

# Authenticate using credentials from environment variables
email = getenv("API_EMAIL")
password = getenv("API_PASSWORD")
if not email or not password:
    raise RuntimeError("Missing required environment variables")

token = client.authenticate(email=email, password=password)
print(f"Authenticated successfully. Token: {token}")

# List available models
models = client.list_models()
print("\nAvailable models:")
for model in models:
    print(f"- {model.name} (ID: {model.model_id})")

# Submit an inference request
inference = client.create_inference(model_id="model-123", file_path="data.csv")
print(f"\nCreated inference request: {inference.inference_request_id}")

# Check inference status and get results
result = client.get_inference_result(inference.inference_request_id)
if result is None:
    print("Inference is still processing...")
else:
    print("Inference completed. Saving results...")
    with open("result.csv", "wb") as f:
        f.write(result)

# List all inferences
inferences = client.list_inferences()
print("\nAll inference requests:")
for inf in inferences:
    print(f"- ID: {inf.inference_request_id}, Model: {inf.model_id}, Created: {inf.created_at}")
```

Set the following environment variables before running the example:

```bash
export API_EMAIL="your-email@example.com"
export API_PASSWORD="your-password"
```

Replace `model-123` and `data.csv` with your actual model ID and CSV file path.
typerdantic 1.0.3
A library for creating declarative, interactive CLI menus with Pydantic and prompt-toolkit.
Requires Python: >=3.8

# 🗿 Typerdantic

**Typerdantic** is a Python library for building powerful, interactive, and self-documenting command-line interface (CLI) menus. It combines the command-line elegance of [**Typer**](https://typer.tiangolo.com/), the robust data modeling of [**Pydantic**](https://docs.pydantic.dev/), and the rich terminal UI capabilities of [**prompt-toolkit**](https://python-prompt-toolkit.readthedocs.io/).

The goal is to abstract away the boilerplate of creating interactive menus, allowing developers to define complex, multi-screen applications using simple Pydantic models or configuration files.

---

## Core Features

- **Declarative & Dynamic Menus**: Define menus by subclassing `TyperdanticMenu` or generate them on the fly from configuration files (e.g., YAML, JSON) using a Pydantic-validated schema.
- **External Action Execution**: Run shell commands and scripts directly from your menu configuration using action strings like `"command::echo Hello"` or `"script::./deploy.sh"`.
- **Seamless Navigation**: A top-level `TyperdanticApp` controller manages a single, persistent UI, eliminating screen flashes when navigating between menus.
- **Custom Styling**: Theme your entire application by loading a simple TOML style file.
- **Asynchronous by Design**: Built with `asyncio` to handle user input and execute subprocesses without blocking or freezing the UI.

---

## Example Usage

Define your menu in a configuration file, like `menu.yml`:

```yaml
# file: menu.yml
doc: My Awesome CLI
items:
  list_files:
    description: List files in the current directory
    action: "command::ls -l"

  run_backup:
    description: Run the backup script
    action: "script::./scripts/backup.sh"

  quit:
    description: Exit the application
    is_quit: true
```

Then, load and run your application:

```python
# main.py
import asyncio
import yaml
from pathlib import Path
from typerdantic import TyperdanticApp, create_menu_from_config
from typerdantic.config_models import MenuConfig

async def main():
    # Load and parse the YAML configuration
    config_path = Path("menu.yml")
    with open(config_path, "r") as f:
        config_dict = yaml.safe_load(f)

    menu_config = MenuConfig(**config_dict)

    # Create a menu class from the validated config
    MyMenu = create_menu_from_config("MyMenu", menu_config)

    # Create and run the app
    app = TyperdanticApp(main_menu=MyMenu)
    await app.run()

if __name__ == "__main__":
    asyncio.run(main())
```

---

## Future Goals

- **YAML/JSON Loaders**: Add convenience functions like `load_menu_from_yaml()` to simplify the loading process.
- **Internal Action Registry**: Create a system for registering and calling internal Python functions via action strings (e.g., `"internal::backup_database"`).
- **CLI Menu Builder**: An interactive command to help scaffold new `Typerdantic` apps, menus, and actions.
- **More Widgets**: Support for forms, confirmation dialogs, and progress bars.
simplemapreduce 0.0.4
A simple map reduce multithreaded library
Requires Python: >=3.8

# simplemapreduce

[![PyPI - Version](https://img.shields.io/pypi/v/simplemapreduce.svg)](https://pypi.org/project/simplemapreduce)

---

## Table of Contents

- [Installation](#installation)
- [License](#license)

## Installation

```console
pip install simplemapreduce
```

## Development

The local development setup is based on [hatch](https://hatch.pypa.io/latest/)

## Create the default hatch env

```
hatch env create
```

## Get a shell with the env activated

```
hatch shell
```

## Run various commands

### Linting

```
hatch run lint
```

### Code formatting

```
hatch run format
```

### Type checking

```
hatch run type-check
```

### Testing

```
hatch run test
```

## License

`simplemapreduce` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.
vignore 1.0.9
Visualize ignored files and directories by rules.

<h1 align="center">vignore</h1>

<h2 align="center"><i>Never been so easy to visualize ignore rules</i></h2>

<p align="center">
<a href="https://asciinema.org/a/630043"><img alt="Demo" src="https://asciinema.org/a/630043.svg"></a>
</p>

<p align="center">
<a href="https://github.com/james4ever0/vignore/blob/master/LICENSE"><img alt="License: WTFPL" src="https://img.shields.io/badge/license-UNLICENSE-green.svg?style=flat"></a>
<a href="https://pypi.org/project/vignore/"><img alt="PyPI" src="https://img.shields.io/pypi/v/vignore"></a>
<a href="https://deepwiki.com/James4Ever0/vignore"><img src="https://deepwiki.com/badge.svg" alt="Ask DeepWiki"></a>
<a href="https://pepy.tech/project/vignore"><img alt="Downloads" src="https://static.pepy.tech/badge/vignore"></a>
<a href="https://github.com/james4ever0/vignore"><img alt="Code style: black" src="https://img.shields.io/badge/code%20style-black-000000.svg"></a>
</p>

It has been a while since I've found writing ignore files, like `.gitignore`, `.dockerignore`, or `.fdignore`, being a hassle.

I've struggled with including the correct files and excluding unwanted ones.

But now, there's no need to guess blindly! Experience the power of visualizing ignored (selected) files and receive instant feedback through intuitive representations.

**Highlights**
- Asynchronous output, so you can scroll smoothly while processing
- Extremely fast for large repositories
- Human friendly number representations
- Supports `git` and `fd` ignore files
- Supports custom ignore files and custom `fd` arguments (coming soon)

## Install

```
pip3 install vignore
```

## Usage

The `diffpath` shall be absolute.

```
vignore [-h] -d DIFFPATH

optional arguments:
  -h, --help            show this help message and exit
  -d DIFFPATH, --diffpath DIFFPATH
                        Path to visualize ignored files
```

## Requirements

You need to install [`fd`](https://github.com/sharkdp/fd), a fast `find` alternative.

You need to run this under a Unix-like OS.
m9lib 1.0.1
m9 utility library
Requires Python: >=3.10.6
Keywords: INI, configuration, config, parse, load, batch, etl, logging, color, folder, files, rules, csv

# m9lib Utility Library

m9lib is a python framework for batch processing.  This library also includes general-purpose helper classes for python applications.

The batch processing framework includes:
- A powerful and flexible **Configuration** file format (INI) that drives batch processing
- Support for user-implemented **Command** objects that represent a unit of work to be executed
- A **Control** mechanism for instantiating and executing **Command** objects via configuration
- Integrated **Logging** features, including console logging in color
- Rules-based folder scans using pattern matching, regex, and parent folder

## m9lib Project Creator

The easiest way to get started is with a simple empty project, using the [m9lib project creator](https://github.com/MarcusNyne/m9lib-project).
- Run this application to create an empty vscode project from a template.
- The application itself is a simple example of an m9lib project.

## Sample Projects

A working demonstration of **m9lib** is available from the sample projects below:
- [m9lib-project](https://github.com/MarcusNyne/m9lib-project): Create a simple **m9lib** project from a template. (*simple*)
- [unzip-files](https://github.com/MarcusNyne/unzip-files): Batch process for unziping files. (*simple*)
- [sync-files](https://github.com/MarcusNyne/sync-files): Rules-based folder synchronization process for backing up files. (*intermediate*)

## m9ini Configuration files

**m9lib** uses **m9ini** for reading configuration files.

Read about [m9ini on Github](https://github.com/MarcusNyne/m9ini).

## Basic utilities

| File | Classes | Feature |
| :--- | :--- | :--- |
| u_logger.py | uFileLogger | [Log to a file](docs/logger.md) |
| u_format.py | uStringFormat | [String formatting](docs/format.md) |
| u_folder.py | uFolder | [Folder utilities](docs/folder.md) |
| u_timer.py | uTimer | [Measure elapsed time](docs/timer.md) |
| u_dictionary.py | uDictionary | [Dictionary wrapper](docs/dictionary.md) |

## Application level

| File | Classes | Feature |
| :--- | :--- | :--- |
| u_args.py | uArgs | [Specify and interpret command line parameters](docs/args.md) |
| u_command.py | uCommand, uCommandResult<br>uCommandRegistry | [Command object representing a unit of work](docs/command.md) |
| u_control.py | uControl | [Command orchestration](docs/control.md) |

## Specialized features

| File | Classes | Feature |
| :--- | :--- | :--- |
| u_csv.py | uCSVFormat, uCSV | [CSV file utilities](docs/csv.md) |
| u_web.py | uWeb, uSoap | [Http helper methods](docs/web.md) |
| u_scan.py | uScanFiles, uScanFolders | [Rules for scanning folder structures](docs/scan.md) |
| u_color.py | uColor, uConsoleColor | [Print to console in color](docs/color.md) |