colour_fx
v2.0.0
Este es un proyecto para desarrollar un paquete Python Pypi que no solo maneja la salida de texto de color, sino que también puede aplicar efectos de color como gradientes a su texto.
Este paquete utiliza las interpretaciones de gráficos de secuencia de escape ANSI para aplicar color y estilo a texto y fondos. ¿Cómo es este paquete diferente al de los demás?
Diferentes terminales renderizan los colores de manera diferente, algunos terminales ni siquiera representan secuencias de escape ANSI, lo que lleva a un gran desastre de texto. Jugar con códigos de escape ANSI es solo eso, está jugando.
Algunos colores básicos utilizados con moderación para resaltar diferentes niveles de registro están bien, pero no se puede llevar con los colores en proyectos serios.
Primero, hay códigos de 4 bits y 8 bits disponibles, importe de colour_fx.four_bit y colour_fx.eight_bit respectivamente. Sin embargo, los códigos de 8 bits y 4 bit se pueden usar juntos sin problemas.
Los objetos en estos módulos solo proporcionan el valor que se utilizará dentro de una secuencia de escape ANSI. Deberán ser compilados en una secuencia de escape ANSI utilizando compile_ansi_code que se puede importar con from colour_fx import compile_ansi_code .
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 } !" )
Los colores de 8 bits son mucho más impredecibles en apariencia entre diferentes terminales que los colores de 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 } !" )
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 } "
)
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 } " )
Ahora, esto es lo que inspiró la creación de este paquete, poder aplicar gradientes a grandes bloques de texto.
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 )
No use Windows, instale Python 3.9, luego use source ./tooling && venv-setup para obtener una configuración de Venv con Python 3.9 (nuestra versión de Python más baja)
Use el comando lint-cfx para el trabajo de la pelusa y el comando test-cfx para probar el trabajo.
Use una sucursal en su nombre para hacer el trabajo de funciones, luego envíe una solicitud de extracción.
