Dame una palanca, punto de apoyo, espacio para las piernas y cinta reforzada
Incluso si lo intentas, no puedes describir sucintamente cómo te espera una madriguera de conejo sin fondo. Este es uno de esos raros casos en los que, para darse cuenta de lo que se discutirá, es necesario escuchar el discurso hasta el final. Después de estudiar los pasos de este manual, todos encontrarán algo por sí mismos: el editor de "texto" esotérico Leo Editor, con toda su esencia, requiere su uso de la manera más sorprendente.
Contenido
1. Prólogo ................................... 2
2. Instalación de Leo Editor ..................... 2
3. Configuración ................................ 4
4. Conociendo la interfaz ................. 7
5. Creación de archivos externos ................. 14
6. Uso de secciones con nombre ........ 18
7. Inclusión codiciosa ....................... 21
8. Magia simple ...................... 24
9. El reverso del hombre lobo ............... 30
10. Visualiza esto ....................... 33
11. Contenido y forma ...................... 36
12. Construiré un IDE para mí ....................... 39
13. Libertad de pensamiento ........................... 49
14. Hurra, el fin .............................. 58
15. UPD. Ejemplos de aplicación ................. 58
Prologo
Cuando escribe en cualquier lenguaje de programación, siempre hay una escasez aguda del navegador de clases de Smalltalk, la sensación molesta de que sus manos están atadas y sus piernas húmedas es interminable. Y también sucede que a menudo buscas una cosa en Internet, y encuentras algo completamente diferente, pero tan hermoso que el motivo del comienzo de la búsqueda se pierde en el contexto de los horizontes que se desarrollan. Una búsqueda de la frase "navegador de clase de pitón" produce una tonelada de basura, pero un diamante sin cortar yace en esta montaña, brillando débilmente, sin atraer un gran interés, esperando el ojo atento y una mente inquisitiva para notarlo y recogerlo.
Instalar Leo Editor
El proyecto es multiplataforma, el proceso de instalación se proporciona para la plataforma Windows. Para iniciar el editor, necesita Python y la biblioteca Qt. La opción de instalación descrita es la más sencilla para el usuario que no está preparado para sufrir, los profesionales pueden actuar a su discreción.
Instale el administrador del espacio de trabajo del programador Python de Miniconda. Esta solución le permite reducir seriamente la capacidad de obtener una calabaza en lugar de componentes correctamente conectados, y en el caso de un punto muerto arbitrario, regrese sin problemas al estado cero y cambie rápidamente a probar una opción de ajuste diferente.
Desde la página de
descarga descargamos el instalador Python 3.7 Miniconda3 Windows de 64 bits. Establecemos cuando surge la pregunta sobre las marcas de verificación, activamos los dos.
A continuación, ejecute la línea de comando (teclas [Win + R], "cmd", [Enter]). Escribimos:
conda
No hay errores, hay acceso directo a conda. Verificamos la disponibilidad de la versión requerida del ejecutor de idiomas:
python -V
En el lugar.
Analizamos qué versiones del editor están disponibles para la instalación:
pip install leo==
Preferimos la última versión sin letras en el número:
pip install leo==6.1
Después de descargar, desempacar e instalar, probamos suerte: lanzamos el intérprete de Python, nos conectamos a los componentes del editor, iniciamos el editor
python >>>import leo >>>leo.run()
Personalización
Si el acceso directo para el inicio no aparece en el escritorio, agréguelo usted mismo:
Ruta al
lanzador del editor:
% USERPROFILE% \ Miniconda3 \ Scripts \ leo.exeRuta del icono :
% USERPROFILE% \ Miniconda3 \ Lib \ site-packages \ leo \ Icons \ SplashScreen_trans.ico
Realmente no me gustaba el aspecto de mis temas visuales nativos, así que tuve que hacer el mío. Para usarlo, primero debe
descargarlo . Libre de virus 1000%. El archivo
python.py es una descripción para diferenciar el color de los elementos de sintaxis de Python. Debe colocarse en
% USERPROFILE% \ Miniconda3 \ Lib \ site-packages \ leo \ modes \ con el reemplazo del archivo anterior. Lo que, por el bien de ustedes, entregó el lenguaje python se aclarará un poco más tarde. Los archivos restantes del archivo deben copiarse en la
carpeta% USERPROFILE% \ Miniconda3 \ Lib \ site-packages \ leo \ themes \ .
Ahora debe habilitar el tema en la configuración del usuario.
Haga clic en el elemento @settings, luego use la tecla [Insertar] para agregar un nuevo elemento anidado. Pega el texto:
@string theme-name = monokai.leo
Para guardar los cambios, presione [Entrar]. Si la edición del nombre de un elemento se desactiva inadvertidamente, puede habilitarla haciendo doble clic en el elemento o presionando la combinación [Ctrl + h].
Reiniciar con guardar cambios.
La asociación con los archivos ".leo" debería ocurrir automáticamente, pero si no, usaremos la solución integrada.
Hasta hace poco, esto no funcionaba sin enmiendas, y ahora lo han reparado, como si, jeje.
Conociendo la interfaz
A primera vista, tenemos ante nosotros un editor ordinario de textos estructurados (editor de
esquemas en inglés, outliner), un clon del amado
treepad por muchos (el archivo web, fuera del sitio, desafortunadamente, se ha deshabilitado debido a problemas financieros del desarrollador). De hecho, hay un árbol y hay un área para ingresar texto que pertenece al nodo del árbol seleccionado. El área multifuncional con las pestañas de nombre sin complicaciones, además del registro, concluye algo más útil, comencemos con la búsqueda de texto.
Parece ser una cosa estereotipada, pero hay excentricidades, en lugar de los botones en pantalla, se propone presionar las teclas del teclado. Y el comando find-all no tiene una clave asignada en absoluto. Ahora toda la atención está en la parte inferior de la ventana.
Tru-geeks deben haberse ahogado con cerveza. Sí chicos, este es un préstamo directo de emacs. La mayoría de las operaciones del editor pueden iniciarse utilizando la línea de comandos incorporada.
Los resultados de búsqueda para todas las palabras que aparecen "the" se muestran en un nuevo nodo de árbol creado deliberadamente. La granja colectiva! (No se preocupe, la búsqueda por elementos "corre" a través de las ocurrencias detectadas, como en los tíos sanos).
¡Juventud, no se dispersen! Era necesario sacudir las ampollas dormidas. Siempre puedes ir por el borde de esta zona oscura Leo Editor. El programa se parece mucho a Linux: pasión, cuánto hacen los entusiastas por sí mismos, todo requiere un estudio cuidadoso, el rendimiento de uno es diferente de la implementación del otro, siempre es sorprendente descubrir nuevos chips que alguien puso, pero realmente no describió, y Por todo esto, existe la punta del iceberg en el que se asienta cómodamente, y si eres reacio a tomar aventuras, no puedes envolverte en las profundidades sombrías.
El área de etiqueta le permite asignar etiquetas a los nodos y, posteriormente, trabajar con ellos. Aparentemente se usa para agregar nuevas dimensiones a la profundidad del ordenamiento del caos. Seleccionamos el nodo, escribimos el identificador de etiqueta, hacemos clic en "+". Seleccionamos otro nodo, simplemente presionamos "+" en él, se asignará la etiqueta activa. Seleccionamos el tercer nodo, escribimos "Schmucker", presionamos "+". Actualmente tenemos dos nodos con la etiqueta "zutsker" y un nodo con la etiqueta "shmutsker".
Seleccionar una etiqueta de la lista de etiquetas conduce a una lista de nodos asociados con la etiqueta por los nombres de los cuales puede navegar. Para seleccionar una etiqueta de un nodo, haga clic derecho sobre ella.
Luego viene el extremadamente útil panel de navegación. Ayuda a pasar por alto rápidamente los nodos en los que se produce una palabra determinada. Dado que la forma de mantener archivos .leo es un gran desastre con un alto nivel de organización, la navegación a través de la búsqueda se ajusta al ciclo natural de la aplicación.
El uso común de editores de textos estructurales es la acumulación de una base de conocimiento personal. El segundo uso más común es mantener una lista de tareas. La siguiente pestaña ayuda a colorear este proceso con prioridades, plazos y estados de implementación.
El menú contextual del nodo le permite utilizar una proporción significativa de las capacidades de la pestaña Tarea.
Crea archivos externos
Cómo editar el texto y usar el árbol no será difícil de resolver por sí mismo, así que procedemos a sumergirnos en el abismo de las infinitas posibilidades de transferir abstracciones al mundo real. Crea un nuevo archivo.
El nombre del nodo único
NewHeadline cambia a
@file 1.txt
Agregue algo de texto al contenido del nodo.
Guarde el archivo .leo en alguna parte. Abra la carpeta en la que se encuentra el archivo .leo. Notamos que hay 1.txt. Lo abrimos
¿Qué construimos? Configuramos la exportación de uno de los nodos del archivo .leo a un archivo externo.
¿Qué basura hay alrededor de nuestro texto? Metadatos que le permiten recrear la estructura al volver a cargar el archivo en el Editor Leo, lo cual es necesario si el archivo se modificará en algún lugar externo. La mayoría de los archivos python del código fuente del Editor Leo se pueden soltar arrastrando y soltando en el editor y se encuentra que contienen una descripción de la estructura:
Pero si no necesitamos la función de carga inversa en absoluto, pero por el contrario queremos que el archivo no contenga bytes extraños, entonces esto se hace reemplazando la directiva
@file por
@file-nosent (sin centinelas).
Después de guardar los cambios en el archivo .leo, el archivo externo se actualizará automáticamente.
Usar secciones con nombre
Cada nodo es una entidad independiente separada, que por defecto no tiene información sobre sus vecinos. Si intentamos agregar una nueva estructura al nodo adjunto a un archivo externo y hacemos clic en guardar, se producirá un error.
Se nos notifican dos problemas:
- Tenemos un nodo de "prueba" suspendido en el aire (en relación con el archivo externo, ya que hay un nodo dentro de la estructura .leo, pero no indicamos cómo debe agregarse al archivo externo, debido a esto hay un error).
- Hasta que se resuelva el problema con el nodo colgante, no se guardarán en el disco otros cambios dentro del
@file-nosent 1.txt .
La primera forma de agregar enlaces entre nodos es a través de secciones. Un formato especial para los nombres de sección se ve así:
<<my_name>>
Esto le permite proclamar un nodo anidado como una sección con nombre, el mismo nombre debe especificarse en el lugar del nodo externo donde se deben colocar los contenidos del nodo subordinado.
El archivo resultante:
El mismo ejemplo en un archivo real, la sección de importación de dependencias externas se asigna explícitamente a un nodo separado.
Inclusión codiciosa
Pero, ¿qué hacer si queremos construir una sección anidada en una sección anidada y poner otra sección en ella? Puedes actuar ingenuamente:
Pero para tales deseos naturales, hay hasta dos directivas:
@all y
@others .
La directiva
@all concatena sin gusto los textos de todos los nodos anidados.
Por supuesto, todo depende del formato de archivo que necesite en la salida, pero probablemente le gustará más la directiva
@others , que le permite materializar la estructura diseñada en la forma deseada. Opción melancólica:
Ajustar secciones con palabras clave:
Formato de sangría:
Como? ¿Está empezando a tomar forma? Apenas llegamos a la verdadera diversión.
:: ::
Magia simple
Finalmente, comenzamos a componer el código. La tarea será estúpida, pero contendrá elementos básicos típicos de un programa útil. Cree un nuevo nodo en cualquier parte del archivo existente o nuevo. La primera línea indica la directiva
@language para habilitar el resaltado de código. Si debajo del idioma de resaltado en la carpeta
% USERPROFILE% \ Miniconda3 \ Lib \ site-packages \ leo \ modes \ no, nadie prohíbe agregarlo usted mismo.
Supongamos que la información que vamos a procesar es almacenada por una placa en un archivo csv.
Necesitamos: contar el número de caracteres "0" encontrados en la columna Count
Debemos:
- Convertir texto a estructura de datos de muestra
- Realizar iteración con conteo
Descomponemos el programa de acuerdo con el algoritmo desarrollado. El segundo paso después de leer el archivo, divide el texto en líneas. Cuál fue el primer paso se mueve al nodo subordinado Leer.
A continuación, cree una matriz de diccionarios correspondientes a los datos de la tabla. Este nodo está en el nivel superior.
Y el último paso.
Mientras tanto, el archivo main.py resultante se formará en el disco.
Hurra, somos geniales. Pero de repente tuvimos un deseo incomprensible de calcular el número de líneas significativas en el mismo archivo csv. No es un problema, haga copy.paste del nodo principal, cambie el nombre del archivo de salida, modifique el código del último paso. Obtenemos el resultado.
Y aquí nuestra alegría da paso a la tristeza, porque el nombre del archivo CSV puede ser diferente, lo que significa que si lo corregimos en un programa, en el segundo definitivamente lo perderemos de vista y, por lo tanto, depreciaremos la alegría de reutilizar el código.
Triste y bonita, ¡es Leo Editor! Tiene copias sincronizadas de nodos. Que? En lugar de copiar el contenido del nodo, puede pegar el nodo copiado en el modo "clon", "fantasma", y luego cambiar uno de los nodos vinculados se mostrará en los otros nodos. Este es un concepto extremadamente poderoso que le permite resolver las contradicciones inherentes a la organización de la información en los árboles.
Copia el nodo.
Lo insertamos como un "fantasma".
Los fantasmas tienen un ícono diferente. Cualquier cambio en el nombre, contenido o nodos subordinados se refleja en la copia. Eliminamos el antiguo nodo de lectura y verificamos que la modificación del nombre del archivo ahora se realiza sincrónicamente en todas partes.
Hablando en el lenguaje de las matemáticas, los "fantasmas" le permiten cambiar de un árbol a un gráfico acíclico completo. ¡Un árbol en Leo puede tener más de una raíz!
Esto le permite hacer cosas fantásticas: hacer malabarismos con representaciones de información, vincular contenedores de datos heterogéneos, tener un número infinito de copias reales de datos en un proyecto, cargar datos en el árbol Leo que no se pueden colocar en un árbol normal.
Hombre lobo reverso
Hagamos un experimento. Crea un nuevo nodo. Añadir texto a él.
g.es( len("This is test".split()) )
Presione [Ctrl] + [b].
Chpok, buenas noches. Sí, tenemos aquí, resulta que el intérprete de Python está incorporado, lo que puede ejecutar el texto del nodo como código. Si las secciones están conectadas al nodo de acuerdo con las reglas para unir secciones a archivos externos, entonces el código de ellas también se ejecuta, lo que significa que no hay tal fuerza que pueda detenernos en una batalla con el desorden.
Ejemplo de vida: el código de los tutoriales es terriblemente reacio a escribir normalmente, pero si se trata de algo más de 50 líneas, el desorden que se vuelve ilegible al día siguiente está garantizado. Vale la pena agregar que muchos entrenadores usan el mismo conjunto de datos de origen y realizan varias manipulaciones en ellos. Lo anterior es cierto para cualquier "prototipo" o "herramienta de utilidad 1-2 veces". En este lugar, los chips Leo Editor descritos son extremadamente útiles.
Eso es todo: este es un código que hace algo directamente dentro del Editor Leo, sin cargarlo en archivos .py.
A diferencia de las hojas de espagueti en la imagen, puede comprender de inmediato la esencia general de lo que está sucediendo. Por ejemplo, en el programa "4 Regresión lineal", los datos de Internet se escriben primero en un archivo. Y luego se llevan a cabo varias manipulaciones en el modelo numérico de "regresión OLS", construido de acuerdo con el archivo. Además, si necesitamos usar otros datos u otras configuraciones del modelo, entonces es suficiente hacer cambios en un nodo, ya que las partes reutilizadas del programa son implementadas por "fantasmas". El programa se divide en 6 partes independientes, cada una de las cuales se inicia por separado, pero al mismo tiempo comienzan a ejecutarse desde un punto común.
Cuando el código de temas similares se almacena de forma organizada en un solo lugar, es muy conveniente, incluso si pasa mucho tiempo, luego, utilizando la búsqueda de navegación, puede encontrar rápidamente algún método específico, y la organización estructural ayudará a navegar lo que está sucediendo. Los "fantasmas" le permiten convertir código complejo no lineal en un conjunto de acciones secuenciales, mientras que las entidades de "clonación" no multiplican la entropía, sino que la reducen, porque la repetición se reemplaza por la unión y no se crean niveles adicionales de abstracción.
50 archivos dispersos con archivos fuente son 50 archivos dispersos. 50 nodos con códigos fuente es una base de conocimiento con un deseo interno de autoorganización.
Visualízalo
Antes de embarcarse en el nivel de dificultad Pesadilla, volvamos a la interfaz.
Los paneles del editor se pueden arrastrar para organizar su espacio de trabajo de la mejor manera. Cada archivo conserva su propia configuración de apariencia. Puede cerrar todos los paneles excepto el árbol. Para devolver los paneles, haga clic derecho en el encabezado del árbol.
En el mismo menú hay un cierto Render. Esta pequeña cosa está diseñada de acuerdo con su nombre para mostrar todo en el mundo.
De forma predeterminada, el procesamiento intenta representar el texto del nodo como
reStructuredText . Se incluyen otros modos de operación forzando el tipo de contenido en el nombre del nodo.
Como puede ver en la tabla, Render no funciona muy vigorosamente, la buena noticia es que Leo Editor se puede ampliar con complementos, incluidos los visuales. Por ejemplo, necesitaba cargar los números en tablas y dibujar gráficos, mientras cambiaba los datos iniciales mil veces.
El código mínimo del complemento visual se ve así:
from leo.core.leoQt import QtCore, QtGui, QtWidgets import leo.core.leoGlobals as g class My_Plugin_Widget(QtWidgets.QWidget): def __init__(self, parent=None, leo_com=None): super(My_Plugin_Widget, self).__init__(parent) c = leo_com self.c = c self.layout = QtWidgets.QVBoxLayout() self.message = QtWidgets.QLabel("Hello there!", self) self.layout.addWidget(self.message) self.setLayout(self.layout) def init(): g.registerHandler("after-create-leo-frame", onCreate) g.plugin_signon(__name__) return True def onCreate(tag, keys): c = keys.get("c") if not c: return dw = c.frame.top dock = g.app.gui.create_dock_widget(closeable=True, moveable=True, height=150, name='My plugin') dw.leo_docks.append(dock) dock.setWidget(My_Plugin_Widget(leo_com=c)) dw.splitDockWidget(dw.body_dock, dock, QtCore.Qt.Horizontal) dock.show()
El complemento es necesario:
- Guardar en
%USERPROFILE%\Miniconda3\Lib\site-packages\leo\plugins\ - Regístrese en el archivo myLeoSettings.leo en el
@settings\@enabled-plugins
Puede leer sobre cómo hacer complementos
aquí , si es impaciente obtener más información, entonces la única manera es estudiar el complemento viewrendered.py usted mismo.
¿Por qué es todo esto? De nuevo a posibilidades ilimitadas. El acceso completo a QT le permite reproducir información de manera arbitraria o ingresarla de la manera más inesperada.
Contenido y forma
Todo lo descrito anteriormente parece una herramienta conveniente para resolver una gama limitada de tareas de pantalla, nada más. La conversión de árbol a archivo externo es lineal y está limitada por marcos estrictos. Incluso los nombres de los nodos desempeñan el papel de comentarios, pero no tienen otra funcionalidad útil. Pero en la práctica resulta que es muy apropiado describir una entidad compleja para el pensamiento humano con un árbol, pero al mismo tiempo el formato para la máquina puede no parecerse a nada y / o puede no tener ninguna estructura distinta. Para un ejemplo simple, tome HTML. Sería muy conveniente y fácil (juicio de valor) preparar el marcado de esta forma:
Todo es estructuralmente consistente y visual, es imposible cometer un error de no cerrar o colocar incorrectamente una etiqueta, y hacer cambios de cualquier escala es elemental. Aunque el archivo de salida HTML será "linealmente proporcional" a esta estructura ficticia, el mecanismo de archivo adjunto de sección no es capaz de producir lo siguiente:
- Etiquetas de abrir-cerrar
- Asignar texto de nodo como atributos de etiqueta
- El texto de los nodos con el nombre especial "> <" se coloca dentro de la etiqueta correspondiente
Bueno, por supuesto, Leo Editor da acceso ilimitado al árbol desde el código de nodo. Tanto para leer como para escribir. Lo que permite realizar modificaciones arbitrarias de las representaciones de información para el hombre y la máquina. En cualquier dirección y cualquier número de veces. Puede descargar cierto formato, reconstruirlo en un árbol entendible para USTED, realizar cambios y volver a convertirlo. Si el formato de salida es trivial, puede escribir un archivo externo usando Python. Si el formato es complejo y / o hay una cantidad significativa de datos, entonces es ventajoso pasar el tiempo cambiando los datos a un nodo de archivo con secciones, ya que esto facilita enormemente la depuración de las conversiones.Descripción de funciones para trabajar con un árbol:Se pueden elegir otras funciones de las fuentes de Leo Editor y completar los archivos .leo, y realmente no hay documentación ( excepto esta página ) = (Por cierto, este artículo está escrito en Leo Editor.
El siguiente código se utiliza para exportar el árbol a HTML: @language python from pathlib import Path @others path = Path('C:\\Projects\\article\\') / 'out.html' out_text = '<body><script>document.body.style.fontSize = 20;</script>' n = g.findNodeAnywhere(c, 'TITLE') assert nh == ('TITLE') tag = f'<h1>{nb}</h1> ' out_text = out_text + tag + '\n\n' n = g.findNodeAnywhere(c, 'TEXT') assert nh == ('TEXT') for header_node in n.children(): anchor_id = hash(header_node.h) tag = f'<anchor>{anchor_id}</anchor><h3>{header_node.h}</h3>' out_text = out_text + tag + '\n' if '' == header_node.h: text = make_toc(header_node) tag = f'{text}' out_text = out_text + tag + '\n' for content_node in header_node.children(): if '@image' in content_node.h: tag = f' <img src="{content_node.b}" alt=" "> ' else: text = content_node.b if not 'table' in content_node.h: content_node.h = ' '.join(content_node.b.split()[:3]) text = text.replace('\n', ' ') tag = f'{text}' out_text = out_text + tag + '\n' tag = ' <hr/>' out_text = out_text + tag + '\n' out_text = out_text + '</body>' + '\n' with open(path, 'w', encoding='utf-8') as f: f.write(out_text) g.es('.')
Construiré un IDE para mí
Ni una sola pitón, así que tratemos de equiparnos con una esquina debajo de ... cualquier cosa. Primero, finalmente presione el botón de secuencia de comandos.
Esta acción lleva a la aparición de un nuevo botón debajo del menú principal con el nombre del nodo actual. La lógica sugiere que hacer clic en este botón recién creado conducirá a un intento de ejecutar código desde el nodo asociado con el botón. Es conveniente, pero inconveniente, que el botón se evapore después de reiniciar el editor. Para mantener el botón siempre en su lugar, debe agregar un hechizo especial en el nombre del nodo @buttony reiniciar Leo Editor.
Para cada botón de usuario, puede asignar una tecla de acceso rápido utilizando la expresión. @key=
Para ejecutar otro script desde un script, debe llamar a la funciónc.executeMinibufferCommand('FIRE'). Cada secuencia de comandos con un botón vinculado cae en el grupo general de comandos del editor bajo el nombre del botón, es decir, sí, su secuencia de comandos también se puede ejecutar desde la línea de comandos del editor.
Para ejecutar la secuencia de comandos del nodo que está actualmente en foco, desde otra secuencia de comandos (como presionando [Ctrl] + [b]), se utiliza el comando c.executeMinibufferCommand('execute-script').Supongamos que tenemos un código preparado. Sería beneficioso ejecutarlo desde Leo Editor, y sería maravilloso obtener todos los errores de la consola. Eche un vistazo a un ejemplo de código Python con formato automático dentro de un nodo utilizando la famosa utilidad Black. @language python import subprocess import re c.frame.log.selectTab('Log') c.frame.log.clearLog() python_src = [] for line in pbsplitlines(): if re.match(r'@', line) is not None: line = line.replace('@', '# special_comment@') elif re.match(r'<<', line) is not None: line = line.replace('<<', '# special_comment<<') python_src.append(line) text = '\n'.join(python_src) proc = subprocess.Popen( ['black', '-', '-q', '--skip-string-normalization'], stdout=subprocess.PIPE, stderr=subprocess.STDOUT, stdin=subprocess.PIPE, bufsize=0, shell=True, ) proc.stdin.write(text.encode()) proc.stdin.close() s = proc.stdout.read() if s: text = s.decode('utf-8') text = text.replace('# special_comment<<', '<<') text = text.replace('# special_comment@', '@') if 'error: cannot format -: Cannot parse:' in text: z = re.search(r'Cannot parse:.*', text) g.error(z.group(0)) else: undoData = c.undoer.beforeChangeNodeContents(p) pb = text.strip() c.undoer.afterChangeNodeContents(p,'Format with black', undoData) c.executeMinibufferCommand('execute-script')
Se hace lo siguiente:- Tomamos el texto del nodo
- Ponemos instrucciones especiales de Leo Editor en los comentarios.
- Inicie la utilidad de la consola.
- Pasamos el texto a la utilidad.
- Lee su conclusión
- Regresamos al lugar instrucciones especiales
- Si no hay errores, reemplace el texto actual con formato
- Ejecute el código del nodo
Esta muestra será suficiente para lanzar cualquier cosa sobre su base.Ahora veamos una versión hermosa y clara del uso práctico de Leo Editor. El ecosistema Python tiene varias soluciones para crear aplicaciones GUI, una de las cuales es el marco Kivy. Una característica importante de este marco es la capacidad de cargar una descripción de interfaz en un idioma especial desde un archivo de texto. Leo Editor nos ayudará, en primer lugar, a almacenar el código y la descripción de la interfaz en un espacio, y en segundo lugar, reemplazará la edición de texto con la edición en árbol, lo que de alguna manera nos acercará a los bocetos de la interfaz wysiwyg.
Qué hechos se pueden extraer de la captura de pantalla anterior:- Leo Editor Kivy
- RUN make_GUI, make_py,
Arriba, puede ver cómo se ve la descripción de la interfaz en forma ensamblada. Esto puede ser sabroso, pero la granja colectiva de la izquierda parece ser una solución más manejable e industrial. La versión correcta pide hacer errores tipográficos el viernes por la noche.Pasamos a la sucursal con el código.
Muy limpio Y está claro. No prestamos atención a DATAGRAPH. ¿Y qué hay de las clases?
El círculo se ha cerrado, entonces lo que sucedió esta historia llegó a ser una implementación improvisada del navegador de clase para Python. Los encabezados de nodo no son solo comentarios; su contenido se usa al generar archivos .py. Los niveles de anidamiento de clases forman automáticamente una jerarquía de herencia. Todo lo que adoramos.
KA-EE-FF !!! No se concentre en el significado de lo que está sucediendo, las clases se lanzan para una captura de pantalla.Se puede hacer algo similar en la funcionalidad básica de las secciones del archivo, pero tendrá que especificar explícitamente todas las construcciones de lenguaje (def, clase ...), y con cualquier cambio, deberá recordar hacer numerosas correcciones allí (y los encabezados de nodo colgante inútiles también )Y nuevamente, sobre un solo espacio de código e interfaz. Primero, recuerde la búsqueda de navegación, que le permite buscar rápidamente controladores de código para elementos visuales y elementos visuales del código.
En segundo lugar, todavía existe una característica tan esperada como un editor de texto adicional.
Hop!
Por lo tanto, no es necesario correr de un lado a otro con una edición mutua compleja de nodos.Por cierto:
Libertad de pensamiento
Al final habrá un poco antinatural. Todo lo que se describe a continuación no debe tomarse como una demostración de buenas prácticas de ingeniería, esto es solo una semilla para cristalizar sus ideas personales.El punto de partida para el primer experimento: si la mayoría de los programas están involucrados en la producción repetida de otras matrices de datos a partir de una única matriz de datos muchas veces, ¿por qué no crear un bloque de construcción simple descrito por una clase universal con una interfaz de recepción / salida de datos unificada para Enlace visualmente bloques similares en el árbol del Editor Leo, en la imagen de programación en gráficos (bloques de funciones). Con la diferencia de que será un sistema híbrido de clase de bloque, y cada forma de describir el código se utilizará de acuerdo con el beneficio máximo a largo plazo.Una unidad funcional primaria debe: tener una entrada para recibir información, ser capaz de responder a su tipo, procesar la información inicial, empaquetar los resultados del procesamiento en un formato para la transmisión y traducir el resultado.
Supongamos que hay una tarea atrevida de analizar sitios. Necesitaremos los siguientes bloques:- Componente de red
- Analizador de página web
- Bloque para la comunicación de los datos recibidos y la interfaz gráfica
A continuación se muestra la implementación práctica mínima de un bloque suficientemente universal, que encaja en la rama de clase.
Por supuesto, cada bloque de concreto puede recargar métodos típicos con los suyos si se observan estrictamente dos reglas:- En cada bloque, el método de decodificación necesariamente llama proceso, que a su vez llama codificación
- El método de codificación llama al método de decodificación en todos los bloques registrados como salidas.
Es decir: se garantiza la disponibilidad de unificación estructural y la homogeneidad del intercambio de información.
Lo mismo, pero más claramente:- El producto original se encuentra en la placa izquierda.
- Decode prepara el producto para el procesamiento
- Después de eso, el bloque lleva a cabo su función principal en el método de proceso.
- El producto está empaquetado por codificar
- El producto empaquetado se transfiere a unidades posteriores
Cada bloque resulta ser bastante independiente, lo único que necesita saber sobre el mundo exterior es una forma específica de analizar los datos entrantes. El código universal es responsable de la implementación específica de conectar los bloques entre sí. Como resultado, si tenemos varias canalizaciones similares disponibles, puede simplemente copiarlas como un todo, solo haciendo correcciones a implementaciones específicas de los métodos de proceso.En la siguiente imagen, puede observar algo muy similar al trabajo con las clases descritas en la sección anterior. La diferencia es que el anidamiento de los nodos no establece la relación padre-hijo, sino la relación de entrada-salida de los bloques correspondientes. Para organizar el intercambio de datos con bloques no adyacentes, se usa una muleta en forma de un anuncio explícito de salidas, que se justifica por el pequeño número de casos.
Con este enfoque, el número de canales se vuelve indiferente: dos de ellos o 50. El número de etapas del procesamiento de la información también es insignificante (dentro de límites razonables), esto no afecta la simplicidad de la comprensión, en contraste con la expansión de los módulos de texto. Al copiar transportadores en un solo paso, se forma una cadena completamente nueva. Todo está organizado de manera absolutamente idéntica, es fácil hacer cambios incluso después de 5 años, el principio metodológico de organizar la funcionalidad es el mismo, no hay necesidad de crear castillos etéreos en la cabeza a partir de abstracciones.
Adjuntar canalizaciones personalizadas no distorsiona la imagen general, ya que la lógica de trabajar con datos arbitrarios es invariablemente idéntica.
La segunda historia absurda. Necesitaba hacer un juego de Kvent (un análogo directo del juego conocido dentro de un juego aún más conocido, para el juego que usa naipes estándar). Hay muchos enfoques diferentes para la organización del ciclo del juego, una de las opciones ingenuas es la máquina de estado. Con la máquina de estados, todo está bien y es simple en teoría, en la práctica, admitir más de 7 estados en cualquier programa real se vuelve gradualmente aburrido sin agregar un par de capas de abstracciones. En este punto, pensé que el mantenimiento visual de la máquina de estado en forma de árbol es una opción interesante.
Escribimos un generador de código de programa desde un árbol, produce el siguiente resultado:
No hay miedo.
Luego viene un cambio de condición por condición. Se hace sospechosamente.
Fue solo un trato de cartas con el reemplazo de un par de cartas arbitrarias. Ok, comparta una sola máquina en varias máquinas.
A continuación, nace la lógica para procesar la ronda del juego.
En este punto, el límite de aplicabilidad práctica de tal descripción de la máquina de estado está roto, aunque el árbol se ve espeluznante solo si se implementa intencionalmente al cien por cien. Pero todavía hubo efectos completamente no realizados de la influencia de las cartas con imágenes en el transcurso del juego. Se puede suponer que una máquina de eventos para tal tarea sería una mejor solución. Y de nuevo, es fácil hacerlo en los árboles;)
Hurra, el final
En Leo Editor, hay una gran falta de autocompletado normal y resaltado múltiple de la palabra seleccionada ("resaltado inteligente" en el bloc de notas ++). Pero incluso con estos defectos grasos es fácil soportarlo, porque una vez que lo haya probado, ya es imposible prescindir de esta herramienta conveniente en la que puede pintar sin esfuerzo su entorno personal para cualquier tarea. ¿Hay algo similar o mejor en el mundo? Hay muchos monstruos entre los IDE, están extremadamente llenos de funcionalidad inteligente inteligente inteligente, pero ¿cuál de ellos otorga un poder similar sobre la información y cuál de ellos proporciona tanta libertad para organizar el flujo de trabajo?Idea, material, herramienta, producto. En el mundo de la ingeniería, una herramienta de generación anterior le permite pasar a la próxima generación de herramientas más sofisticadas. Hemos pasado de un taladro manual a dispositivos de cultivo con gatos que utilizan electricidad. La programación colgaba en la etapa de buenos tornos, pero en lugar de profundizar, discutimos qué aleación es mejor desde el cortador, y debe alimentar desde arriba o desde el costado. Leo Editor no es la respuesta a las preguntas de mañana, es una señal de lo que se puede hacer mejor.El punto no es que un programador pueda resolver el problema escribiendo código, mientras que el otro "empuja" lo mismo (condicionalmente). Una herramienta en la que puede "hacer clic" (condicionalmente) le permitirá resolver problemas previamente inaccesibles en términos de tiempo y complejidad. En el futuro, necesitaremos programas que escriban en tiempo real millones de programas relacionados, y no tenemos nada para gestionar la complejidad de esta escala.En general, crea tu realidad, y si no hay herramientas necesarias para ello, hazlas, funciona.
UPD Ejemplos de aplicación
Admin : biblioteca de comandos. Simplemente puede almacenarlo, puede ejecutarlo tal como está, puede usar la configuración de argumentos dentro del árbol. Por ejemplo, organice el trabajo con varias bases de datos.
Síntesis algorítmica de la música : organización de la pista
Embedder : organización arbitraria del código en caso de que su entorno tenga medios limitados.Hay dos opciones:1. Dividir el programa en secciones en el orden más favorable2. Si el lenguaje no tiene funciones, se pueden simular usando fantasmas.
Hay tres formas de organizar el orden de ejecución del código:
Pentester : transfiere tu arsenal habitual a tu "ataque de cobalto" personal "