Departamento de Ingeniería de Sistemas y Computación

Estructuras de Datos y Algoritmos

ISIS-1225, 2023-20

LABORATORIO 1: CONFIGURANDO EL
AMBIENTE DE DESARROLLO
(VS CODE + GITHUB + PYTHON)

Contenido
1 Objetivo ................................................................................................................................................. 2
2 Fecha de Entrega ................................................................................................................................... 2
3 Preparación ............................................................................................................................................ 2
3.1 Instalar VS Code ............................................................................................................................. 2
3.2 Personalizar el IDE ......................................................................................................................... 3
3.3 Instalar GIT ..................................................................................................................................... 5
3.4 Registrarse en GitHub .................................................................................................................... 5
3.5 Integrar VS Code y GitHub ............................................................................................................. 6
4 Trabajo propuesto ................................................................................................................................. 6
4.1 Crear una organización de trabajo ................................................................................................ 6
4.2 Bifurcar un proyecto en la organización ........................................................................................ 9
4.3 Cambiar la visibilidad de un repositorio ......................................................................................12
4.4 Descargar un proyecto en el computador ...................................................................................13
4.5 Examinar el proyecto con VS Code ..............................................................................................14
4.6 Modificar README del repositorio ..............................................................................................17
4.7 Modificar el código del repositorio .............................................................................................18
4.8 Utilizar Extensiones para inspeccionar código (Debugger) .........................................................20
5 Entrega .................................................................................................................................................22
5.1 Confirmar cambios finales ...........................................................................................................22
5.2 Compartir entregables con los evaluadores ................................................................................22
ANEXO: Solución de la practica ...................................................................................................................24
Cambios para el model.py .......................................................................................................................24
Cambios para el controller.py..................................................................................................................24
Cambios para el view.py ..........................................................................................................................24
1 Objetivo
Configurar un ambiente de trabajo útil para completar los laboratorios, prácticas y retos del curso de
Estructuras de Datos y Algoritmos, teniendo en cuenta los requerimientos de trabajo en equipo.

Al finalizar este laboratorio el estudiante estará en capacidad de:

1) Utilizar VS Code como Entorno de Desarrollo Integrado (IDE) para Python.

2) Entender los conceptos y aspectos generales de un ambiente de trabajo distribuido (Repositorio
GIT, IDE VS Code, Python 3.7 o superior).
3) Administrar las versiones y ramas de código en un repositorio GIT (GitHub).
4) Administrar un depósito de versiones GIT por medio de la consola y línea de comandos.
5) Comprender la organización de una aplicación siguiendo el esquema Modelo–Vista–Controlador
(MVC por sus siglas en inglés).
6) Utilizar herramientas de inspección de código (debugger) dentro de VS Code.
7) Ampliar las capacidades de VS Code al instalar y utilizar extensiones (Plug-In) o adiciones
(Extensions) dentro del ambiente.

2 Fecha de Entrega
Recuerde que durante la sesión de laboratorio todos los miembros del grupo deben completar hasta la
sección 4.6 Modificar README del repositorio

La entrega final de toda la práctica es antes del martes 15 de agosto, 11:59 p.m.

3 Preparación
3.1 Instalar VS Code
Para este curso se utilizará como entorno de IDE la herramienta Visual Studio Code (VS Code). Para
ayudarles a instalar este IDE en sus equipos, se prepararon los siguientes recursos del curso:

a. Video Uniandes para instalar y configurar VS Code titulado Como Instalar VS Code
b. Video Uniandes para instalar Python en MacOS titulado Como instalar Python 3 en MacOS
c. Video Uniandes para Instalar Python en Windows titulado Como instalar Python 3 en Windows

Después de examinar el material complete los siguientes pasos (p):

p.1. Después de ver los videos relevantes, instale Python 3.7 o superior como lenguaje de
programación global en su sistema operativo desde la página Python.Org

pg. 2
 p.2. Compruebe que instalo correctamente Python escribiendo los siguientes comandos por consola
CMD (Terminal en MacOS y Linux) “python --version” y “pip --version” como se ve en
la Ilustración 1.

IMPORTANTE: se recomienda desinstalar otras distribuciones de Python y otros administradores librerías

como Anaconda para evitar problemas al integrar todas las herramientas.

Ilustración 1. Comandos para comprobar la correcta instalación global de Python.

3.2 Personalizar el IDE

Después de instalar VS Code en el computador, su funcionamiento puede extenderse para desarrollar
código Python con diferentes adiciones o extensiones del IDE.

Para aprender a integrar estas herramientas se ha dispuesto del siguiente recurso del curso:

a. Video Uniandes con las instrucciones generales para instalar la extensión de GitHub y conectarlo
con VS Code titulado Como instalar in Plug-in en VS Code

Para instalar las extensiones (Extensions) en su VS Code complete los siguientes pasos (p):

p.3. Diríjase al icono de extensiones en el menú vertical izquierdo – ver Ilustración 2.

p.4. Como muestra la Ilustración 2 escriba el nombre de la extensión en la barra de búsqueda. En este
caso busque el Plug-In con el nombre de “GitHub Pull Requests and Issues”
p.5. Elija la opción de instalar dentro de la página de descarga de la extensión como lo muestra la
Ilustración 2.
p.6. Según sea el caso reinicie VS Code para completar la configuración de la extensión.
p.7. Repita los pasos anteriores para todas las extensiones que desee integrar a su IDE.

Considere que las siguientes extensiones (Extensions) o adiciones (Plug-In) del IDE son fundamentales
para el desarrollo de los laboratorios y retos.

a. El paquete de extensión para el desarrollo en Python por Don Jayamanne en Python Extension
Pack el cual incluye:
i. Generador automático de documentación en código por Nils Werner en autoDocstring -
Python Docstring Generator
ii. Soporte con IntelliSense (Pylance) para desarrollo de código por Microsoft en Python
iii. Generador de esqueletos de código Jinja por wholroyd en Jinja for VS Code

pg. 3
 iv. Soporte para Framework Django por Baptiste Darthenay en Django
v. Soporte para desarrollo de código IntelliCode por Microsoft en Visual Studio IntelliCode
vi. Identador automático para Python por Kevin Rose en Python Indent
b. Extensión para crear sentencias de importación dentro de código Python por Mathias Gesbert en
Python Path
c. Extensión para administrar archivos gitignore de GIT por CodeZombie en gitignore Extension
for VS Code
d. Extensión para integrar GitHub y VS Code por GitHub en GitHub Pull Requests and Issues
e. Extensión para visualizar el historial de GitHub en VS Code por mhutchie en Git Graph
f. Extensión para abrir archivos CSV desde VS Code por janisdd en Edit csv
g. Marcador de tareas pendientes dentro del código por Gruntfuggly en TODO Tree
h. Monitor de recursos para VS Code por mutantdino en Resource Monitor
i. Visualizador de datos para archivos CSV por Microsoft DevLabs en SandDance for VSCode
j. Visualizador de PDF para VS Code por tomoki1207 en vscode-pdf

p.4

p.5
p.3

Ilustración 2. Ejemplo para instalar una extensión en VS Code.

Otras extensiones pueden instalarse para personalizar y ampliar el uso de Python con código interactivo
(Notebooks) de Jupyter. Algunas de estas opciones son:

a. El paquete de extensión para el desarrollo código interactivo (Notebook) en Python por Microsoft
en Jupyter (este incluye 4 extensiones más).
b. Visualizador de archivos Markdown por Yiyi Wang en Markdown Preview Enhanced
c. Tema de colores personalizable por Andrey Volosovich en Monokai ST3
d. Tema de colores personalizable por Unintended Side Effects en Adventurous Syntax Black

pg. 4
3.3 Instalar GIT
De igual forma, para el curso se utilizará el Sistema de Control de Versiones GIT y el administrador de
repositorios en línea GitHub.

Se prepararon los siguientes recursos del curso para ayudarles a instalar GIT en sus equipos:

a. Video Uniandes para instalar GIT en Windows titulado Como instalar GIT en Windows
b. Video Uniandes para registrar GitHub e instalar GIT en MacOS titulado Como instalar GIT en
MacOS

Después de examinar el material complete los siguientes pasos (p):

p.8. Después de ver el video indicado, instale GIT 2.39 o superior como aplicación global desde la
página git-scm.com
p.9. Compruebe que instaló correctamente GIT escribiendo los siguientes comandos por consola CMD
(Terminal en MacOS y Linux) “git --version” y “git --help” como se ve en la Ilustración
3.

Ilustración 3. Comandos para comprobar la correcta instalación global de GIT.

3.4 Registrarse en GitHub

GitHub es un servicio en la nube que permite administrar un proyecto de software, bien sea trabajando
grupal o individualmente. En este curso publicaremos los laboratorios, esqueletos de los proyectos,
ejercicios de practica y soluciones destacadas de los retos en la organización EDA Uniandes DISC

Para continuar debe tener una cuenta en GitHub. Para ello complete los siguientes pasos:

p.10. Diríjase a la página oficial para unirse a la plataforma en join

p.11. Registre su correo Uniandes como cuenta principal para el servicio de GitHub1.
p.12. Siga los pasos del portal para registrarse.

1En caso de tener un perfil, agregue su cuenta Uniandes al perfil de GitHub y selecciónela como cuenta principal de
registro.
pg. 5
 p.13. Complete su perfil de GitHub.

Adicionalmente preparamos el siguiente contenido para mostrar la importancia de GitHub en la clase:

a. Video Uniandes sobre el paquete estudiantil de GitHub titulado Paquete Educativo de GitHub

3.5 Integrar VS Code y GitHub

Ahora que tenemos instalado GIT, VS Code y estamos registrados en GitHub podemos trabajar con estas
tres herramientas. Una de las formas más sencillas para integrar VS Code con GitHub es mediante la
extensión GitHub Pull Requests and Issues

Ahora, complete los siguientes pasos para integrar ambas herramientas:

p.14. Habilite GIT en VS Code como lo muestra en el video.

p.15. Ingrese sus credenciales GitHub en el perfil de VS Code por medio del icono de usuario en la parte
inferior del menú vertical izquierdo del IDE como se muestra en Ilustración 4.
p.16. Confirme sus datos y autorice a VS Code para acceder a GitHub2.

p.15

Ilustración 4. Perfil de GitHub acreditado visto desde VS Code.

IMPORTANTE: Para mejorar en el uso de todas las herramientas recomendamos ver el contenido
complementario de Pills EDA en nuestra sección unificada.

4 Trabajo propuesto
4.1 Crear una organización de trabajo

2 En caso de que la extensión de GitHub no funcione desde VS Code instale GitHub Desktop como alternativa.
pg. 6
GitHub permite crear organizaciones con el objetivo de agrupar repositorios de código relacionados entre
sí. Una vez creen sus usuarios de GitHub deberán crear una nueva organización para trabajar con sus
compañeros del curso.

Para este proceso solo UNO de los integrantes del grupo deberá crear esta organización. Para ello
examine el siguiente recurso audiovisual:

a. Video Uniandes para crear una organización en GitHub titulada Como crear equipos en GitHub

A continuación, complete el proceso siguiendo las siguientes instrucciones:

p.17. Cree la organización del grupo de trabajo utilizando el formato EDA-202320-SEC<<XX>>-G<<YY>>,

donde: <<XX>> es el número de la sección y <<YY>> el numero asignado del grupo (Ej.: EDA-
202320-SEC05-G03 para el tercer grupo de la sección 5 del curso).
p.18. Invite a sus otros compañeros utilizando el correo Uniandes con la opción para invitar a un
miembro (invite member) en la pestaña de personas (People) como se ve en Ilustración 5.
p.19. Configure un nuevo grupo de desarrollo en la pestaña de equipo de trabajo (Team) con el nombre
“Equipo EDA” como se ve en la Ilustración 6.
p.20. Configure el perfil de sus compañeros como propietario (Owner) de la organización después de
que ellos acepten la invitación como se ve en Ilustración 7.
p.21. Invite a los evaluadores, esto incluye al profesor de la sección, al profesor de laboratorio y a los
dos monitores asignados.

p.18
p.18

Ilustración 5. Pestaña de personas (People) para una organización.

pg. 7
 p.19

p.19

Ilustración 6. Pestaña de equipos (Teams) para una organización.

p.20

pg. 8
 p.20

Ilustración 7. Pestaña de personas (People) y configuración de roles para los miembros de una organización.

IMPORTANTE: NO borre o edite los repositorios después de su entrega oficial porque esto afecta el
proceso de calificación de los monitores.

4.2 Bifurcar un proyecto en su organización

Se le llama Fork/Bifurcar al proceso de copiar un repositorio existente como plantilla de trabajo
independiente para uno nuevo. El repositorio para el primer laboratorio es SampleMVC.

Normalmente un Fork realizado a un repositorio público por defecto también es público; este proceso es
automático y puede consultar como realizarlo en el siguiente recurso:

a. Video Uniandes para Copiar/Fork repositorios GitHub público titulado Como hacer Fork público
de un repositorio GIT

Sin embargo, para crear un Fork privado desde un repositorio público se necesita completar un proceso
manual. Para ello complete las siguientes instrucciones:

p.22. Abra al enlace de SampleMVC.

p.23. Seleccione el botón verde de Código (Code) en la página del repositorio como se señala en la
Ilustración 8.
p.24. Copie el URL que aparece en la pestaña señalada en la Ilustración 8.

pg. 9
 p.23

p.24

Ilustración 8. Portal GitHub para Bifurcar/Fork un repositorio público a privado.

p.25. Vuelva a la organización del grupo de trabajo.

p.26. Seleccione el botón verde de Nuevo (New) en la página principal de la organización para crear un
nuevo repositorio como se muestra en Ilustración 9.

p.26

Ilustración 9. Como crear un nuevo repositorio desde la organización en GitHub.

Este proceso lo dirigirá a una nueva ventana para continuar con el proceso.

p.27. Seleccione la opción Importar repositorio (Import a repository) como en la Ilustración 10.

p.27

Ilustración 10. Como seleccionar la opción para importar manualmente un repositorio en GitHub.

p.28. Complete los campos indicados por GitHub como se muestra en Ilustración 11.
a. Seleccione el propietario del repositorio, que en este caso el nombre de la organización.
b. Complete el nombre del repositorio objetivo, que en este caso será “DEMO-EDA-SampleMVC”.
c. Configure la Privacidad (Privacy) del repositorio objetivo a pública.
pg. 10
 p.29. Presione el botón de Iniciar Importación (Begin Import) según la Ilustración 11 para iniciar el
proceso.

p.28, a

p.28, b

p.28, c

p.29

Ilustración 11. Indicaciones para configurar manualmente el Fork de un repositorio en GitHub.

Antes de clonar el repositorio en su computador cambie el nombre. Para ello, diríjase a su organización
(Ej.: EDA-202310-SEC05-G03) y complete las siguientes instrucciones:

p.30. Abra el repositorio que bifurcó.

p.31. Seleccione la pestaña de Ajustes (Settings) del repositorio como lo muestra la Ilustración 12.

p.31

Ilustración 12. Ejemplo de donde está la pestaña de Ajustes/Settings en un repositorio de GitHub

Ahora, cada integrante del grupo debe completar los siguientes pasos:

p.32. Cambie el nombre del repositorio según el esquema LabMVC-L<<XX>>-G<<YY>>-<<ZZ>> donde

XX es el numero de la semana de la práctica que se está haciendo, YY el número del grupo de
trabajo y ZZ es el usuario Uniandes de uno de los integrantes del grupo. Un ejemplo de esto es

pg. 11
 LabMVC-L01-G01-j.perez123 para este primer laboratorio del grupo 1 hecho por el estudiante
Juan Perez como se ve en la Ilustración 13.
p.33. Confirme los cambios seleccionando la opción de Renombrar (Rename) de la Ilustración 13.

p.33

p.32

Ilustración 13. Ejemplo de cómo renombrar un repositorio existente en GitHub.

IMPORTANTE: NO necesita agregar la sección o el semestre en este nombre porque ya está identificado
en su organización.

4.3 Cambiar la visibilidad de un repositorio

Ahora, al final de la misma página de Ajustes (Settings) del repositorio asegúrese de que la Visibilidad
(Visibility) de este sea Privada (Private).

Para ello, cada estudiante debe completar las siguientes indicaciones:

p.34. Seleccione la opción para Cambiar visibilidad (Change visibility) de la Ilustración 14.
p.35. Seleccione en la ventana emergente la opción de Hacer privado (Make private) el repositorio
de la Ilustración 15
p.36. Confirme los cambios diligenciando el texto requerido por GitHub señalado en la Ilustración 15.

pg. 12
 p.34

Ilustración 14. Detalles de los campos para cambiar la visibilidad de un repositorio GitHub.

p.35

p.36

Ilustración 15. Ventana emergente para cambiar la visibilidad de un repositorio GitHub.

IMPORTANTE: Todos los repositorios de trabajo durante el semestre deben ser privados, ya que este es
un trabajo propio e intransferible de los grupos.

4.4 Descargar un proyecto en el computador

GitHub guarda en la nube el código que vamos desarrollando para no perder el trabajo. Esto permite que
todos los desarrolladores tengan acceso al código y maneja una bitácora de cambios (versiones).

pg. 13
Sin embargo, para desarrollar software necesitamos tener el proyecto en nuestras máquinas y no en la
nube. Para ello debemos copiar el proyecto desde GitHub a un espacio en nuestros computadores.

A esta operación la llamamos clonar (clone) un proyecto. Y el resultado es que la máquina/computador

de cada miembro del grupo posee una copia local del proyecto para trabajar de forma independiente.
Esta copia estará conectada al proyecto en GitHub, y de esta forma los desarrolladores pueden saber que
cambios se han realizado al código.

Ahora, cada integrante del grupo debe completar los siguientes pasos. Para aprender a clonar un proyecto
sigas las instrucciones del siguiente video dispuesto por el equipo del curso:

a. Video Uniandes de como clonar un proyecto de GitHub desde VS Code titulado Como clonar un
repositorio GIT

Ahora, repita los pasos utilizando el enlace del repositorio privado de la organización creado a partir del
ISIS1225-SampleMVC.

p.37. Ingrese al portal GitHub de su organización.

p.38. Diríjase al repositorio del primer laboratorio.
p.39. Copie el URL GIT del repositorio.
p.40. Diríjase a VS Code.
p.41. Inicie el comando Clonar (Clone) desde la paleta de comandos.
p.42. Pegue el URL en el campo despegado
p.43. Seleccione un lugar apropiado en su directorio local para guardar los archivos del proyecto.
p.44. Espere a que descarguen los archivos y comience a trabajar3.

IMPORTANTE: aunque los repositorios y sus archivos dentro de una organización son compartidos, en
este laboratorio se espera que cada miembro del grupo bifurque (fork) y clone (clone) el repositorio
individualmente para familiarizarse con el proceso.

4.5 Examinar el proyecto con VS Code

El proyecto Sample-MVC busca familiarizarlos con el editor VS Code y mostrar los elementos que se
usarán durante el curso. Una vez clonado el proyecto, cada estudiante deberá examinar su contenido en
VS Code para entender su estructura.

Como se ve en la Ilustración 16 el directorio App, contiene tres archivos llamados view.py,

controller.py y model.py. Este esquema de trabajo busca organizar claramente el código en tres
distintas partes, llamadas Modelo, Vista y Controlador (MVC). Este patrón es muy conocido y utilizado en
muchas de las aplicaciones Web y móviles que utilizamos hoy en día.

3Este proceso puede completarse por diferentes medios, utilizando la terminal/consola de Windows o MacOS, y
también utilizando aplicaciones independientes como GitHub Desktop y Sourcetree
pg. 14
Primero, la Vista (view.py) contiene todos los recursos para que el programa interactúe con el ambiente.
Esto incluye la captura y despliegue de información al usuario. Se usa para facilitar actualizaciones y
cambios a la forma de representar las respuestas y no tiene ninguna incidencia en las estructuras de datos.

Segundo, el Modelo (model.py) procesa y contiene los datos en memoria principal. Aquí se implementan
todas las operaciones del programa, como las funciones de comparación, acceso a los datos, otras
funciones y la implementación a los requerimientos de los retos. Para evitar confusiones y errores con
cómo se representan los datos, el modelo no tiene contacto directo con la vista.

Finalmente, el controlador (controller.py) se utiliza para comunicar la vista con el modelo y mantener
su independencia. Al revisar el código del laboratorio, se dará cuenta que la única función del archivo
view.py es interactuar con el usuario y comunicar todas las operaciones del usuario al controlador. Este
a su vez reenvía la información al modelo para ejecutar las funciones necesarias.

Ahora, al inspeccionar el controller.py encontrará que este se encarga de leer los archivos de datos
e invoca las operaciones del modelo (model.py) con las funciones loadBooks() y loadTags().

pg. 15
 Ilustración 16. Estructura (Python Path) del repositorio para el primer laboratorio.

Adicionalmente, al revisar el código del modelo (model.py) observará que contiene los modelos usados
para solucionar los requerimientos; es decir, en el model.py están todos los datos que usaremos en
nuestros programas.

Finalmente, como se ve en la Ilustración 16 el proyecto también contiene un directorio denominado Data,

el cuál inicialmente se encuentra vacío.

Ahora, para ejecutar correctamente el laboratorio complete los siguientes pasos:

p.45. Acceda a la página unificada en Bloque Neón.

p.46. Diríjase al contenido del curso en laboratorios/datos de entrenamiento.
p.47. Descargue el archivo del caso de estudio (GoodReads).
p.48. Descomprima el archivo GoodReads.zip.
p.49. Copie los archivos en el directorio */Data/GoodReads como lo indica Ilustración 17.
p.50. Ejecute el proyecto presionando el icono de Play en VS Code (Ilustración 17).

pg. 16
 p.51. Seleccione las opciones del menú para cargar libros (1) y tags (2) según la Ilustración 17.

p.50

p.49

p.51

Ilustración 17. VS Code con el view.py del primer laboratorio.

Los tres archivos del proyecto deben ser: proyecto maneja tres archivos:

• Books.csv: Este archivo contiene toda la información de los libros, tales como autor, ISBN,
fecha de publicación e idioma entre otros.
• Tags.csv: Este archivo contiene todas etiquetas que se pueden poner a un libro, como por
ejemplo el tipo de obra, es decir si es de ficción, ciencia o suspenso.
• Book_tags.csv: Este archivo tiene el identificador de un libro y el identificador de un tag, para
indicar que ese libro fue etiquetado con ese tag por un usuario.

4.6 Modificar README del repositorio

Para registrar los cambios realizados al repositorio, debe confirmarlos localmente (Commit) y empujarlos
(Push) al servidor GitHub. Para aprender cómo hacerlo se ha dispuesto del siguiente video:

a. Video Uniandes titulado Como administrar desarrollo de codigo desde VS Code

Ahora edite README.md dentro del proyecto siguiendo las siguientes instrucciones:

p.52. Abra al archivo README del laboratorio 1.

p.53. Cambie los nombres de los integrantes del grupo e incluya los nombres completos, correos
Uniandes y códigos de estudiantes de cada uno en la sección de integrantes.

pg. 17
 p.54. Ejecute un Commit en el repositorio con el comentario “Cambios README laboratorio 1” (git
commit -m “Cambios README laboratorio 1”).
p.55. Ejecute un Push de los cambios del repositorio hacia GitHub.
p.56. Confirme los cambios accediendo el portal web del repositorio en GitHub.

4.7 Modificar el código del repositorio

Dado que el proyecto lee dos de los tres archivos del ejemplo, el de libros (Books.csv) y el de tags
(Tags.csv), se requiere que ustedes modifiquen el proyecto para que en el menú de opciones aparezca
una tercera opción para cargar el archivo llamado book_tags.csv.

Ahora complete las siguientes instrucciones:

p.57. Busque el comentario “# TODO: Modificaciones lab 1…” dentro del modelo.
p.58. Examine el código relacionado a este comentario.
p.59. Modifique el código como crea pertinente.
p.60. Confirme (Commit) los cambios en su máquina local utilizando el mensaje “modificaciones
individuales laboratorio 1.”
p.61. Envie (Push) los cambios al repositorio remoto.
p.62. Repita del paso p.57 al p.61 para todos los #TODO dentro del MVC laboratorio.

Recuerde que puede ver un resumen e ir al código de todos los #TODO en el menú izquierdo vertical con
la extensión TODO Tree como se ve en la Ilustración 18.

Ilustración 18. Lista de comentarios para las modificaciones del SampleMVC con TODO Tree.

Primero, Las modificaciones propuestas para el #TODO del model.py son las siguientes:
def addBookTags(catalog, booktagsfile):
"""
Esta funcion crea una lista basada en el archivo de booktags. siga
el mismo procedimiento que la funcion addBooks.
"""

pg. 18
 # TODO: Mods lab 1, completar funcion.
book_tags = catalog.get("Book_tags")
book_tags = lt.newList(datastructure="SINGLE_LINKED",
filename=booktagsfile)
catalog.update({"Book_tags": book_tags})
return catalog

Segundo, las modificaciones propuestas para el #TODO del controller.py son las siguientes:
def loadBooksTags(control, filename):
# TODO: Mods lab 1, integración controlador y modelo
"""
Carga los tags de los libros del archivo y los agrega a la lista
de tags. Siga el mismo procedimiento que en la carga de libros.
"""
catalog = control.get("model")
booksfile = os.path.join(cf.data_dir, filename)
catalog = model.addBookTags(catalog, booksfile)
if model.emptyBookTags(catalog):
return None
else:
return model.bookTagSize(catalog)
Tercero, las modificaciones para el primer #TODO del view.py son:
def printMenu():
print("Opciones:")
print("1- Cargar Libros")
print("2- Cargar Tags")
# TODO: Mods lab 1, agregar opcion 3.
print("3- Cargar Libros con Tags")
print("0- Salir")
Por último, las modificaciones propuestas para el segundo #TODO del view.py son:
# TODO: Mods lab 1, agregar la opcion 3 -> ladBookTags().
elif int(inputs[0]) == 3:
print("Cargando información de libros con tags…")
book_tags = loadBooksTags(control)
print("Total de libros con tags cargados: " + str(book_tags))
Al finalizar las modificaciones la consola mostrará un resultado al ejecutar la tercera opción como lo
muestra la Ilustración 19.

pg. 19
 Ilustración 19. Respuesta esperada para la opción 3.

Sin embargo, este resultado (ver Ilustración 19) no es el que aparece en la consola ya que aparece None
como total de libros con tags cargados y no 999. Por lo tanto, concluimos que existen errores en las
modificaciones con comportamientos no indeseados.

4.8 Utilizar Extensiones para inspeccionar código (Debugger)

Ahora que sabemos modificar código dentro de un proyecto y sabemos que existen errores. Ahora,
necesitamos examinar su comportamiento. Esta actividad se le conoce como probar (Debugger) un
software.

Para aprender en detalle sobre este proceso hemos dispuesto el siguiente contenido:

a. Video Uniandes para aprender a probar código titulado ¿Cómo hacer debug en Visual Studio
Code?

Ahora diríjase a su laboratorio y dentro del Modelo (model.py) complete los siguientes pasos:

p.64. Marque como punto de inspección (Checkpoint) la línea 99 del código en el modelo como se
muestra en la Ilustración 20.
p.65. Ejecute el laboratorio desde el view.py utilizando el Debugger según Ilustración 20.
p.66. Seleccione la opción 1 del menú por consola, aquí notará que el programa se comporta como
lo haría en una ejecución normal.
p.67. Ahora ejecute la opción 2, en este caso el comportamiento cambia y se observa algo como se
ve en la Ilustración 21. Donde la herramienta de inspección muestra el estado de las variables
globales, locales y da la opción de avanzar o retroceder hasta el siguiente Checkpoint.
p.68. Pruebe sus cambios hechos al código del Modelo para confirmar su correcto comportamiento.
p.69. Modifique el código fuente de ser necesario y confirme (Commit y Push) los cambios con el
comentario “modificaciones por debug lab 1”.
p.70. De ser necesario repita este procedimiento en los cambios del Controlador y la Vista.

pg. 20
Intente por usted mismo encontrar el error en las modificaciones basándose en lo observado durante la
sección 4.5 Examinar el proyecto con VS Code. Sin embargo, si lo desea diríjase al final del documento al
ANEXO: Solución de la practica para leer los detalles de una posible solución.

p.65

p.64

Ilustración 20. Ejemplo de cómo preparar un punto de inspección en la herramienta de pruebas de VS Code para Python.

pg. 21
 p.67

p.67

Ilustración 21. Ejemplo e como debe funcionar el punto de inspección al ejecutarse con la herramienta de pruebas VS Code.

5 Entrega
5.1 Confirmar cambios finales
Confirme los cambios finales siguiendo los pasos practicados en la sección 4.6 Modificar README del
repositorio con el comentario “Entrega Final – laboratorio 1” (git commit -m “Entrega Final –
laboratorio 1”)4

No olvide confirmar que sus cambios fueron registrados correctamente al repositorio remoto en GitHub.

Por último, cada uno de los integrantes del grupo debe diligenciar la encuesta para conformar los grupos
de trabajo en el formulario Microsoft Forms para inicio del semestre E informar al grupo EDA de quienes
son.

5.2 Compartir entregables con los evaluadores

4GIT y VS Code no permiten operaciones Commit/Push sin cambios en el código, puede forzar este comportamiento
modificando inconsecuentes para el software como lo son los comentarios y la documentación.
pg. 22
Finalmente, debe entregar el enlace (URL) del repositorio GitHub por de Bloque Neón en la actividad que
los profesores y monitores de su sección dispusieron para ello. Recuerde que para su entrega final debió
completar lo siguiente:

1) Invitar al profesor de laboratorio y los monitores de su sección a la organización del grupo.

2) Completar el Fork del repositorio base y tener una copia por cada uno de los miembros del grupo.
3) Incluir en el README de cada repositorio los datos completos de los integrantes del grupo
(nombre completo, correo Uniandes y código de estudiante).
4) Generar una versión en GitHub con el comentario “Entrega Final – laboratorio 1” (git commit
-m “Entrega Final – laboratorio 1”) antes de la fecha límite de entrega.
5) Enviar el enlace (URL) del repositorio por BrightSpace antes de la fecha límite de entrega.

Recuerden que cualquier documento solicitado durante en la práctica debe incluirse dentro del
repositorio GIT y que solo se calificara hasta el último COMMIT realizado antes de la media noche (11:59
PM) del martes 15 de agosto de 2023.

pg. 23
ANEXO: Solución de la practica
Las siguientes marcas #TODO poseen el código funcional para el laboratorio. El error está en que la llave
de diccionario “Book_tags” del en el model.py debe ser “book_tags”, todo en minúsculas

Modificaciones para el model.py

def addBookTags(catalog, booktagsfile):
"""
Esta funcion crea una lista basada en el archivo de booktags. siga
el mismo procedimiento que la funcion addBooks.
"""
# TODO: Mods lab 1, completar funcion.
book_tags = catalog.get("Book_tags")
book_tags = lt.newList(datastructure="SINGLE_LINKED",
filename=booktagsfile)
catalog.update({"Book_tags": book_tags})
return catalog

Modificaciones para el controller.py

def loadBooksTags(control, filename):
# TODO: Mods lab 1, integración controlador y modelo
"""
Carga los tags de los libros del archivo y los agrega a la lista
de tags. Siga el mismo procedimiento que en la carga de libros.
"""
catalog = control.get("model")
booksfile = os.path.join(cf.data_dir, filename)
catalog = model.addBookTags(catalog, booksfile)
if model.emptyBookTags(catalog):
return None
else:
return model.bookTagSize(catalog)

Modificaciones para el view.py

def printMenu():
print("Opciones:")
print("1- Cargar Libros")
print("2- Cargar Tags")
# TODO: Mods lab 1, agregar opcion 3.
print("3- Cargar Libros con Tags")
print("0- Salir")

# TODO: Mods lab 1, agregar la opcion 3 -> ladBookTags().

elif int(inputs[0]) == 3:
print("Cargando información de libros con tags…")
book_tags = loadBooksTags(control)
print("Total de libros con tags cargados: " + str(book_tags))

pg. 24