CShell v1 0:Interfaz interactiva con Python

Texto completo

(1)

(2) Hago constar que el presente Trabajo de Diploma ha sido realizado en la facultad de Matemática, Física y Computación de la Universidad Central Marta Abreu de Las Villas (UCLV) como parte de la culminación de los estudios de Licenciatura en Ciencia de la Computación, autorizando a que el mismo sea utilizado por la institución para los fines que estime conveniente, tanto de forma total como parcial y que además no podrá ser presentado en eventos ni publicado sin la previa autorización de la UCLV.. ______________________________ Firma del Autor. Los abajo firmantes, certificamos que el presente trabajo ha sido realizado según acuerdo de la dirección de nuestro centro y que el mismo cumple con los requisitos que debe tener un trabajo de esta envergadura referido a la temática señalada.. ________________________________. Firma del Tutor. ________________________________. Firma del Jefe del Seminario de Programación.

(3)

(4)

(5)

(6)

(7) Resumen En este trabajo se describe la implementación de CShell, una herramienta multiplataforma que permite presentar la historia de interacción con Python y documentación embebida como un documento, donde se tiene en cuenta la filosofía conocida como programación literada. Para el proceso de interacción se crea un mecanismo que permite ejecutar fragmentos de código Python, además de proveer al usuario de algunas facilidades que lo diferencian de los métodos tradicionales. En la construcción de la interfaz de usuario se utiliza wxPython como sistema de ventanas. También se hace un análisis de las características principales de una interfaz de usuario, así como de las principales herramientas existentes para la construcción de las mismas en Python..

(8) Abstract This work describes the implementation of CShell, a multiplatform tool for handling Python interaction history and embedded documentation, where some key features of the literate programming paradigm are taken into account. For the interaction process a mechanism which lets the user to execute Python fragments is created, besides supplying him with some facilities which makes this application distinct of more conventional precedents. For building the user interface wxPython is used. An analysis of the main characteristics of the user interface is done, together with a review of the principal tools for that in Python..

(9) INTRODUCCIÓN............................................................................................................. 1 CAPÍTULO 1: ELEMENTOS TEÓRICOS RELACIONADOS CON EL ENTORNO DE CSHELL................................................................................................. 4 1.1 PYTHON. BREVE RESEÑA. .................................................................................... 4 1.1.1 Proyectos desarrollados en Python. ------------------------------------------------6 1.2 INTERFAZ GRÁFICA DEL USUARIO......................................................................... 6 1.2.1 Características. ------------------------------------------------------------------------8 1.2.2 Funciones Generales.--------------------------------------------------------------- 10 1.3 CONSTRUYENDO INTERFACES VISUALES PARA PYTHON. .................................... 11 1.3.1 Tk. ------------------------------------------------------------------------------------ 11 1.3.2 Qt ------------------------------------------------------------------------------------- 11 1.3.3 GTK + -------------------------------------------------------------------------------- 12 1.3.4 WxPython. --------------------------------------------------------------------------- 13 1.3.5 Análisis de las bibliotecas de componentes visuales.---------------------------- 13 1.4 UTILIZACIÓN DE HERRAMIENTAS Y SOFTWARE LIBRE............................................... 16 1.5 CONCLUSIONES PARCIALES...................................................................................... 17 CAPÍTULO 2: DISEÑO E IMPLEMENTACIÓN DE CSHELL V.1.0 .................... 18 2.1 PRINCIPALES CONCEPTOS DE DISEÑO Y PROGRAMACIÓN ORIENTADA A OBJETOS...... 18 2.1.1 Conceptos Generales de la Programación Orientada a Objetos ----------------- 18 2.1.2 La metodología de análisis y diseño orientados a objetos ----------------------- 20 2.2 HERRAMIENTAS UTILIZADAS ................................................................................... 21 2.3.1 IDLE ------------------------------------------------------------------------------------ 21 2.3.3 WxPython. ----------------------------------------------------------------------------- 21 2.3 GENERALIDADES DE CSHELL. .................................................................................. 22 2.4 UNA FILOSOFÍA PRESENTE: PROGRAMACIÓN LITERADA ........................................... 24 2.5 CONSIDERACIONES PARA EL DISEÑO DEL SISTEMA. .................................................. 25 2.5.1 Necesidad de un control que permita el procesamiento de texto.--------------- 25 2.5.2 Necesidad de Interactuar. ------------------------------------------------------------ 26 2.6 CASOS DE USO DEL SISTEMA .................................................................................... 26 2.6.1 Principales Casos de Usos de CShell: ---------------------------------------------- 28 2.6.1.1 Gestionar Documentos .............................................................................. 28 2.6.1.1.1 Caso de Uso: Crear Documento ......................................................... 28 2.6.1.1.2 Caso de Uso: Salvar Documento........................................................ 29 2.6.1.1.3 Caso de uso: Salvar código fuente ..................................................... 30 2.6.1.1.4 Caso de Uso: Abrir documento. ......................................................... 30 2.6.1.1.5 Caso de Uso: Salvar historia ............................................................. 31 2.6.1.1.6 Casos de Uso: Salvar configuración................................................... 31 2.6.1.2 Configurar Aplicación............................................................................... 32 2.6.1.2.1 Caso de Uso: Mostrar Auto-Completamiento de Código ................. 32 2.6.1.2.2 Caso de Uso: Mostrar Call Tips ...................................................... 33 2.6.1.2.3 Caso de Uso: Insertar Call Tips . ..................................................... 33 2.6.1.2.4 Casos de Uso: Salvar historia automáticamente. ............................... 34 2.6.1.2.5 Caso de Uso: Salvar configuración automáticamente........................ 34.

(10) 2.6.1.3 Edición de Documento .............................................................................. 35 2.6.1.3.1 Caso de Uso: Cambiar Modo ............................................................. 35 2.6.1.3.2 Caso de Uso: Nueva Entrada.............................................................. 36 2.6.1.3.3 Ejecutar Entrada ................................................................................. 36 2.6.1.3.4 Cambiar contenido de las entradas..................................................... 36 2.6.1.3.5 Re - Ejecutar Entrada ......................................................................... 37 2.6.1.3.6 Eliminar Entrada ................................................................................ 37 2.7 CSHELL POR DENTRO. .............................................................................................. 38 2.7.1 Acciones realizadas por CShell ----------------------------------------------------- 38 2.7.1.1 Interacción con Python.............................................................................. 38 2.7.1.2 Gestión de ficheros.................................................................................... 39 2.7.1.2.1 Proceso de salvar código fuente. ........................................................ 39 2.7.1.2.2 Proceso de abrir fichero en CShell..................................................... 40 2.7.2 Implementación de CShell--------------------------------------------------------- 41 2.7.2.1 Diseño en tres capas .................................................................................. 41 2.7.2.2 Interfaz de usuario..................................................................................... 42 2.7.2.3 Extensión de un editor de texto. ................................................................ 43 2.7.3 Componentes de CShell. ------------------------------------------------------------- 44 2.8 CONCLUSIONES PARCIALES ...................................................................................... 45 CAPÍTULO 3: MANUAL DE USUARIO. ................................................................... 46 3.1 REQUISITOS PARA LA EXPLOTACIÓN DE CSHELL. ..................................................... 46 3.2 MODO DE TRABAJO. ................................................................................................. 47 3.2.1 Modo Edición-------------------------------------------------------------------------- 47 3.2.2 Modo Intérprete ----------------------------------------------------------------------- 48 3.2.2.1 Uso del auto-completamiento de Código .................................................. 49 3.2.2.2 Uso de Call Tips .................................................................................... 50 3.3 USO DE LA HISTORIA. ............................................................................................... 51 3.3.1 Remplazar de la Historia. ------------------------------------------------------------ 51 3.3.2 Insertar de la Historia----------------------------------------------------------------- 51 3.4 MENÚ PRINCIPAL Y BARRA DE HERRAMIENTAS....................................................... 51 3.4.1 Menú File ---------------------------------------------------------------------------- 52 3.4.2 Menú Edit --------------------------------------------------------------------------- 53 3.4.3 Menú Options : ---------------------------------------------------------------------- 57 3.4.4 Menú Action : ----------------------------------------------------------------------- 58 3.5 MENÚ DE CONTEXTO: .............................................................................................. 60 3.6 CONCLUSIONES PARCIALES:..................................................................................... 60 CONCLUSIONES........................................................................................................... 61 RECOMENDACIONES................................................................................................. 62 REFERENCIAS BIBLIOGRÁFICAS .......................................................................... 63 APÉNDICES.................................................................................................................... 66 APÉNDICE 1 DIAGRAMA DE LAS PRINCIPALES CLASES DE CSHELL. ................................ 66 APÉNDICE 2 APARIENCIAS DE CSHELL EN LINUX. ......................................................... 67.

(11) Introducción Python es un lenguaje interpretado y que se presta para construir herramientas interactivas. Existe un gran número de herramientas científicas articuladas en torno a Python. Por solo mencionar algunas: numpy, pylab, pygraph. El grupo CIMCNI (Centro de Investigación de Métodos Computacionales y Numéricos aplicados a la Ingeniería) posee las suyas y ha basado prácticamente toda su visión de interfaz de usuario en herramientas de este tipo. En lo que sigue, se denotará interfaz interactiva de Python a un método en el cual el usuario ejecuta sentencias del lenguaje (entradas) o evalúa expresiones y recibe inmediatamente respuesta desde el intérprete (salidas). Existen varias maneras de interactuar interactivamente con Python. Entre las más conocidas se encuentran: a través del propio intérprete de CPython1 y a través de una herramienta hosteada en www.scipy.org; conocida como IPython. Adicionalmente se han hecho intentos de crear interfaces interactivas en aplicaciones web dinámicas.. Ahora bien en el desarrollo de aplicaciones de este tipo, se tienen en cuenta elementos que permiten brindar al usuario ciertas facilidades, como guardar todas las acciones realizadas, este elemento se le denomina. historia de interacción. y en este caso. particular servirá para almacenar las entradas efectuadas.. En términos de programación la documentación de los programas es un aspecto de gran importancia tanto para el desarrollo de la aplicación como para el mantenimiento de su código, existen dos maneras fundamentales de documentar los programas: Interna: Es la que se crea en el mismo código, ya puede ser en forma de comentarios o de. 1 CPython es el nombre común que se le da a la principal implementación de Python, ver www.python.org; hecha en C.. 1.

(12) archivos de información dentro de la aplicación Externa: Es aquella que se escribe en libro, totalmente ajena a la aplicación en si. Aquí se incluye la ayuda electrónica.. Para algunos desarrolladores la documentación juega un papel determinante, tanto es así que en la actualidad existe una filosofía de programación conocida como Programación Literada ( Literate Programming ) basada en la premisa de que un programa debe ser escrito, con la legibilidad para humanos como un objetivo primordial. De acuerdo con esta filosofía, los programadores deben tratar de lograr una "alfabetización" en su estilo de programación. La misma contrasta con la opinión de la corriente principal que el programador tiene como único objetivo crear el código fuente y que la documentación quedaría relegada a un segundo plano.. Objetivo General Desarrollar una herramienta computacional que permita presentar la historia de interacción con Python, así como documentación embebida como un documento interactivo.. Objetivos Específicos Lograr guardar la historia de interacción en un archivo preferentemente cercano al formato que nativamente entiende el intérprete: el propio lenguaje Python. Permitir al usuario ejecutar entradas seleccionadas de la historia de interacción y actualizar las salidas correspondientes. Lograr que la aplicación pueda trabajar con mínimos cambios y molestias por parte del usuario tanto en Linux como en Windows.. 2.

(13) Justificación de la investigación: En el grupo de investigación CIMCNI (Centro de Investigación de Métodos Computacionales y Numéricos aplicados a la Ingeniería) se desarrollan una serie de investigaciones científicas que requieren de la implementación de métodos numéricos de gran complejidad. Para el desarrollo de estas implementaciones se ha utilizado Python como lenguaje de programación. Existe la necesidad, por tanto, de una herramienta que permita al usuario mezclar comandos y salidas, logrando trabajar eficazmente en un ciclo de prueba y error con las sentencias que ejecuta y los resultados que recibe. Esta aplicación será de gran utilidad para el desarrollo de estas investigaciones.. El presente trabajo se encuentra divido en tres capítulos. El primero aborda el tema de las principales características del lenguaje Python. También hace referencia a técnicas existentes para la construcción de una interfaz de usuario en Pyhton. En el segundo se mencionan aspectos generales de la elaboración del la aplicación (CShell). Por último en el tercer capítulo se presenta el manual de usuario de CShell.. 3.

(14) CAPÍTULO 1: Elementos teóricos relacionados con el entorno de CShell. El objetivo de este capítulo es realizar una descripción general de los aspectos esenciales tanto del lenguaje Python en sí como exponer las características principales de una interfaz de usuario, y proponer algunas de las herramientas principales para la construcción de la misma. El lenguaje Python es usado en la actualidad para el desarrollo de aplicaciones, estas están relacionadas con disímiles ramas. La selección de las técnicas correctas para la programación de dichas aplicaciones para obtener resultados que se reflejen en un producto final de calidad reviste gran importancia, dada la gran variedad de herramientas existentes para tal propósito.. 1.1 Python. Breve Reseña. Python es un lenguaje de programación creado por Guido van Rossum en el año 1990. Es comparado habitualmente con TCL, Perl, Scheme, Java y Ruby. En la actualidad Python se desarrolla como un proyecto de código abierto, administrado por la Python Software Foundation.. Python permite dividir el programa en módulos reutilizables desde otros programas Python. Viene con una gran colección de módulos estándar que se pueden utilizar como base de los programas o como ejemplos para empezar a aprender Python. También hay módulos incluidos que proporcionan entrada y salida de ficheros, llamadas al sistema, sockets y hasta interfaces a GUI (interfaz gráfica con el usuario) como Tk, Gtk, Qt, wxPython entre otros, siendo estos los más conocidos.. Python es un lenguaje interpretado, lo que ahorra un tiempo considerable en el desarrollo del programa, pues no es necesario compilar ni enlazar.. El intérprete de Python estándar incluye un modo interactivo, en el cual se escriben las instrucciones en una especie de shell , las expresiones pueden ser introducidas una por una, pudiendo verse el resultado de su evaluación inmediatamente. Esto resulta útil tanto. 4.

(15) para las personas que se están familiarizando con el lenguaje como también para los programadores más avanzados, pues se pueden probar porciones de código en el modo interactivo antes de integrarlo como parte de un programa.. Existen otros programas, tales como IDLE e IPython, que añaden funcionalidades extra al modo interactivo, como el auto-completar código y el coloreado de la sintaxis del lenguaje. (Wikipedia). En los últimos años Python ha experimentado un importantísimo aumento del número de programadores y empresas que lo utilizan. Algunos de sus desarrolladores y clientes opinan:. Python ha sido parte importante de Google desde el principio, y lo sigue siendo a medida que el sistema crece y evoluciona. Hoy día, docenas de ingenieros de Google usan Python y seguimos buscando gente diestra en este lenguaje. Peter Norvig, director de calidad de búsquedas de Google Inc.(Gracia, 2003). Python juega un papel clave en nuestra cadena de producción. Sin el, un proyecto de la envergadura de Star Wars: Episodio II hubiera sido muy difícil de sacar adelante. Visualización de multitudes, proceso de lotes, composición de escenas. . . Python es lo que lo une todo. Tommy Brunette, director técnico senior de Industrial Light & Magic. (Gracia, 2003). Python está en todas partes de Industrial Light & Magic. Se usa para extender la capacidad de nuestras aplicaciones y para proporcionar la cola que las une. Cada imagen generada por computador que creamos incluye a Python en algún punto del proceso. Philip Peterson, ingeniero principal de I+D de Industrial Light & Magic (Gracia, 2003). 5.

(16) Este lenguaje debido a sus características es usado en varias ramas de la industria, sobre todo en el área científica, el desarrollo de software y en la ingeniería.. 1.1.1 Proyectos desarrollados en Python. A continuación se describen algunos de los proyectos desarrollados en Python: 1. Google: Gran parte de sus principales herramientas tales como su motor de búsqueda, su cliente de correo, y su comunidad (Google Groups).. 2. PyDrone: Es herramienta para la colaboración en el descubrimiento de fármacos construida en Phyton, usada por AstraZeneca, una de las más importantes empresas farmacéuticas. 3.. Modelado Molecular Toolkit (MMTK): Es una biblioteca de código abierto de Python para el modelado y simulación molecular con un enfoque en sistemas biomoleculares, escrito en una mezcla de Python y C.. 4. MayaVi: Es una herramienta de código abierto para la visualización de datos científicos totalmente escrito en Python, desarrollado por un solo programador en su tiempo libre .MayaVi es utilizado por miles de investigadores y científicos de todo el mundo.. 5. Sistema de Cartografía Táctil para Ciegos: Desarrollado en Python, está diseñado para permitir el acceso a mapas para ciegos y débiles visuales. El uso de Python para la implementación de aplicaciones de gran envergadura va en auge, debido a las prestaciones de sus bibliotecas y la facilidad de su aprendizaje.. 1.2 Interfaz gráfica del usuario. Los avances de la ciencia y la tecnología han puesto al hombre en un plano intermedio entre lo tangible e intangible computacionalmente hablando, es ahora tan común el. 6.

(17) convivir con una computadora diariamente que cada vez se hace más imperativo la mejor interacción hombre-máquina a través de una adecuada interfaz (Interfaz de Usuario), que le brinde comodidad y eficiencia.. La idea fundamental en el concepto de interfaz es el de mediación, entre hombre y máquina. La interfaz es lo que "media", lo que facilita la comunicación, la interacción, entre dos sistemas de diferente naturaleza, típicamente el ser humano y una máquina como la computadora. Esto implica, además, que se trata de un sistema de traducción, ya que los dos "hablan" lenguajes diferentes: verbo-icónico en el caso del hombre y binario en el caso del procesador electrónico.. De una manera más técnica se define Interfaz de usuario, como conjunto de componentes empleados por los usuarios para comunicarse con las computadoras. El usuario dirige el funcionamiento de la máquina mediante instrucciones, denominadas genéricamente entradas . Las entradas se introducen mediante diversos dispositivos, por ejemplo un teclado, y se convierten en señales electrónicas que pueden ser procesadas por la computadora. Estas señales se transmiten a través de circuitos conocidos como bus, y son coordinadas y controladas por la unidad de proceso central y por un soporte lógico conocido como sistema operativo. Una vez que el procesador ha ejecutado las instrucciones indicadas por el usuario, puede comunicar los resultados mediante señales electrónicas, o salidas, que se transmiten por el bus a uno o más dispositivos de salida, por ejemplo una impresora o un monitor.. Resumiendo entonces, una interfaz de software es la parte de una aplicación que el usuario ve y con la cual interactúa. Está relacionada con la subyacente estructura, la arquitectura, y el código que hace el trabajo del software, pero no se confunde con ellos. La interfaz incluye las pantallas, ventanas, controles, menús, metáforas2, la ayuda en línea, la documentación y el entrenamiento. Cualquier cosa que el usuario ve y con lo 2. Metáforas: Refiriéndose a interfaces de usuario, se trata de ayudas visuales para representar nociones abstractas, como guías en un programa de diseño gráfico, o las regletas en la zona de edición del Word que permiten definir visualmente los márgenes y tabuladores del documento.. 7.

(18) cual interactúa es parte de la interfaz. Una interfaz inteligente es fácil de aprender y usar. Permite a los usuarios hacer su trabajo o desempeñar una tarea en la manera que hace más sentido para ellos, en vez de tener que ajustarse al software. Una interfaz inteligente se diseña específicamente para la gente que la usará. (Toledo, 1996). 1.2.1 Características. Para lograr una buena interacción con el usuario según (Lores, 2006), la interfaz debe lograr una armonía entre las principales características de una interfaz que son:. Facilidad de manejo: permite poder familiarizarse con su funcionamiento básico de cara a centrarse en los contenidos y en la navegación. La mejor interfaz de usuario es la que requiere el menor esfuerzo de aprendizaje. Originalidad: con ello se consigue motivar a la utilización de la aplicación y promover la exploración por los elementos de la interfaz.. Homogeneidad: la interfaz es la herramienta que va a acompañar a lo largo del viaje por la información y por eso tiene que ser lo suficientemente estable u homogénea como para familiarizarse con su funcionamiento en el menor tiempo posible, y lo suficientemente versátil para que se amolde a distintas actividades dentro de la misma aplicación. La interfaz permitirá contar con unas funciones básicas claras como: salir del programa, seleccionar un módulo, cambiar de tipo de actividad, mapa general para moverse por la aplicación, etc.. Consistencia: en situaciones similares se debe emplear la misma secuencia de acciones. Se debe utilizar una terminología idéntica en los mensajes, menús y pantallas de ayuda. Un ejemplo de consistencia sería usar siempre el comando Nuevo para crear cualquier elemento, en vez de tener comandos alternativos en función de la situación.. 8.

(19) Versatilidad: hará que la interfaz incorpore, manteniendo esa estructura básica, nuevas funciones específicas para una actividad concreta como pueden ser la resolución de casos, el control de variables en una simulación, etc.. Reversibilidad: debe permitir deshacer acciones. Las unidades reversibles pueden ser una acción simple, una entrada de un dato o un grupo de acciones completo. Por ejemplo, cuando se borra un elemento por confusión se debe poder anular la acción, recuperando el elemento eliminado. Adaptabilidad: consiste en ofrecer al usuario la posibilidad de seleccionar las modalidades de navegación en función del tipo de contenidos, de los destinatarios y de los niveles de profundidad previstos.. Multimodalidad: es una característica principal de una interfaz de navegación. Se trata de ver la forma de como integrar las distintas modalidades de comunicación que pueden ser necesarias para cada concepto. Un concepto o idea puede requerir en paralelo un visionado de un proceso en forma de esquema y a su vez la imagen real con la posibilidad de consultar elementos concretos del proceso.. Agilidad: una buena interfaz no debe quedarse en una inmejorable presentación física o artística, sino que, sobre todo, tiene que haber un impecable engranaje que se ponga en mancha para cada acción del usuario y que se traduce en un funcionamiento ágil y dinámico del programa.. Transparencia: la interfaz debe ser ante todo natural y transparente al usuario, de forma que las posibles actividades implicadas en el aprendizaje de un tema concreto se puedan producir directamente sin mediar procesos incomprensibles o complejos.. 9.

(20) Interactividad: el sistema de navegación y la interfaz han de ser interactivos, esto es, deben ofrecer la posibilidad al usuario de que se sienta protagonista de su propia experiencia.. Conectividad: un aspecto de la interfaz que se está investigando mucho es la incorporación de la interconexión de redes. En este ámbito se tiende igualmente a simplificar y hacer amigable el acceso remoto a la información disponible a través de terminales de todo el mundo.. 1.2.2 Funciones Generales. Una interfaz de usuario según (Lores, 2006) ha de contar con unas funciones generales que se pueden agrupar en: 1. Utilidades: Incluye herramientas para la edición, la planificación y la comunicación. Con la utilidad de edición se pueden tomar notas, crear vínculos entre los contenidos, modificar, imprimir, etc. Con la utilidad de planificación el usuario puede preparar sus actividades. La utilidad de comunicación permite el envío y recepción de información tanto con el programa informático como con el exterior y el contacto con otros usuarios.. 2. Navegación: Se incluyen funciones para un recorrido que puede ser libre o guiado a través de la red de contenidos y que permita saber en todo momento donde se está, de donde se viene y a donde se puede ir (claves para la orientación).. 3. Información: Están las funciones de ayuda del sistema, profundización en temas y seguimiento del camino recorrido.. 10.

(21) En la ayuda se encuentra la información sobre el funcionamiento del entorno.. En el seguimiento se tiene acceso a una descripción, y en su caso, valoración del progreso en función del grado de consecución de los objetivos.. 1.3 Construyendo interfaces visuales para Python. Python es un lenguaje que permite la implementación de interfaces de usuario, a través de las extensiones que existen para el propio lenguaje, de los principales sistemas de ventanas multiplataformas existentes en la actualidad. En este epígrafe realizaremos un análisis de algunas de ellas.. 1.3.1 Tk. Tk es una aplicación software libre, multiplataforma constituye una biblioteca de elementos básicos para construir una interfaz gráfica Tk fue desarrollado por Jhon Ousterhout como una extensión para el lenguaje de Tcl, también llamado "bindings", Tk puede ser usado por otros lenguajes como Perl, Python y Ruby. Hay dos formas de usar Tk desde Perl el módulo Tcl::Tk Perl que usa Tcl como un puente (este acercamiento proporciona más flexibilidad), y Perl/Tk tiene solo (solamente las extensiones adoptadas de Tcl/Tk disponibles). Python y Ruby también usan Tcl como puente para Tk. Tk ha sido portado para correr en la mayoría de las variantes de Linux, Apple Macintosh, Unix, y Windows. La extensión para Python es conocida como Tkinter y es la que trae por defecto la instalación del propio lenguaje. (Wikipedia, 2008a). 1.3.2 Qt Qt es una biblioteca multiplataforma para desarrollar interfaces gráficas de usuario. Fue. 11.

(22) creada por la compañía noruega Trolltech. Qt es utilizada en KDE, un entorno de escritorio para sistemas como GNU/Linux o FreeBSD entre otros. Utiliza el lenguaje de programación C++ de forma nativa y además existen extensiones para C, Python, Java, Perl,, Ruby y varios lenguajes más. El API de la biblioteca cuenta con métodos para acceder a bases de datos mediante SQL, así como uso de XML y una multitud de otros para el manejo de ficheros, además de estructuras de datos tradicionales. Qt cuenta en la actualidad con un sistema de triple licencia: GPL v2 y GPL v3 para el desarrollo de software de código abierto y software libre, y otra de pago para el desarrollo de aplicaciones comerciales. Actualmente se encuentra la versión 4 de la biblioteca, y además de las múltiples mejoras, ahora las bibliotecas Qt son también liberadas bajo licencia GPL para Windows y Mac. La extensión para Python es conocida como PyQt está desarrollada por la firma británica Riverbank Computing y está disponible para Windows, GNU/Linux y Mac OS X bajo diferentes licencias. (Wikipedia, 2008c). 1.3.3 GTK + GTK+ o The GIMP Toolkit es un grupo importante de bibliotecas o rutinas. para. desarrollar interfaces gráficas de usuario (GUI) para principalmente los entornos gráficos GNOME, XFCE y ROX de sistemas Linux. GTK+ es la abreviatura de GIMP toolkit (conjunto de rutinas para GIMP).Es software libre, multiplataforma y parte importante del proyecto GNU.. Inicialmente fue creado para desarrollar el programa de manejo de imágenes GIMP, sin embargo actualmente es muy usada por muchos otros programas en los sistemas GNU/Linux. Cabe mencionar que Qt es una alternativa a GTK que también es muy utilizada (en el entorno KDE, por ejemplo).. GTK+ se ha diseñado para permitir programar con lenguajes como C, C++, C#, Java, Perl, PHP o Python. Actualmente su última versión es GTK+ 2, con una cantidad. 12.

(23) importante de mejoras respecto a la primera versión, aunque sin embargo, no es compatible con ella.. La extensión para Python es conocida como PyGTK y es desarrollada por el propio proyecto GNU. (Wikipedia, 2008b). 1.3.4 WxPython. WxPython es una herramienta GUI para el lenguaje de programación Python. Permite a los programadores de Python crear programas con una robusta y altamente funcional interfaz gráfica de usuario, simple y fácil. Está implementado como un módulo de extensión de Python (código nativo), que envuelve a la popular plataforma wxWidgets GUI, que está escrito en C++.. Al igual que Python y wxWidgets, wxPython es de código abierto, lo que significa que es libre para cualquier persona de utilizar y el código fuente está disponible para cualquier persona a examinar y modificar. O cualquiera puede contribuir parches o mejoras del proyecto.. WxPython es un juego de herramientas de múltiples plataformas. Esto significa que el mismo programa funcionará en múltiples plataformas sin modificación. Realmente son las plataformas de 32 bits de Microsoft Windows, la mayoría de Unix o similares a los sistemas Unix, y Macintosh OS X. (Wikipedia, 2008d) 1.3.5 Análisis de las bibliotecas de componentes visuales. Para la construcción de CShell fue necesaria la elección de una biblioteca de componentes visuales para su interfaz de usuario, en este epígrafe se describirá algunos de los criterios que se toman en el proceso de elección.. Con todo lo analizado anteriormente con respecto a las características de una interfaz de usuario, al analizar el aspecto visual, Tkinter deja mucho que desear en cuanto a su apariencia, sin importar plataforma. Además al adicionar que se le recrimina por la falta. 13.

(24) de controles de alto nivel, su elección como sistema de ventanas para CShell queda prácticamente desechada, por lo que a partir de aquí se continuará con las restantes bibliotecas.. Al. analizar. pyQt. (Riverbanks,. 2008). su. aspecto. es. considerado. nativo. independientemente la plataforma en que se encuentre, pues a pesar que se encuentra influenciado por KDE (KDE, 2008), las últimas versiones son capaces de utilizar funciones nativas en Windows. Esto no sucede con pyGTK (pyGTK, 2008), pues es relativamente lento en Windows debido a que dibuja cada elemento de la ventana, esto hace que su aspecto sea de apariencia extraña , aunque en las últimas versiones se ha ganado mucho en esto. Sin embargo su apariencia en Linux es bien acogida entre los desarrolladores, por ser influenciado por GNOME (GNOME, 2008) . Si hay algo que lastra su uso en aplicaciones multiplataforma, es que en Windows es la librería que tiene más dependencias y las mismas son instaladas por separado.. El aspecto de WxPython (wxPython, 2008) es catalogado de nativo en cualquier plataforma, pues usa directamente las API de Windows y GTK cuando se encuentra en Linux. En otras palabras está diseñado para usar funciones nativas de cada plataforma.. En cuanto a la filosofía del propio lenguaje, wxPython se separa del resto de los demás pues al comparar su código, se aprecia un espacio de nombre más claro, sin referencias a C / C++. Esto no sucede en el resto, donde en ocasiones emerge la implantación en C++ subyacente.. Un elemento importante para determinar la interfaz a usar, es la de poder lograr el coloreado de la sintaxis del lenguaje, qué opciones existen para lograrlo de la manera más sencilla y eficiente.. En PyGTK existen varios modos uno de ellos seria el uso, de PyGTKScintilla, que es la extensión del control de edición de texto Scintilla (Scintilla, 2008) para GTK. El uso de este control se hace un tanto difícil, pues en su versión para Windows a quedado en el. 14.

(25) olvido al no seguirse su desarrollo, por lo que no existe una actualización del mismo. Esto se debe en gran medida al uso de GTKSourceWiew (GtkSourceView, 2008), que es una librería que extiende al estándar de GTK+ Framework, con respecto a la edición de texto; pues brinda las facilidades de un editor de código. Su uso tiene el inconveniente de tener en cuenta nuevas dependencias y la compatibilidad entre las mismas. Por solo citar un ejemplo para usar la última versión se necesita GTK+-2.12.x y libxml2 2.5.x respectivamente.. En pyQt (Riverbanks, 2008) existe QScintilla que es la extensión para Qt del componente para edición de Scintilla e igual necesita ser instalado con los inconvenientes que pueda llevar esto consigo. Esto no sucede en wxPython pues la propia instalación contiene un control incorporado conocido como StyledTextCtrl que permite el reconocimiento de varios lenguajes, así como la edición de texto, siendo esta la forma más sencilla y eficiente de lograrlo.. En lo que a licencias respecta quizás las más problemática para ser usada es la que utiliza Qt y su extensión para Python, pues la empresa creadora de Qt. Trolltech, tiene este producto bajo dos licencias una comercial y otra GPL (Licencia Pública General) de GNU. En esencia esta licencia permite la redistribución binaria y de los fuentes de la aplicación, aunque en el caso de que se redistribuyan de manera binaria obliga a que también se pueda acceder a los fuentes. Bajo esta licencia está permitido realizar modificaciones sin restricciones, aunque solo se puede integrar código licenciado bajo GPL o que contenga una licencia compatible. (GNU, 2008) Esto obliga en caso de que no se quiera distribuir el código, a utilizar la variante comercial de estos productos.. Esto no sucede con GTK que al estar bajo licencia LGPL (Licencia Pública General Reducida) La LGPL (GNU, 2008) permite el uso de programas libres con software propietario. El programa en sí se redistribuye como si estuviera bajo la licencia GPL, pero se permite la integración con cualquier otro software sin prácticamente limitaciones. WxPython entre las licencias que usa se encuentra una modificación de LGLP, también. 15.

(26) se destaca el uso de la licencia Python Software Foundation License (Initiative, 2008) , que es compatible con la licencia GPL. Esta licencia no obliga a liberar el código fuente al distribuir los archivos binarios.. Después de analizado lo expuesto anteriormente la mejor opción en para alcanzar los objetivos propuesto con CShell seria la utilización de wxPython como componente visual para el sistema de ventanas.. 1.4 Utilización de herramientas y software libre. La utilización de software libre se ha convertido en la alternativa al uso de herramientas de software propietario. Este conjunto de herramientas pueden ser utilizadas de forma gratuita para el desarrollo de aplicaciones. Los aspectos legales sobre la utilización de este tipo de software se comprenden en una serie bastante numerosa y relativamente compleja de licencias que no es objetivo tratar en este trabajo. Una de las ventajas que presenta el software libre es que da acceso a su código, el cual puede ser modificado para ajustarse a necesidades propias o sencillamente enriquecer sus funcionalidades. Esta peculiaridad, unido a la gran cantidad de desarrolladores que existen por todo el mundo, ha traído consigo la adaptación de estas herramientas de software a varias plataformas, producto a lo cual es posible encontrar versiones de ellas para varios sistemas operativos, llegando a considerarse una parte importante de ellas totalmente multiplataforma. En el presente trabajo se hace uso de una serie de herramientas pertenecientes a este último grupo, y a las que se hará una breve mención en el presente epígrafe. En el presente trabajo se emplean herramientas libres, en primer lugar el lenguaje Python, el cual permite desarrollar aplicaciones que son compatibles con varias plataformas debido a que es un lenguaje interpretado permitiendo ejecutar este tipo de aplicaciones en los distintos sistemas operativos. Para la realización del sistema de ventanas se hace uso de wxPython, otra herramienta de carácter libre mediante la cual se pueden crear interfaces de usuario multiplataformas.. 16.

(27) 1.5 Conclusiones Parciales. Después de realizada una revisión bibliográfica sobre temas relacionados con el tema referente en este capitulo se ha arribado a las siguientes conclusiones:. Python es un lenguaje usado en la elaboración de herramientas para disímiles ramas y su uso a nivel mundial va en aumento.. Python debido a sus características y prestaciones es un lenguaje a tener en cuenta por el país en su estrategia en el área de la informática.. En la construcción de interfaces visuales de usuario, se tienen en cuenta algunas características para lograr la calidad de la misma.. Al hacer un análisis de las herramientas existentes para la construcción de interfaces visuales en Python, wxPython será el sistema de ventanas escogido para la implementación del proyecto.. El uso de software libre permite en gran medida el posterior desarrollo y mejora de los proyectos desarrollados bajo este concepto.. 17.

(28) CAPÍTULO 2: Diseño e implementación de CShell v.1.0 En el presente capítulo se abordan aspectos generales relacionados con la implementación de una aplicación capaz de lograr interactuar con Python (CShell) en su versión 1.0 y se analizan algunos aspectos relacionados con la Programación Orientada a Objetos, paradigma empleado en la elaboración de CShell 1.0.. 2.1 Principales conceptos de diseño y programación orientada a objetos Es importante tratar algunos conceptos fundamentales de la Programación Orientada a Objetos (POO), así como aspectos sobre la metodología de análisis y diseño orientada a objetos UML utilizada durante las etapas de desarrollo del sistema (Rumbaugh et al., 1997a, Rumbaugh et al., 1997b). 2.1.1 Conceptos Generales de la Programación Orientada a Objetos Los módulos que en este capítulo se describen son realizados utilizando el paradigma de POO. Es necesario precisar cuáles son las características particulares y las propiedades que son utilizadas en este diseño para identificar los objetos.. En (Rodríguez, 1999) se presentan las siguientes propiedades de los objetos: Estado: Se define a partir de los valores que en un momento dado tienen los atributos del objeto. La estructura del objeto se define como el conjunto de todos los atributos o propiedades. Además, un objeto puede conocer o contener a otros objetos, estas relaciones son también parte de su estado.. Comportamiento: Define cómo actúan los objetos frente a estímulos externos en términos de cambio de estados.. Identidad: Es la propiedad de un objeto que lo distingue del conjunto de todos los demás objetos del universo al que pertenece. Los modelos de POO son representaciones abstractas de este tipo.. 18.

(29) El marco de referencia conceptual en un sistema orientado a objeto es el modelo de objetos que incluye cuatro conceptos fundamentales: Abstracción: Denota las características esenciales de un objeto que lo distinguen de todos los demás tipos de objeto y proporciona así fronteras conceptuales nítidamente definidas respecto a la perspectiva del observador.. Encapsulamiento: Es uno de los principios más importantes de la POO, ha permitido la reusabilidad de objetos. Constituye el proceso de almacenar en un mismo compartimiento los elementos de una abstracción que constituyen su estructura y su comportamiento. El cliente se interesa por lo que hace el objeto y no cómo lo hace. Modularidad: Es la propiedad que tiene un sistema que ha sido descompuesto en un conjunto de módulos cohesivos y débilmente acoplados.. Jerarquía: Es una clasificación u ordenamiento de abstracciones.. Otros conceptos importantes a tener en cuenta son: Concurrencia: Es la propiedad que distingue un objeto activo de uno que no está activo.. Persistencia: Es la propiedad de un objeto por la que su existencia trasciende el tiempo, el espacio, o ambos.. En (Rodríguez, 1999) se definen los conceptos de clase y tipo: La clase no es más que una representación abstracta que define la estructura y el comportamiento que le son comunes a un grupo de objetos. Mientras que el tipo es un protocolo usado en los mecanismos de comunicación e interacción entre objetos. Tiene identidad y generalmente está más relacionado a los mecanismos de comunicación que a la propia naturaleza de los objetos.. 19.

(30) 2.1.2 La metodología de análisis y diseño orientados a objetos Las metodologías de análisis y diseño orientadas a objetos, como el resto de las metodologías de la ingeniería de software tratan de establecer pautas para el desarrollo de sistemas; indican los pasos a seguir durante las diferentes etapas por las que transita un software en su construcción. Generalmente en las metodologías existen tres etapas bien definidas que son: la etapa de análisis, la etapa de diseño y la de implementación (Kendall and Kendall, 1997).. Según Grady Booch (Booch, 1991, Booch et al., 1999): El análisis orientado a objetos es un método de análisis que examina los requisitos desde la perspectiva de las clases y objetos que se encuentran en el vocabulario del dominio del problema .. El diseño orientado a objetos es un método de diseño que abarca el proceso de descomposición orientado a objetos y una notación para describir los modelos lógico y físico, así como los modelos estático y dinámico del sistema que se diseña .. En el análisis de un problema se deben examinar los roles que un objeto puede jugar. Durante la etapa de diseño se refinan estos roles inventando las operaciones que llevan a cabo las responsabilidades de cada rol .. Al definir las clases es necesario tener en cuentas las operaciones que permiten representar el comportamiento de una clase y los atributos que representan su estructura.. No sólo es necesario conocer como se definen correctamente los objetos, sino qué relaciones se pueden establecer entre ellos. En (Booch et al., 1999) se definen tres tipos de relaciones entre objetos: Asociación: Es una conexión bidireccional entre clases. Se muestra en el diagrama una línea conectando las clases relacionadas. Agregación: Es una relación existente entre una pieza y sus partes. Una agregación se representa a través de una línea que conecta las clases. 20.

(31) relacionadas con un rombo en el extremo de la clase que representa a la clase agregada.. Dependencia: Es una forma débil de relación entre un cliente y un proveedor cuando el cliente no tiene un conocimiento semántico del proveedor. Una dependencia se representa como una línea discontinua desde el cliente hasta el suministrador.. La herencia no es más que la relación entre una superclase y sus subclases. Existen dos formas de encontrar herencia: generalización y especialización. Así, los atributos comunes, operaciones y relaciones son mostrados en las clases de mayor nivel en la jerarquía. Un elemento que facilita la organización del diseño en UML son los paquetes. Un paquete es un agrupamiento de elementos del modelo. Los paquetes en sí mismos pueden estar compuestos por otros paquetes. Un paquete puede contener paquetes subordinados y elementos ordinarios del modelo.. 2.2 Herramientas Utilizadas 2.3.1 IDLE Es el entorno de desarrollo que trae por defecto la instalación de Python, desarrollado por Guido van Rossum, si bien es de una presentación bastante tosca, pues usa como sistema de ventanas a Tk. Brinda al programador facilidades como una sintaxis clara del lenguaje y acceso al modo interactivo. Permite una adecuada indentación en la programación, así como numerosas funcionalidades, con las que debe contar una aplicación de su tipo. Si bien es una aplicación bastante sencilla, con ella se pueden lograr proyectos como CShell.. 2.3.3 WxPython. Es el componente gráfico utilizado para el desarrollo de CShell, su uso es recomendado por el propio Guido van Rossum, debido que es el que más se ajusta a la filosofía del. 21.

(32) propio Python , aquí haré una reseña de los ventajas y las desventajas que tiene el uso de esta herramienta. Ventajas: Completo conjunto de elementos gráficos Rápido y de Apariencia nativa (diseñado para utilizar funciones nativas de cada plataforma) Contiene más de 12 librerías y utilitarios complementarios Independencia: no esta orientado a ningún entorno, ni QT ni GTK. Soporta las características comunes de Windows, y las emula en Linux cuando no se pueden hacer nativamente (y viceversa) Es más "pitónico", por ej. espacio de nombres más claro, sin referencias a C/C++. Permite separar completamente el diseño de la interface en XML del código python (XRC) Documentación completa y ejemplos extensivos.. Desventajas: No viene preinstalado con Python, se debe instalar un paquete (wxPython en windows, wxWidgets + wxPython en Linux) Relativamente complejo de aprender Al tener un desarrollo bastante rápido y sostenido, se liberan versiones frecuentemente, lo que en la práctica le confiere cierto nivel de "volatilidad" y problemas de compatibilidad si se deben mantener varias versiones de wx para el mismo código.. 2.3 Generalidades de CShell. CShell es una herramienta de software que permite presentar la historia de interacción con Python, así como documentación embebida como un documento interactivo.. Basado en el uso de la filosofía de programación conocida como programación literada CShell permite la creación de ficheros en los se combinen tanto la documentación, como. 22.

(33) la interacción con el interprete Python en un mismo documento. Para lograr eso el sistema contará con funciones que permiten las entradas tanto de documentación, como de sentencias válidas del propio lenguaje.. Otros de los elementos tenidos en cuenta es el de lograr una interacción con dicho intérprete: se recibirá una salida desde el sistema, para cada sentencia de Python prescrita por el usuario para evaluación.. También cuenta con las funcionalidades que le permiten al usuario poder salvar y recuperar adecuadamente cada sesión interactiva, brindar facilidades para la edición permitiendo con esto la modificación y eliminación de entradas seleccionadas. Entre estas facilidades se encuentra la de poder salvar solamente el código fuente en el mismo formato que entiende el lenguaje, también se podrá ejecutar una entrada inmediatamente después de ser modificada.. Con CShell se logra la implementación de diferentes tipos de ayuda durante la sesión interactiva con Python. En este caso particular se le incorpora al sistema además del coloreado de la sintaxis del lenguaje, un mecanismo de auto-completamiento de código.. Para la aplicación se basa en ventanas orientadas a la metáfora de una forma y cuadros de diálogo, y puede ser utilizada con mínimos cambios en varios sistemas operativos. Esta aplicación podrá ser ejecutada en Microsoft Windows en sistemas de 32 bits, Linux y en Macintosh OS X.. 23.

(34) Fig. 2.1 Flujo de Trabajo CShell.. 2.4 Una filosofía presente: Programación Literada Una filosofía tenida en cuenta en la construcción de CShell es la conocida por programación literada. En este epígrafe se explica cómo se refleja en la aplicación el uso de la misma.. En la práctica, esto se logra con la combinación de documentación humano-legible y documentación legible por máquina: el código fuente en un único archivo, con el fin de mantener una estrecha correspondencia entre la documentación y código fuente. El orden y la estructura de este archivo de fuente están específicamente diseñados para ayudar a la. 24.

(35) comprensión humana: el código y la documentación se organizan juntos de manera lógica y/o jerárquica (por lo general de acuerdo con un plan que da cabida a explicaciones detalladas y comentarios de ser necesario).. En CShell esta combinación de documentación y código es posible debido a la existencia de dos modos de trabajo, uno dedicado estrictamente a la interactividad con Python, mientras que el otro tiene entre sus funciones la de permitir documentar la interacción. De este modo se logran dos objetivos: realizar una tarea mediante la ejecución de fragmentos de programas y explicar qué se hace en ellos, desde una interfaz única.. 2.5 Consideraciones para el diseño del sistema. Se pretende desarrollar una herramienta que permita la entrada de sentencias escritas en Python y se obtenga respuesta inmediata del intérprete a través de CShell, además de la inclusión de documentación adicional. En este epígrafe se describen algunas de las consideraciones tenidas en cuenta en la construcción de la aplicación.. 2.5.1 Necesidad de un control que permita el procesamiento de texto. Para la construcción de la aplicación se hace necesaria la existencia en el área de trabajo de un control que permita, de una manera adecuada el procesamiento de texto. El propio wxPython contiene varios controles que permiten la entrada de texto y su posterior edición. Entre las pretensiones de CShell se encuentra permitir las entradas de sentencias escritas en Python, de aquí la importancia de brindar al usuario el reconocimiento de la sintaxis del lenguaje, brindando una interfaz amigable para este propósito.. Con el uso del wx.stc.StyledTextCtrl, control perteneciente a wxPython no solo se logra el procesamiento de las entradas, sino que es posible resaltar la sintaxis de los comandos escritos en Python, pues el mismo permite el reconocimiento de varios lenguajes, entre ellos el propio Python.. 25.

(36) 2.5.2 Necesidad de Interactuar. Otra consideración a tener en cuenta para la construcción de CShell, fue la de lograr un mecanismo de interacción con el lenguaje Python, con el que se pretende obtener para cada comando escrito a través de la aplicación, su respectiva salida. En el propio lenguaje Python existe un modo de lograr esto, pero el mismo resultó insuficiente para algunos propósitos a alcanzar por CShell. Por eso fue necesario la construcción de un mecanismo que permitiera interpretar, para esto surge la creación de una clase Interpreter la cual constituye el mecanismo de interacción con Python en la aplicación.. 2.6 Casos de Uso del Sistema CShell está diseñado para ser usado por un solo actor en este caso se denominará usuario y es el que va poder lograr interactuar con el intérprete por medio de la aplicación. En este epígrafe se hace una breve descripción breve de los principales casos de uso. Las principales acciones que puede realizar el actor del sistema se describen en el Diagrama de Casos de Uso en la Fig. 2.2. Como puede apreciarse las principales acciones pueden determinarse a través de tres casos de usos, esenciales para aplicaciones como CShell.. Fig. 2.2 Principales Casos De Uso.. 26.

(37) Para la edición de la sesión interactiva el usuario cuenta con la posibilidad de interactuar con el intérprete Python, así como la posibilidad de dar entrada la documentación adicional, con la expansión de este Caso de Uso se muestra todas las posibilidades con la que se cuenta para la Edición del Documento (véase fig. 2.3). Fig. 2.3 Extensión del Caso de Uso Editar Documento.. Durante la gestión de los documentos por CShell se tienen en cuenta algunas acciones que recaen en el manejo de los ficheros generados para guardar la información de la interacción con Python; lograda por el usuario, a través del trabajo con el sistema. Aquí la posibilidad de salvar no solo toda la sesión interactiva, sino cuando se requiera poder salvar exclusivamente, el código Python. Como se puede apreciar en la Fig. 2.4 en la gestión también se trabaja con los ficheros relacionados con la historia de la interacción y con el fichero dedicado a almacenar los datos de la configuración de CShell... 27.

(38) Fig. 2.4 Extensión del Caso de Uso Gestionar Documentos.. 2.6.1 Principales Casos de Usos de CShell: Para llevar a cabo la construcción del sistema se tuvieron en cuenta a grandes rasgos tres paquetes de casos de uso, que engloban las principales acciones del proyecto. Podemos denominar a estos del siguiente modo. 2.6.1.1 Gestionar Documentos Los casos de uso analizados en este epígrafe, son los encargados de lograr un adecuado manejo de los ficheros. 2.6.1.1.1 Caso de Uso: Crear Documento Propósito: Permitir al usuario crear un nuevo documento. Descripción: Este caso permitirá al usuario la creación de un nuevo fichero, asi como el inicio de una nueva interacción con el intérprete.. 28.

(39) Flujo de Evento:. Flujo básico. Acción del actor. Respuesta del sistema. El usuario presiona el ítem del menú El sistema creará un documento File/New o a través del teclado nuevo. mediante la combinación ctrl. + N. 2.6.1.1.2 Caso de Uso: Salvar Documento. Propósito: Permitir al usuario salvar datos hacia un fichero. Descripción: Este caso de uso le permitirá al usuario guardar en un fichero toda la sesión interactiva con el sistema. Flujo de Evento:. Flujo básico. Acción del actor.. Respuesta del sistema.. El usuario presiona el ítem del menú El sistema abrirá un diálogo, con File/Save o a través del teclado opciones para salvar el documento. mediante la combinación ctrl. + S El usuario. selecciona el lugar y. nombre con los cuales va a guardar y nombrar el fichero El usuario presiona el botón Save. El sistema actualizará los parámetros entrados y salvará el archivo según los mismos.. El usuario presiona Cancel. 29.

(40) 2.6.1.1.3 Caso de uso: Salvar código fuente Propósito: Permitir al usuario, salvar en un fichero, solo el código fuente. Descripción: El usuario accederá a través del menú principal o con una combinación del teclado y podrá salvar el código Python escrito en su sesión con el sistema. Diseño de Interfaz de usuario: Flujo de Evento: Flujo básico. Acción del actor. Respuesta del sistema. El usuario presiona el ítem del menú El sistema abrirá un diálogo, con File/Save Code Source o a través opciones para salvar el documento. del teclado mediante la combinación ctrl. + S El usuario. selecciona el lugar y. nombre con los cuales va a guardar y nombrar el fichero El usuario presiona el botón Save. El sistema actualizará los parámetros entrados y salvará el archivo según los mismos.. El usuario presiona Cancel 2.6.1.1.4 Caso de Uso: Abrir documento. Propósito: Permitir al usuario abrir documento con datos de una sección previamente salvada. Descripción: El usuario accederá a través del menú principal o con una combinación del teclado, que le permitirá abrir un documento existente, para interactuar con el sistema. 30.

(41) Flujo de Evento: Flujo básico. Acción del actor.. Respuesta del sistema.. El usuario presiona el ítem del menú El sistema abrirá un diálogo, con File/Open o a través del teclado opciones para abrir el documento. mediante la combinación ctrl. + S El usuario. selecciona el lugar y. escoge el fichero que abrira El usuario presiona el botón Open. El sistema actualizará los parámetros entrados, si existiera otro fichero abierto lo cerrará, para abrir el especificado.. El usuario presiona Cancel 2.6.1.1.5. Caso de Uso: Salvar historia. Propósito: Permitir al usuario que pueda salvar la historia de interacción con el intérprete Descripción: Al activarse esta opción en la configuración, el sistema salvará hacia un fichero predeterminado en el momento de activarse la opción. Flujo de Evento: Flujo básico. Acción del actor.. Respuesta del sistema.. El usuario activa la opción a través El sistema salvará la historia en un del menú Option/History. camino predeterminado.. 2.6.1.1.6 Caso de Uso: Salvar configuración Propósito: Permitir al usuario que pueda salvar la una determinada configuración con el intérprete. 31.

(42) Descripción: Al activarse esta opción en la configuración, el sistema salvará hacia un fichero la configuración del usuario.. Flujo de Evento: Flujo básico. Acción del actor.. Respuesta del sistema.. El usuario activa la opción a través El sistema salvará la historia en un del menú Option/Config. camino predeterminado.. 2.6.1.2 Configurar Aplicación La aplicación cuentas con funcionalidades que son configurables, CShell al comenzar cuenta con una configuración por defecto, pero le brinda al usuario la oportunidad de acomodar el sistema según sus necesidades. 2.6.1.2.1 Caso de Uso: Mostrar Auto-Completamiento de Código Propósito: Mostrar al usuario este tipo de herramienta de ayuda al programar Descripción: Al activar esta opción, el sistema mostrará esta herramienta de ayuda al usuario en el momento de la programación de las entradas en Python.. Flujo de Evento: Flujo básico. Acción del actor.. Respuesta del sistema.. El usuario activa la opción a través El sistema del. menú. completion. activa la opción o. Option/Code desactiva según sea el caso. o la combinación de. teclado ctrl. + shift + A El. sistema. mostrará. o. no. la. herramienta según configuración.. 32.

(43) 2.6.1.2.2 Caso de Uso: Mostrar Call Tips . Propósito: Mostrar al usuario este tipo de herramienta de ayuda al programar Descripción: Al activar esta opción en la configuración del sistema, le permite al usuario en el momento de pasar los parámetros al ejecutar una función, que le sea mostrado los parámetros requeridos así como la documentación de la misma. Flujo de Evento: Flujo básico. Acción del actor.. Respuesta del sistema.. El usuario activa la opción a través El sistema del menú Option/Call Tips. activa la opción o. o la desactiva la opción según sea el caso. combinación de teclado ctrl. + shift + T El. sistema. mostrará. o. no. la. herramienta según configuración. 2.6.1.2.3 Caso de Uso: Insertar Call Tips . Propósito: Crear nuevas entradas de este tipo. Descripción: Este caso de uso le permitirá al usuario insertar la información recogida para los Call Tips según vaya interactuando con el intérprete Python.. Flujo de Evento: Flujo básico. Acción del actor.. Respuesta del sistema.. El usuario activa la opción a través El sistema. activa la opción o. 33.

(44) del menú Option/Call Tips. o la desactiva la opción según sea el caso. combinación de teclado ctrl. + shift + I El sistema ira insertando nuevos Call Tips durante la interacción el intérprete. Para continuar a partir de ahora al mencionar la historia de interacción, se hará referencia a una estructura que guarda todas las entradas realizadas al intérprete Python.. 2.6.1.2.4 Casos de Uso: Salvar historia automáticamente. Propósito: Permitir al usuario que pueda salvar la historia de interacción con el intérprete Descripción: Al activarse esta opción en la configuración, el sistema salvará hacia un fichero predeterminado al cerrarse la aplicación Flujo de Evento: Flujo básico. Acción del actor.. Respuesta del sistema.. El usuario activa la opción a través El sistema del menú Option/History. activa la opción o. desactiva la opción según sea el caso El sistema salvará la historia en un documento al salir del sistema.. 2.6.1.2.5 Caso de Uso: Salvar configuración automáticamente. Propósito: Permitir al usuario que pueda salvar la historia de interacción con el intérprete. 34.

(45) Descripción: Al activarse esta opción en la configuración, el sistema salvará hacia un fichero predeterminado al cerrarse la aplicación Flujo de Evento: Flujo básico. Acción del actor.. Respuesta del sistema.. El usuario activa la opción a través El sistema del menú Option/Config. activa la opción o. desactiva la opción según sea el caso El sistema salvará la historia en un documento al salir del sistema.. 2.6.1.3 Edición de Documento Este caso de uso permitirá la edición tanto de la documentación embebida, como de las entradas de código Python. 2.6.1.3.1 Caso de Uso: Cambiar Modo Propósito: Permitir al usuario a realizar una transición de modo edición a permitir al sistema la entrada de sentencias válidas en Python. Descripción: Al. producirse la transición el sistema se prepara para permitir la entrada de. documentación, o edición de alguna entrada anterior. o para recibir estrictamente. sentencias válidas en Python. Flujo de Evento: Flujo básico. Acción del actor.. Respuesta del sistema.. El usuario realiza la transición, El sistema hace un cambio del presionando el botón en la barra de. prompt para indicar que se realizó. herramienta o accediendo a través el cambio de modo, preparando el del Menu Action/Change Mode. sistema, para el nuevo rol.. 35.

(46) 2.6.1.3.2 Caso de Uso: Nueva Entrada Propósito: Permitir al usuario entrar una nueva entrada de interacción. Descripción: El usuario introduce su nueva entrada de sentencia válida para Python. Flujo de Evento: Flujo básico. Acción del actor. El. usuario. introduce. Respuesta del sistema. su. nueva El sistema. entrada.. va reconociendo la. sintaxis de la entrada. El sistema muestra las herramientas de ayuda según configuración.. 2.6.1.3.3 Caso de Uso: Ejecutar Entrada Propósito: Permitir la ejecución de las entradas Descripción: El usuario solicitará al sistema la ejecución por el intérprete de su entrada. Flujo de Evento: Flujo básico. Acción del actor.. Respuesta del sistema.. El usuario solicita la ejecución de su El sistema al recibir la solicitud entrada de código Python. ejecutará la sentencia El sistema le brindará al usuario una respuesta.. 2.6.1.3.4 Caso de Uso: Cambiar contenido de las entradas. Propósito: Permitir al usuario poder realizar cambios al contenido de las entradas. 36.

(47) Descripción: El usuario podrá seleccionar alguna entrada previa y hacerle modificaciones. Flujo de Evento: Flujo básico. Acción del actor.. Respuesta del sistema.. El usuario selecciona la entrada a modificar. El usuario introduce su modificación. El sistema actualiza la entrada. 2.6.1.3.5 Caso de Uso: Re - Ejecutar Entrada Propósito: Permitir ejecutar cada vez que se requiera. Descripción: El usuario solicitará al sistema la ejecución por el intérprete de su entrada seleccionada del documento.. Flujo de eventos Flujo básico. Acción del actor.. Respuesta del sistema.. El usuario seleccionará una entrada que ya haya sido ejecutada. El usuario solicita la ejecución de su El sistema al recibir la solicitud entrada de código Python. ejecutará la sentencia El sistema le brindará al usuario una respuesta.. 2.6.1.3.6 Caso de Uso: Eliminar Entrada Propósito: Permitir eliminar una entrada.. 37.

(48) Descripción: El usuario seleccionará una entrada y el sistema permitirá eliminarla del documento de interacción. Flujo de eventos Flujo básico. Acción del actor.. Respuesta del sistema.. El usuario seleccionará una entrada a eliminar El usuario solicita la eliminación de El sistema al recibir la solicitud su entrada.. eliminará la entrada. 2.7 CShell por dentro. Para CShell se tuvieron en cuentas varios elementos, que permitieron lograr su desarrollo, en este epígrafe se analiza a algunos de ellos.. 2.7.1 Acciones realizadas por CShell CShell como aplicación esta concebida para que realice una serie de acciones que permiten que su conjunto conforme las funcionalidades con las que cuenta el sistema. En este epígrafe se hará un acercamiento a acciones que se realizan en CShell. 2.7.1.1 Interacción con Python. A continuación se muestra como es que el sistema es capaz de lograr que el usuario pueda ejecutar sus sentencias en Python. El proceso se inicia desde que se va tecleando la entrada a interpretar, se reconoce la sintaxis del lenguaje. En el siguiente paso se determina el comando con exactitud y es enviado al intérprete, el cual ejecutará el código. Luego se enviará la salida correspondiente, la cual se visualizará en la aplicación.. 38.

(49) Fig. 2.4 Diagrama de Actividades de la Interacción con Python. 2.7.1.2 Gestión de ficheros. En CShell existen algunos procesos que están concebidos para que gestionen diferentes tipos de ficheros generados por CShell, entiéndase uno dedicado a la configuración de CShell y el que guarda la historia de las entradas enviadas al intérprete. También se tienen en cuentas los ficheros creados a través de una sesión interactiva con la aplicación, la mayoría de estos procesos no se basan en nada más que un simple trabajo de ficheros típico en cualquier aplicación, quizás los más relevantes en estos procesos son los que se explican a continuación. 2.7.1.2.1 Proceso de salvar código fuente. Entre las funcionalidades existentes en CShell se encuentra la de poder salvar el código Python escrito por el usuario, en una sesión con la aplicación. El modo en que se realiza este proceso es el siguiente: Primeramente se selecciona todo el contenido existente en el área de trabajo de la aplicación. A continuación se crea el fichero en cual se salvará el fichero. Se hace un recorrido para seleccionar las expresiones que forman parte del. 39.

(50) código y van siendo copiados hacia el fichero origen, cuyo formato es entendible por el propio lenguaje Python. 2.7.1.2.2 Proceso de abrir fichero en CShell Un proceso que si bien no tiene mucha complejidad, es válida su descripción debido a lo que representa en la aplicación. Esta acción permite abrir los dos tipos de ficheros generados por CShell, en lo que respecta a la información generada mediante la sesión con el sistema. El flujo de las operaciones se describe a continuación: Al seleccionar el archivo a abrir, a través del diálogo existente para tal propósito, se determina el tipo de fichero gracias al uso de funciones existentes en el módulo. os. (abreviatura de. Operating Systems) que pertenece a las bibliotecas distribuidas con Python.. Fig. 2. 5 Diagrama de Actividades de la acción de abrir fichero. Después de determinar el tipo de fichero, se realizan las acciones determinadas para cada archivo. En CShell existen dos tipos de archivos, el primero es el que guarda toda una sección interactiva, al abrirse se leerá todo su contenido y se mostrará en la aplicación; el segundo tipo es el que guarda solamente el código de la interacción, y en este caso se procederá del siguiente modo, mientras se va leyendo se ejecutarán las sentencias y se irán reflejando en la aplicación junto a su respectiva salida.. 40.