semvec/pypi-packages huggingface dataset:
colourup 0.1.4
Utility to make your terminal apps stand out.
Requires Python: >=3.11

# ColourUp 🎨

[![PyPI version](https://badge.fury.io/py/colourup.svg)](https://badge.fury.io/py/colourup)
[![Static Badge](https://img.shields.io/badge/python-%2B3.12-blue?logo=python&logoColor=blue)](https://www.python.org/downloads/)
![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/piker98988/colourup/python-package.yml)
![GitHub last commit](https://img.shields.io/github/last-commit/piker98988/colourup)

Make your terminal output beautiful with simple, intuitive styling functions.

## ✨ Features

- 🎯 Simple API for common terminal styling needs
- 🌈 16 Foreground & Background colors
- 💫 Text effects (bold, italic, underline, inverse)
- 📏 Centered titles with custom borders
- 🔤 Styled input prompts
- 💻 Windows support via Colorama

## 📦 Installation

```bash
pip install colourup
```

## 🚀 Quick Start

```python
from colourup import title, pinput
from colourup.styles import fg, bg, style

# Create beautiful titles
title("Welcome to ColourUp!", "=", 6)  # ====== Welcome to ColourUp! ======

# Styled input prompts (spaces at the end included)
name = pinput("What's your name?", customprompt="→")
# What's your name?
# → 

# Colorful output
print(f"{fg.GREEN}{styles.BOLD}Success!{styles.RESET}")
print(f"{bg.BLUE}{fg.WHITE}Info message{styles.RESET}")
```

## 🎨 Available Styles

### Colors (fg/bg)
Standard: `BLACK` `RED` `GREEN` `YELLOW` `BLUE` `MAGENTA` `CYAN` `WHITE`
Bright: `BBLACK` `BRED` `BGREEN` `BYELLOW` `BBLUE` `BMAGENTA` `BCYAN` `BWHITE`

### Text Effects
- `BOLD` -- **Bold text**
- `ITALIC` -- *Italic text*
- `UNDERLINE` -- Underlined text
- `FLIPPED` -- The foreground and background colours are flipped
- `RESET` -- Reset all styles, leave it like default 

> [!TIP]
> Use `styles.RESET` at the end of each print to prevent bleeding the style to the next lines

## 🛠️ Development
```bash
# Clone the repository
git clone https://github.com/piker98988/colourup.git
cd colourup

# Create virtual environment
python -m venv venv
source venv/bin/activate  # Linux/Mac
# or
.\venv\Scripts\activate  # Windows

# Install dependencies
pip install -r requirements.txt
```

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

- Fork the repository
- Create your feature branch (`git checkout -b feature/AmazingFeature`)
- Commit your changes (`git commit -m 'Add some AmazingFeature'`)
- Push to the branch (`git push origin feature/AmazingFeature`)
- Open a Pull Request

## 📄 License

This project is licensed under the GNU General Public License v3.0 - see the [LICENSE](LICENSE) file for details.

Copyright (C) 2024 Piker

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
tchoice 0.0.1
TChoice - Lightweight implementation of Django-like `TextChoices` and `IntegerChoices`.
Requires Python: <4,>=3.11
Keywords: django, textchoices, intchoices, backend, fastapi, microservice, typing, enum, dataclass, dataclasses, pydantic

# TChoice

Lightweight implementation of Django-like `TextChoices` and `IntegerChoices` 
for Python applications.

## Problem Statement

When working with FastAPI or other frameworks, it's often useful to have 
enumerations with labels for better readability and usability in models, 
forms, and APIs. While Django provides `TextChoices` and `IntegerChoices` 
for this purpose, they are tightly coupled to the Django framework. 
`tchoice` offers a standalone solution, allowing you to use similar 
functionality without requiring Django.

## Installation

Install the package via pip:

```bash
pip install tchoice
```

## How to Use

### Defining Choices
You can define your choices using `TextChoices` or `IntegerChoices`:

```python
from tchoice import TextChoices, IntegerChoices

class ColorChoices(TextChoices):
    RED = "red", "Red Color"
    GREEN = "green", "Green Color"
    BLUE = "blue", "Blue Color"

class SizeChoices(IntegerChoices):
    SMALL = 1, "Small Size"
    MEDIUM = 2, "Medium Size"
    LARGE = 3, "Large Size"
```

### Accessing Labels and Values

```python
print(ColorChoices.RED)          # Output: red
print(ColorChoices.RED.label)    # Output: Red Color

print(SizeChoices.SMALL)         # Output: 1
print(SizeChoices.SMALL.label)   # Output: Small Size
```

### Using Choices in Models

For FastAPI and Pydantic:

```python
from pydantic import BaseModel
from tchoice import TextChoices

class ColorChoices(TextChoices):
    RED = "red", "Red Color"
    GREEN = "green", "Green Color"
    BLUE = "blue", "Blue Color"

class Item(BaseModel):
    name: str
    color: ColorChoices

# Example usage
item = Item(name="Example Item", color=ColorChoices.RED)
print(item.color)           # Output: red
print(item.color.label)     # Output: Red Color
```

---

## License

This project is licensed under the terms of the [MIT license](https://github.com/ispaneli/tchoice/blob/master/LICENSE).
pysgconnect 2.3
Utilities to interact with SGConnect
Requires Python: >=3.10

# pysgconnect

Python package to interact with SGConnect

## Install

You can install this package by using Pypi:

```sh
pip install pysgconnect
```

## Usage

### Protect HTTP requests

```python
from pysgconnect import SGConnectAuth
from requests import Session

session = Session()
# Do not hardcode your credential directly in your scripts, use a secure Vault solution instead
client_id = 
client_secret =

session.auth = SGConnectAuth(client_id, client_secret, scopes=['myscope'], env='PRD')

request = session.get('https://api.sgmarkets.com/foo/v1/bar')
```

#### Corporate proxy

By default, no proxies are configured.

```python
proxies = {'https': '...', 'http': '...'}
session.auth = SGConnectAuth(client_id, client_secret, scopes=['...'], proxies=proxies)
```

### Development

```sh
pip install -e .
```
liquibase-checks-python 2.0.0
Use python to write your custom policy checks for Liquibase
Requires Python: >=3.10

# liquibase-checks-python
Write your custom policy checks using Python! Secure your database and lock 
down your CI by running your own custom logic to evaluate the safety and security
of each database change.

### Requirements
* Python 3.10 or graalpy-24.0.0
* Liquibase 4.29.0

## Getting Started
We recommend installing `liquibase-checks-python` in a virtual environment.

### Installation
Create your virtual environment 

`python -m venv <path/to/venv>`

Install `liquibase-checks-python`

`pip install liquibase-checks-python`

You can validate the package has been successfully installed by running `pip list`

### Writing your first custom policy check
Create a file `custom.py` inside your liquibase working directory.

`touch custom.py`

Configure a new database scoped `CustomCheckTemplate` with the name `MyCustomCheck` with liquibase and set the `SCRIPT_PATH` to `custom.py`

`liquibase checks customize --check-name CustomCheckTemplate`

Open your `custom.py` in your text editor and add the following:

```python
from liquibase_checks_python import liquibase_utilities as lb
import sys

obj = lb.get_database_object()
status = lb.get_status()

if lb.is_table(obj):
	status.fired = True
	status.message = "No tables allowed!"
	sys.exit(1)
```

Run your new custom check

`liquibase --script-python-executable-path <path/to/venv>/bin/python --checks checks run --check-name MyCustomCheck --checks-scope database --checks-scripts-enabled`

If your database has any tables, you should see a warning like this:

```
DATABASE CHECKS
---------------
Validation of the database snapshot found the following issues:

Check Name:         Custom Check Template (test)
Object Type:        table
Object Name:        my_table
Object Location:    DEV.PUBLIC.my_table
Check Severity:     BLOCKER (Return code: 4)
Message:            No tables allowed!
```