Metadata-Version: 2.4
Name: visor_vari
Version: 3.0
Summary: Permite la visualización de grandes conjuntos de datos en sistemas (software) complejos
Home-page: https://github.com/Jesu-super-galactico/visor-vari
Author: El señor es el único eterno. Que la ciencia lo honre a Él
Author-email: from.colombia.to.all@gmail.com
Classifier: Programming Language :: Python :: 3
Classifier: License :: OSI Approved :: Mozilla Public License 2.0 (MPL 2.0)
Classifier: Operating System :: OS Independent
Classifier: Development Status :: 5 - Production/Stable
Classifier: Intended Audience :: Developers
Classifier: Topic :: Software Development :: Debuggers
Requires-Python: >=3.6
Description-Content-Type: text/markdown
License-File: LICENSE.txt
Dynamic: author
Dynamic: author-email
Dynamic: classifier
Dynamic: description
Dynamic: description-content-type
Dynamic: home-page
Dynamic: license-file
Dynamic: requires-python
Dynamic: summary


# visor_vari

**Librería que Permite la visualización de grandes conjuntos de datos en sistemas**

`visor_vari` es una herramienta de debugging que permite monitorear el estado de las variables durante la ejecución de un programa Python, ofreciendo una alternativa visual y organizada. Pero ademas de ser una herramienta de debugging, es una herramienta de apoyo, en el desarrollo de sistemas de software.

## Actualización

Versión: 3.0 octubre de 2026. 
(Se reorganizaron las importaciones de los... refer_x, 
el gentil, encadena, faseypulso, ultimate, borratodo, guia 
dentro de 'ayudandome'. 

Opto por pasar a la versión 3 por nueva librería incorporada al paquete. 
Esta libreria se incluye dentro del paquete 'visor_vari'. Es llamada 
'comparando' y ejecuta operaciones sobre celdas guardadas. 
Esta nueva libreria 'comparando', la creo por dos motivos: 
1. En respuesta a la nueva forma de programar pretendida y 
promovida por el modelo de inteligencia artificial llamado JEV. 
El cual trata la programacion, en el orden de las probabilidades. 
2. Porque con esto, puedo crear desde el principio, en el diseño 
del sofware, un "primer estado" e ir avanzando en el programa, 
haciendolo cambiar o evolucionar "segun las siguientes fases 
a la que se puede enfrentar dicho programa". 
Con esto se pasa de tratar el sofware como un sistema a ser tratado 
como un flujo, de un conjunto de datos 
que va cambiando (moviendose o fluyendo). 
Para ser mas preciso, me refiero a que la programacion se puede ver como 
cambios en una "estructura de datos". Lo cual, a mi parecer, 
esta mas en sintonia con la "programacion orientada a IA", 
con una programacion que utiliza flujogrmas y 
con posibles plataformas que representen nuevos mundos virtuales 
o metaversos. Puediendo ser el mismo "sistema" nuestro sistema, observador, 
de este dicho metaverso. Como un visor, 
que observa solo cosas puntuales desde las alturas.)

## Uso Básico

```python
from visor_vari.ayudandome.con_ import gentil, refer_0

# Asigna tus variables a las celdas del visor
a = 10
b = 15

refer_0.selda_0 = a
refer_0.selda_1 = b

# Visualiza los valores
gentil()

# Las variables pueden cambiar durante la ejecución
refer_0.selda_0 = 43

c = 17
refer_0.selda_41 = c

# Visualiza los nuevos valores
gentil()
```

## Características

- **81 celdas de almacenamiento**: selda_0 hasta selda_80 para monitorear múltiples variables. cada `refer_x` tiene esta cantidad de celdas
- **Seguimiento en tiempo real**: Detecta y muestra cambios en las variables durante la ejecución
- **Fácil integración**: Solo necesitas importar y usar

## Modos de Operación

1. **Modo simple** : Muestra variables una a una. La funcion 'gentil' puede recibir como argumento 'pausado'. pausado esta por defecto en= True
```python
gentil()
```

2. **Modo encadena** : Solo muestra los numeros que coinciden con `encadena`.
Para la 'lista'... cada 'gentil' tiene una posicion (indice). comenzando desde cero.
```python
encadena(n, lista, pausado)
gentil(n)
```

3. **Modo fase y pulso** : No los primeros (profundidad), sino los indicados en las listas de los diccionarios dentro de 'lista' [ {0: [n_numeros]}, {1: [n_numeros]} ...] las llaves (de los diccionarios) representan las veces que el flujo entra (olas). 
Pausado en False es innecesario si el primer argumento que se pasa a 'faseypulso' es: False, este primer argumento se llama 'bajada'. Por otro lado, `ultimate` es necesario para que la libreria identifique las olas en este modo (fase y pulso).
```python
faseypulso(True, lista, pausado)
gentil(n)
ultimate()
```

4. **nota adicional** : como puede notar... en los dos ultimos modos, pausado es controlado directamente desde las definiciones, previas, `encadena` y `faseypulso`. por lo que en 'gentil' solo ingresa el numero.

## Ejemplo Completo

Puede copiar el siguiente codigo para que usted mismo haga la prueba de este ejemplo.

```python
""" Comprobando el funcionamiento de la libreria visor_vari
    version 3.0 """


"==================================="

from visor_vari.ayudandome.con_ import gentil, encadena, faseypulso, ultimate
from visor_vari.ayudandome.con_ import refer_0

"==================================="

class Numeros:
    def __init__(self):
        self.valor_x= 0
        self.valor_y= 20

abaco= Numeros()

def suma_valores():
    suma= abaco.valor_x + abaco.valor_y
    
    refer_0.selda_0= abaco.valor_x
    refer_0.selda_1= abaco.valor_y
    refer_0.selda_2= suma
    
    abaco.valor_x += 1
    
    return suma

"==================================="

"""# agrega el carapter numeral (#) al comienzo de esta linea para activar el bloque de codigo.
suma_valores()
gentil()
suma_valores()
gentil()
suma_valores()
gentil()
suma_valores()
gentil()

ultimate() # no trabaja qui, ya que solo lo hace en faseypulso.
#"""

"==================================="

#""" suprime o elimina el carapter numeral (#) al comienzo de esta linea para desactivar el bloque de codigo.
suma_valores() # para que empiece a sumar desde 1 (abaco.valor_x o refer_0.selda_0).
listando_los_gentiles_que_quiero_ver= [0, 2]
encadena(2)

suma_valores()
gentil(0)
suma_valores()
gentil(1)
suma_valores()
gentil(2)
suma_valores()
gentil(1)
suma_valores()
gentil(2)
suma_valores()
gentil(1)
suma_valores()
gentil(2)

ultimate() # no trabaja qui, ya que solo lo hace en faseypulso.
#"""

"==================================="

"""

lista_1= []
lista_2= [0, 1]
lista_3= [0, 1]

tu= 0
listando_los_gentiles_que_quiero_ver= [{0: lista_1}, {1: lista_2}, {2: lista_3}]
faseypulso(True, listando_los_gentiles_que_quiero_ver)
suma_valores() # para que empiece a sumar desde 1 (abaco.valor_x o refer_0.selda_0).

while tu < 7:
    
    print("Ciclo numero: ", tu)
    
    suma_valores()
    gentil(0)
    suma_valores()
    gentil(1)
    suma_valores()
    gentil(2)
    gentil(1)
    suma_valores()
    gentil(3)
    suma_valores()
    gentil(4)
    gentil(3)
    suma_valores()
    gentil(2)
    suma_valores()
    gentil(6)

    ultimate()
    tu += 1
#"""

print("fin de la prueva")
```

## Requisitos

- Python 3.6+
- tkinter (incluido con Python)

## Licencia

Licencia pública de Mozilla versión 2.0

## Codigo fuente en github

https://github.com/Jesu-super-galactico/visor-vari

## Documentación Adicional

Para más información sobre los modos de visualización, consulta:

```python
from visor_vari.readme_visor import readme
from visor_vari.readme_visor import readme_tipos
from visor_vari.readme_visor import readme_comparando
```
