[Python]Mi módulo newbie n.n

[edit] ¿Cómo le pongo color al código?
Bueno, edito el mismo post. Ya solucioné mis dudas, leí, entendí y estoy haciendo mi módulo (ya hace unos días) con varias funciones raras
Pienso ponerle muchas cosas, hasta ahora tiene:
-Armado de menúes (Ahora estoy trabando en el armado de menúes con contexto)
-Armado de cajas de texto (con recuadros ASCII Extendidos)
-Marquesina de textos (Textos en movimiento, los cuáles voy a mejorar)
-Manejo de color en consola: Obtener atributs de texto, cambiarlos, etc.
-Obtención de valores: Se puede pasra una lista de cadenas, y devuelve la de menor y mayor longitud, o se puede pasar números y da el mayor y el menor, en una tupla.
-Tiene otros "dos print", ilprint para mostrar un mensaje con otro color, sin cambiar el color de la consola, es decir, cambia solopara mostrar el texto y vuelve a la normalidad y "olprint" que es lo mismo, solo que muestra el texto seguido (equivalente a sys.stdout.write)
-Invertir cadenas
-Muestra mensajes con beepeo
Y estoy trabajando en:
Barra de progreso
Inputboxes (Con recuadros ascii)
Animaciones ascii
Relojes (TAmbién en ASCII, toda la onda)
Y estoy modificando un programa mío para resolver cosas de matemática, y poderlo aplicar
Es una newbiada, y tiene cosas que están de mas, pero es porque forman parte de lo que estoy agregando
tiene un par de variables definidas, como líneas, y cosas así
Véanlo en el código, después voy a hacer un texto sobre como usarlo
Es una newbiada total, y espero que algunos sabiondos puedan corregirme n.n Hay cosas que repito ESTÁN DE MAS pero porque van a formar parte de otra cosa que estoy armando
Y también puse de dónde aprendí eso
Código
# -*- coding: cp1252 -*-
#--------------------------------------------
#Autor: GeSeM (S3KH)   Grisolía Emilio.
# Se permite la modificación, y edición de jazzer. Dejando a la moral de cada uno el hecho de mantener o no los créditos.
#Prohibido distribuirlo compilado SIN el fichero de texto, puesto que es código abierto.
#Programado en Python 2.7. 
#-- 
#Versión 2.0 
# Espero, pueda servirles un poco...!
#                                    Septiembre, 2011. Argentina.
#--------------------------------------------
 
print 'Cargando Jazzer...'
print 'Cargando datos... 100%'
ERROR01 = 'Error (Argumento invalido): '
ERROR02 = 'Error (Función inexistente): '
ERROR03 = 'Error (Dato/s invalido/s): '
VAR     = 'VAR'
n       = '-n'
endl    = 'endl'
 
 
 
print 'Cargando (modulos)... 100%'
 
 
#--- MÓDULOS IMPORTADOS ---#
 
import os, time, math, cmath, sys
print 'Cargando ctypes... 100%'
from ctypes import *
 
#-- El uso de ctypes brinda la posibilidad de poder usar las APIs de Windows, entre demás prestaciones de C
 
#------------CONSTANTES (WIN32API)------------------------#
 
print 'Cargando jazzer (GENERIC_READ)... 100%'
#GENERIC_READ
 
STD_INPUT_HANDLE     = -10
STD_OUTPUT_HANDLE    = -11
STD_ERROR_HANDLE     = -12
 
#-- Tipos de dato C
print 'Cargando datos C... 100%'
Short                = c_short
uShort               = c_ushort
Long                 = c_long
 
#-- HWND (GetStdHandle)
print 'Cargando HWND_STD(IO)... 100%'
HWND_StdOut          = windll.kernel32.GetStdHandle(STD_OUTPUT_HANDLE)
HWND_StdIn           = windll.kernel32.GetStdHandle(STD_INPUT_HANDLE)
 
 
#------------CONSTANTES (COLORES)--------------------------#
# Dados en formato hexadecimal                             #
#----------------------------------------------------------#
print 'Cargando colores... 100%'
FOREGROUND_BLACK     = 0x0000
FOREGROUND_BLUE      = 0x0001
FOREGROUND_GREEN     = 0x0002
FOREGROUND_CYAN      = 0x0003
FOREGROUND_RED       = 0x0004
FOREGROUND_MAGENTA   = 0x0005
FOREGROUND_YELLOW    = 0x0006
FOREGROUND_GREY      = 0x0007
FOREGROUND_INTENSITY = 0x0008 # Color de texto intensificado
BACKGROUND_BLACK     = 0x0000
BACKGROUND_BLUE      = 0x0010
BACKGROUND_GREEN     = 0x0020
BACKGROUND_CYAN      = 0x0030
BACKGROUND_RED       = 0x0040
BACKGROUND_MAGENTA   = 0x0050
BACKGROUND_YELLOW    = 0x0060
BACKGROUND_GREY      = 0x0070
BACKGROUND_INTENSITY = 0x0080 # Fondo de texto intensificado
 
#-------------------------------------------------------------#
 
#-------- Carácter de emisión de sonido
beep                 = chr(7)
 
 
 
 
#----- CONSTANTES (Gráficas) ----------------------------------#
 
print 'Constantes graficas... 100%'
#----- LÍNEAS (ASCII EXTENDIDO) -----#
 
# Usadas para la construccion de menúes
 
# formato de constante:
# Las constantes de las líneas se componen de un prefijo "l", seguido de una S o una D
# para indicar si es simple(S) o doble(D). Finalmente, un juego de 3 letras indica cuál caracter es:
 
#-- ES(I/D) = Esquina Superior (Izquierda o Derecha)
#-- EI(I/D) = Esquina Inferior (Izquierda o Derecha)
#-- HOR     = HORizontal
#-- VER     = VERtical
#-- CRZ     = CRuZ
#-- T(DI/ID)= "T" (Derecha>Izquierda / Derecha<Izquierda) (Línea "T" que apunta hacia un lado)
#-- LT(B/A) = Línea T (Baja / Alta) (De abajo hacia arriba / De arriba hacia abajo)
 
#----------LÍNEAS DOBLES---------------------------#
lDESI    = chr(201) #-- Esquina superior izquierda
lDESD    = chr(187) #-- Esquina superior derecha
lDEID    = chr(188) #-- Esquina inferior derecha
lDEII    = chr(200) #-- Esquina inferior izquierda
 
lDVER    = chr(186) #-- Línea doble vertical
lDHOR    = chr(205) #-- Linea doble horizontal
 
lDLTA    = chr(203) #-- Línea "T" (Arriba)
lDLTB    = chr(202) #-- Línea "T" (Abajo)
lDTID    = chr(185) #-- Línea "T" (Izquierda>Derecha)
lDTDI    = chr(204) #-- Línea "T" (Derecha>Izquierda)
 
lDCRZ    = chr(206) #-- Linea doble "cruz"
 
#----------LÍNEAS SIMPLES---------------------------#
lSEII    = chr(192) #-- Esquina inferior izquierda
lSESI    = chr(218) #-- Esquina superior izquierda
lSESD    = chr(191) #-- Esquina superior derecha
lSEID    = chr(217) #-- Esquina inferior derecha
 
lSVER    = chr(179) #-- Línea vertical
lSHOR    = chr(196) #-- Línea horizontal
 
lSTID    = chr(195) #-- Línea "T" (Izquierda>Derecha)
lSLTB    = chr(193) #-- Línea "T" (abajo)
lSLTA    = chr(194) #-- Línea "T" (arriba)
lSTDI    = chr(180) #-- Linea "T" (Derecha>Izquierda)
 
lSCRZ    = chr(197) #-- Línea "cruz"
 
 
#----------------GRÁFICOS---------------------------#
# Carácteres que son usados para rellenar espacios
# o gráficos, animaciones, etc
#----------------------------------------------------#
 
fill_1           = chr(176) #-- Menos saturado
fill_2           = chr(177)
fill_3           = chr(178)
fill_4           = chr(219) #-- Mas saturado
#--
fill_5           = chr(220)
fill_6           = chr(221)
fill_7           = chr(222)
fill_8           = chr(223)
blank            = ' '
P                = '.'
D1, D2           = '<', '>'
line             = chr(10)
 
print 'Secuencias (animaciones)... 100%'
#---------SECUENCIAS--------------------------------#
# Las animaciones son secuencias de carácteres
# que mostrados (respetando dicha secuencia)
# generan "imágenes" en movimiento.
# Se almacenan en listas, para ser impresas
# siguiendo el orden en ellas.
#----------------------------------------------------#
 
ANIM01           = [P, P*2, P*3]                    #Secuencia de 3 puntos suspensivos
ANIM02           = [D1, D1*2, D1*3]                 #Secuencia con los direccionales (<)
ANIM03           = [D2, D2*2, D2*3]                 #Secuencia con los direccionales (>)
ANIM04           = [fill_1, fill_2, fill_3, fill_4] #Secuencia con carácteres de relleno
ANIM05           = ['\\', lSVER*2, '/', lSHOR*2]    #Secuencia de barra giratoria
ANIM06           = [blank, D1]                      #Prompt titilante
 
 
 
print 'Cargando controles... 100%'
#----------CONSTANTES DE CONTROLES------------------#
# Hay disponibles los siguientes "controles":
# Cajas de aviso
# Cajas de ingreso de datos
# Relojes (Numeración romana, occidenta (Analógica / Digital)
# Barras separadoras
#---------------------------------------------------#
# Próximamente (Barras de progreso, animaciones ASCII)
# Y mas...!
 
 
#--CAJAS DE TEXTO (Marco doble) (Argumentos)
 
DBox  = 'DBox'
DDBox = 'DDBox'
DIBox = 'DIBox'
D1Box = 'D1Box'
D2Box = 'D2Box'
 
 
#--CAJAS DE TEXTO (Marco simple) (Argumentos)
 
SBox  = 'SBox'
SDBox = 'SDBox'
SIBox = 'SIBox'
S1Box = 'S1Box'
S2Box = 'S2Box'
 
#Lista de cajas
 
Boxes = [DBox, DDBox, DIBox, D1Box, D2Box, SBox, SDBox, SIBox, S1Box, S2Box]
 
#------------- Relojes ----------------------#
CLOCK_OCC   = 'CLOCK_OCC'
CLOCK_ROM   = 'CLOCK_ROM'
 
DIGITAL   = 'DIGITAL'
ANALOGIC = 'ANALOGIC'
 
FORM12    = 'FORM12'    #Formato de 12horas
FORM24    = 'FORM24'    #Formato de 24horas
 
sContext = 'sRecuadro' #Sin recuadro
Context1 = 'Recuadro1' #Recuadro rectangular o cuadrado
Context2 = 'Recuadro2' #Recuadro circular o redondeado
 
NUM_OCC12 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
NUM_OCC24 = NUM_OCC12
iN = 13
while (iN <= 24):
    NUM_OCC24.append(iN)
    iN += 1
 
 
NUM_ROM  = {1:'I',
            2:'II',
            3:'III',
            4:'IV',
            5:'V',
            6:'VI',
            7:'VII',
            8:'VIII',
            9:'IX',
            10:'X',
            11:'XI',
            12:'XII'
            }
 
 
 
#---------------------------------------------#
 
 
 
 
 
 
print 'Cargando estructuras C... 100%'
#-------------------------------------------------------------------------------------#
 
#--ESTRUCTURAS C------------------------------#
# Las estructuras C son utilizadas
# junto con ctypes para poder invocar funciones
# del sistema operativo, que necesiten apuntar
# a estructuras de datos
#-----------------------------------
# Visitar MSDN y documentación de Python para mas información.
 
#----------------------Console (ScreenBufferInfo)
 
class COORD(Structure):           #-- Estructura para coordenadas.
        _fields_ =[
                ('X', Short),
                ('Y', Short)
                  ]
 
class SMALL_RECT(Structure):       #-- Estructura para posiciones.
        _fields_ =[
                ('Left', Short),
                ('Top', Short),
                ('Right', Short),
                ('Bottom',Short)
                  ]
 
class CONSOLE_SCREEN_BUFFER_INFO(Structure):
        _fields_ =[
                ('dwSize', COORD),
                ('dwCursorPosition', COORD),
                ('wAttributes', uShort),
                ('srWindow', SMALL_RECT),
                ('dwMaximumWindowSize', COORD)
                  ]
 
 
print 'Cargando funciones... (Misc)'
#--- Reversión de una cadena
#--- (Argumento = Cadena)
def strReverse(String):
        reversedString = ''
        reverseIndex  = -1
        abs_maxCount  = abs(len(String))
        while (abs(reverseIndex) <= abs_maxCount):
            reversedString = reversedString + String[reverseIndex]
            reverseIndex -= 1
        return reversedString
 
#--- Obtención de cadena de mayor y menor longitud, o número mas grande y mas chico
#--- Devuelve una tupla, siendo elemento 0 el mayor y 1 el menor.
#--- Los arugmentos son: 'str', 'num', para indicar si se trabaja con una cadena o números.
#--- Traspasar cualquier cantidad de cadenas/números
def GetValues(valueType, *Values):
        valTypes = ('str', 'num');
        if not (valueType in valTypes): return ERROR01+valueType;   
        if (valueType==valTypes[0]):
                maxStr, minStr = '', '';
                lenValues      = len(Values);
                Count          = 0;
                maxCount       = (lenValues - 1);
                while (Count < maxCount):
                        if (len(Values[Count]) > len(Values[Count+1])):
                                maxStr=Values[Count];
                                minStr=Values[Count+1];
                        elif (len(Values[Count]) < len(Values[Count+1])):
                                maxStr=Values[Count+1];
                                minStr=Values[Count];
                        Count += 1;
                return maxStr, minStr;
        elif (valueType==valTypes[1]):
                tmpMenor = 0
                tmpMayor = 0
                longitudValores    =len(Valores)
                Contador           = 0
                maxContador        = (longitudValores-1)
                while (Contador < maxContador):
                        if (Valores[Contador] >= Valores[Contador+1]):
                                tmpMayor = Valores[Contador]
                                tmpMenor = Valores[Contador+1]     
                        elif (Valores[Contador] <= Valores[Contador+1]):
                                tmpMayor = Valores[Contador+1]
                                tmpMenor = Valores[Contador]
                        Contador += 1
                return tmpMayor, tmpMenor
 
 
print 'Cargando funciones (WINAPI32)...100%'
#------------------------------FUNCIONES---------------------------------#
 
#--- Manejo de consola (Color e información)
#--- No necesita argumentos, devuelve el color de consola.
def GetConsoleColor():
        GConsoleScreenBufferInfo = CONSOLE_SCREEN_BUFFER_INFO()
        windll.kernel32.GetConsoleScreenBufferInfo(HWND_StdOut, byref(GConsoleScreenBufferInfo))
        return hex(GConsoleScreenBufferInfo.wAttributes)
#--- Argumento = Color
def SetConsoleColor(Color):
        bool = windll.kernel32.SetConsoleTextAttribute(HWND_StdOut, Color)
        return bool
 
 
 
 
 
 
#-------------------------------------------------------------------------#
 
 
print 'Cargando funciones de cálculo lineal... 100%'
class Lineal:
# Cálculo líneal
    def __init__(self, a, b, c):
        self.a = a
        self.b = b
        self.c = c
# Obtención de discriminante
    def Discriminante(self):
        Discriminante = self.b*self.b -4*self.a*self.c
        return Discriminante
# Obtención de raices (Soporte para raices en campo complejo)   
    def raices(self):
        Discriminante = self.b*self.b -4*self.a*self.c
        if (Discriminante < 0):
                real = -self.b/(2*self.a) 
                imag = math.sqrt (-Discriminante)/(2*self.a)
                return 'Im', 'X1', real, imag, 'X2', real, imag
        elif (Discriminante > 0):
                X1 = (-self.b + math.sqrt (Discriminante))/(2*self.a) 
                X2 = (-self.b - math.sqrt (Discriminante))/(2*self.a)
                return '2', X1, X2
        elif (Discriminante == 0):
                X = -self.b/(2*self.a)
                return '1', X
 
 
#-----------Draws--------------------------------------------------------#
def pchar(char): sys.stdout.write(char);
 
def iprint(Color, jline, *iText):
        def tpchar(Text):
            for item in Text: pchar(str(item));
        if (Color != n):
            prevColor = hex(GetConsoleColor());
            SetConsoleColor(Color);
        Count     = 0;
        fText     = [];
        for item in iText:fText.append(str(item));
        for item in fText:tpchar(str(item)); 
        if (Color != n):
            SetConsoleColor(prevColor);
        if (jline == endl):
            print line
 
class Draw:
        def __init__(self, *Args):
            self.Args = Args   #-- En construcción 
 
#----------CONTROLES------------------------------------------------------#
 
 
print 'Cargando controles... 100%'
 
 
 
 
class Control:
        def __init__(self, *Options):
                if not (Options):
                    pass;
 
                lnOptions = len(Options)
                #-- En construcción
 
 
 
 
 
        def Box(self, Color, Sound, Stop, Text, box):
                if not (box in Boxes):
                        x = Control()
                        Control.sbox(x, 0xC, 0, 1, 'Error <box inválido>', DBox)
                lenLDH  = lDHOR*len(Text)
                txtLn   = lDVER+Text+lDVER
                prevColor = GetColor()
                SetConsoleColor(Color)
                #-- Verificación argumento caja --#
                if (box == DBox):
                        print lDESI+lenLDH+lDESD+line+txtLn+line+lDEII+lenLDH+lDEID
                        SetConsoleColor(prevColor)
                        if (Sound == 1): sys.stdout.write(chr(7))
                        if (Stop == 1): raw_input()
                elif (box == DDBox):
                        print lDESI+lenLDH+lDLTA+line+txtLn+line+lDEII+lenLDH+lDLTB
                        SetConsoleColor(prevColor)
                        if (Sound == 1): sys.stdout.write(chr(7))
                        if (Stop == 1): raw_input()
                elif (box == DIBox):
                        print lDLTA+lenLDH+lDESD+line+txtLn+line+lDLTB+lenLDH+lDEID
                        SetConsoleColor(prevColor)
                        if (Sound == 1): sys.stdout.write(chr(7))
                        if (Stop == 1): raw_input()
                elif (box == D1Box):
                        print lDHOR+lenLDH+lDHOR+line+Texto+line+lDHOR+lenLDH+lDHOR
                        SetConsoleColor(prevColor)
                        if (Sound == 1): sys.stdout.write(chr(7))
                        if (Stop == 1): raw_input()
                elif (box == D2Box):
                        print lDVER+(blank*len(Texto))+lDVER+line+lDVER+Texto+lDVER+line+lDVER+(blank*len(Texto))+lDVER;
                        SetConsoleColor(prevColor);
                        if (Sound == 1): sys.stdout.write(chr(7));
                        if (Stop == 1): raw_input();