colour_fx

C'est un projet pour développer un package Python PYPI qui non seulement gère la sortie du texte de couleur, mais peut également appliquer des effets de couleur tels que les gradients à votre texte.

Introduction

Ce package utilise des interprétations graphiques de séquence d'échappement ANSI afin d'appliquer la couleur et le style au texte et aux arrière-plans. En quoi ce package est-il différent des autres?

• Codes à 8 bits ainsi que des codes à 4 bits
• Il existe une bibliothèque en constante expansion des effets qui peuvent être appliqués à des blocs de textes plus grands.
• Interface super lisse et simple

NB

Différents terminaux rendent les couleurs différemment, certains terminaux ne rendent même pas du tout des séquences d'échappement ANSI, conduisant à un gros gâchis de texte. Jouer avec des codes d'échappement ANSI est juste que, il joue.

Certaines couleurs de base utilisées avec parcimonie pour mettre en évidence différents niveaux de journalisation sont bien, mais vous ne pouvez pas vous emporter avec des couleurs dans des projets sérieux.

Commencer

Tout d'abord, il y a des codes 4 bits et 8 bits disponibles, importez à partir de colour_fx.four_bit et colour_fx.eight_bit respectivement. Cependant, les codes 8 bits et 4 bits peuvent être utilisés ensemble sans problème.

NB

Les objets de ces modules ne fournissent que la valeur à utiliser à l'intérieur d'une séquence d'échappement ANSI. Ils devront être compilés dans une séquence d'échappement ANSI à l'aide compile_ansi_code qui peut être importée avec from colour_fx import compile_ansi_code .

Exemple 4 bits

 from colour_fx import compile_ansi_code
from colour_fx . four_bit import Colour , Style

blinking_red_on_yellow = compile_ansi_code (
    # add as many ANSI values as you like and receive a single ANSI
    # escape sequence to handle all effects
    Colour . RED ,
    Colour . YELLOW . bright_background ,
    Style . BLINK
)

# an empty call to compile_ansi_code() gives the reset ANSI escape
# sequence which resets the way text is rendered
RESET = compile_ansi_code ()

print ( F"HELLO, { blinking_red_on_yellow } WORLD { RESET } !" )

Exemples 8 bits

NB

Les couleurs 8 bits sont beaucoup plus imprévisibles en apparence entre différents terminaux que les couleurs 4 bits.

SimpleColour

 from colour_fx import compile_ansi_code
from colour_fx . eight_bit import SimpleColour

red_on_yellow = compile_ansi_code (
    # add as many ANSI values as you like and receive a single ANSI
    # escape sequence to handle all effects
    SimpleColour . RED ,
    SimpleColour . YELLOW . bright_background ,
)

# an empty call to compile_ansi_code() gives the reset ANSI escape
# sequence which resets the way text is rendered
RESET = compile_ansi_code ()

print ( F"HELLO, { red_on_yellow } WORLD { RESET } !" )

sortir

Grey

 from colour_fx import compile_ansi_code
from colour_fx . eight_bit import Grey

# Grey has 24 different shades available, here we use 12 to apply a
# gradient to the text "HELLO, WORLD!"
grey_array = [
    Grey . AA ,
    Grey . AC ,
    Grey . AE ,
    Grey . BB ,
    Grey . BD ,
    Grey . BF ,
    Grey . CA ,
    Grey . CC ,
    Grey . CE ,
    Grey . DB ,
    Grey . DD ,
    Grey . DF ,
]

# converting shades in grey_array to background colours and
# reversing order
grey_back = [ grey . background for grey in reversed ( grey_array )]

# Compiling the values in grey_array and grey_back into codes
g = [
    compile_ansi_code (
        grey_array [ idx ],
        grey_back [ idx ],
    )
    for idx in range ( len ( grey_array ))
]

# an empty call to compile_ansi_code() gives the reset ANSI escape
# sequence which resets the way text is rendered
RESET = compile_ansi_code ()

# Accessing the individual ANSI escape codes in the list of codes to
# create a gradient
print (
    F" { g [ 0 ] } H { g [ 1 ] } E { g [ 2 ] } L { g [ 3 ] } L { g [ 4 ] } O { g [ 5 ] } ,"
    F" { g [ 6 ] } W { g [ 7 ] } O { g [ 8 ] } R { g [ 9 ] } L { g [ 10 ] } D { g [ 11 ] } ! { RESET } "
)

sortir

RGB

 from colour_fx import compile_ansi_code
from colour_fx . eight_bit import RGB


# RGB is different to the rest in that you need to pass values in and
# initialise the object rather than treating as an Enum
# RGB values should be an integer between 0 and 5 inclusive
spectrum = [
    RGB ( 5 , 0 , 0 ). foreground ,
    RGB ( 3 , 2 , 0 ). foreground ,
    RGB ( 1 , 4 , 0 ). foreground ,
    RGB ( 0 , 4 , 1 ). foreground ,
    RGB ( 0 , 2 , 3 ). foreground ,
    RGB ( 0 , 0 , 5 ). foreground ,
]

# compiling spectrum into ANSI escape sequences while adding a
# white background
s = [
    compile_ansi_code ( spec , RGB ( 5 , 5 , 5 ). background )
    for spec in spectrum
]

# an empty call to compile_ansi_code() gives the reset ANSI escape
# sequence which resets the way text is rendered
RESET = compile_ansi_code ()

# Accessing individual elements of s allows a gradient
print ( F" { s [ 0 ] } HE { s [ 1 ] } LL { s [ 2 ] } O, { s [ 3 ] } WO { s [ 4 ] } RL { s [ 5 ] } D! { RESET } " )

sortir

Être avancé

Maintenant, c'est ce qui a inspiré la création de ce package, pouvoir appliquer des gradients à de grands blocs de texte.

gradients

 from colour_fx . four_bit import Colour
from colour_fx . effects . gradients import create_vertical_gradient_field
from colour_fx . effects import apply_ansi_field

rainbow_vals = [
    [ Colour . RED ],
    [ Colour . RED . bright ],
    [ Colour . YELLOW . bright ],
    [ Colour . GREEN ],
    [ Colour . BLUE ],
    [ Colour . BLUE . bright ],
    [ Colour . MAGENTA ],
]

text_to_render = (
    "       :::    ::: :::::::::: :::        :::        ::::::::  ::: n "
    "      :+:    :+: :+:        :+:        :+:       :+:    :+: :+:  n "
    "     +:+    +:+ +:+        +:+        +:+       +:+    +:+ +:+   n "
    "    +#++:++#++ +#++:++#   +#+        +#+       +#+    +:+ +#+    n "
    "   +#+    +#+ +#+        +#+        +#+       +#+    +#+ +#+     n "
    "  #+#    #+# #+#        #+#        #+#       #+#    #+#          n "
    " ###    ### ########## ########## ########## ########  ###       n "
)

output_field = create_vertical_gradient_field (
    template = text_to_render ,
    ansi_vals = rainbow_vals ,
    indent = 3 ,
    step = 1 ,
)

output_text = apply_ansi_field (
    text = text_to_render ,
    field = output_field
)

print ( output_text )

sortir

Travailler là-dessus?

N'utilisez pas Windows, installez Python 3.9, puis utilisez source ./tooling && venv-setup pour vous procurer un Venv configuré avec Python 3.9 (notre version Python la plus basse prise en charge)

Utilisez la commande lint-cfx pour travailler avec Lint et commander test-cfx pour tester les travaux.

Utilisez une branche à votre nom pour effectuer des fonctionnalités, puis soumettez une demande de traction.