runmany
1.0.0
Introducción | Instalación | Uso | Sintaxis | Configuración | Acerca de
Una herramienta para ejecutar muchos programas escritos en muchos idiomas de un archivo.
Normalmente para practicar múltiples lenguajes de programación a la vez, necesita múltiples archivos o múltiples proyectos, tal vez múltiples IDE. Runmany es una herramienta que le permite escribir múltiples programas en el mismo archivo utilizando cualquier lenguaje de programación que desee, y luego ejecutarlos todos a la vez.
Runmany usa ".many" como extensión de archivo, por ejemplo, si un archivo llamado simple.many tiene los siguientes contenidos:
Python:
print("Hi")
JavaScript:
console.log("Hi")
C:
#include <stdio.h>
int main() {
printf("Hin");
return 0;
}
Luego, hacer runmany simple.many en Terminal producirá esta producción organizada de ejecutar los programas Python, JavaScript y C dentro:
************************************************************
1. Python
-------------------- output from line 1 --------------------
Hi
************************************************************
2. JavaScript
-------------------- output from line 4 --------------------
Hi
************************************************************
3. C
-------------------- output from line 7 --------------------
Hi
************************************************************
3/3 programs successfully run!
3/3 had the exact same stdout!
************************************************************
Argv y Stdin también se pueden especificar en el archivo .many por idioma, y hay muchas configuraciones que pueden personalizar cómo se ejecutan y se muestran los idiomas en la salida.
En general, Runmany se puede usar para:
General Runmany es una herramienta útil para cualquiera que quiera jugar con múltiples lenguajes de programación a la vez.
Asegúrese de tener la versión 3.6 de Python o más, luego ejecute
pip install runmany
en Terminal para instalar el último paquete Runmany Python de Pypi. Entonces runmany <filename> debería funcionar para ejecutar archivos .many. Vea más formas de ejecutar en el uso.
Runmany funciona mejor en VScode con la extensión complementaria Runmany VScode que proporciona una resaltura de sintaxis para archivos. Muchos y formas rápidas de ejecutarlos. Instale la extensión de forma gratuita desde el mercado o ejecutando:
code --install-extension discretegames.runmany
También necesita los lenguajes de programación que desea que Runmany ejecute instalado en su computadora porque Runmany usa sus intérpretes/compiladores detrás de escena para ejecutar programas.
Runmany tiene soporte incorporado para los siguientes idiomas:
Ada, Bash, Batch, C, C#, C ++, Dart, Fortran, GO, Groovy, Haskell, Java, JavaScript, Julia, Kotlin, Lisp, Lua, MIPS, Pascal, Perl, Php, PowerShell, Python, Python, Python 2, R, Raquet, Raquet, Ruby, Rust, WysteScript, Vsbscript, y Visshon, y Visual.
Es decir, si ya tiene uno de estos idiomas instalados, hay una buena posibilidad de que funcione en Runmany automáticamente.
La extensión de Vscode de Runmany proporciona una resaltura de sintaxis para todos estos idiomas, además de algunos más.
Hay formas de agregar lenguajes personalizados y cambiar el comportamiento de los idiomas incorporados, e incluso hacerlos diferentes en diferentes sistemas operativos. Para obtener más información, consulte Personalización de idiomas.
Tenga en cuenta que Print es un lenguaje de utilidad que simplemente imprime el contenido del código a Stdout, y MIPS espera que mars.jar esté en el directorio de trabajo actual.
Si pip install runmany no funcionó, pruebe pip3 install runmany o python -m pip install runmany o python3 -m pip install runmany .
En Windows, si nada funciona, es posible que deba asegurarse de que los directorios de instalación y scripts de Python estén en su variable de entorno de ruta, luego reinicie su terminal e intente nuevamente.
Runmany se hizo en Python 3.9 en Windows y se ha probado a fondo en las versiones de Python 3.6, 3.7, 3.8, 3.9 y 3.10 en Windows. También debería funcionar bien en Linux y MacOS, pero se ha probado menos ampliamente en esos sistemas operativos, especialmente cuando se trata de los comandos que ejecutan los intérpretes/compiladores de otros lenguajes de programación.
Runmany ahora está en la versión 2 con sintaxis de archivos mejorado y más configuraciones. La antigua versión 1.0.3 todavía está disponible en PYPI.
Para ejecutar un archivo Runmany llamado myfile.many Use el comando terminal:
runmany myfile.many
También hay argumentos opcionales para obtener ayuda y especificar la configuración y los archivos de salida:
runmany [-h --help] [-s --settings <settings-file>] [-o --outfile <output-file>] <input-file>
<input-file> es el archivo. Muchy para ejecutar.<settings-file> es el archivo .json opcional que define cómo se ejecutan los idiomas y cómo se formatea la salida.<output-file> es el archivo opcional para enviar la salida. Cuando se omite, la salida va a stdout. Por ejemplo, el comando para ejecutar myfile.many con configuración mysettings.json y enviar salidas a myoutput.txt sería:
runmany -s mysettings.json -o myoutput.txt myfile.many
Cuando se proporciona un archivo de configuración en la línea de comandos, se ignoran las secciones de configuración incrustadas en el archivo de entrada. Si ni hay presente o para ninguna configuración faltante, default_settings.json se usa como alojamiento. Ver más información en Configuración.
Para algunos ejemplos de archivos. Muchos y su salida verifique la carpeta de ejemplos en GitHub o el repositorio de ManyChallenges, donde varios desafíos de código para sitios como Project Euler se resuelven en muchos idiomas a la vez.
La extensión .many para archivos runmany no es necesaria, pero se recomienda para mayor claridad.
Runmany se puede importar y usar desde Python de la siguiente manera:
from runmany import runmany , runmanys
# Run to stdout
runmany ( 'path/to/myfile.many' , 'path/to/mysettings.json' ) # settings JSON is always optional
# Run to output file
runmany ( 'path/to/myfile.many' , 'path/to/mysettings.json' , 'path/to/myoutput.txt' )
# Run to file object
with open ( 'path/to/myoutput.txt' , 'w' ) as output_file :
runmany ( 'path/to/myfile.many' , 'path/to/mysettings.json' , output_file )
# Run to string
output_string = runmanys ( 'path/to/myfile.many' , 'path/to/mysettings.json' )
print ( output_string ) Tanto en las funciones de runmany.runmany como en runmany.runmanys , from_string=True hará que el argumento del archivo .many se interprete como una cadena en lugar de una ruta de archivo, y el argumento de configuración JSON puede dar como una ruta al archivo .json o un diccionario de python tipo JSON, o None para no proporcionar configuraciones. Al igual que con la ejecución de la línea de comandos, proporcionar configuraciones aquí significa que se ignoran todas las configuraciones incrustadas en el archivo .many.
La función runmany.cmdline , que toma una lista de argumentos de la línea de comandos, también está presente como alternativa al uso de la línea de comando directamente.
El formato de archivo .many es lo que Runmany espera cuando se le da un archivo para ejecutar.
Principalmente, un archivo. Muchos consiste en secciones que cada una contiene uno o más fragmentos. Una sección comienza con una línea de encabezado sin sentido como Python: o Stdin for Python: entonces el contenido del primer fragmento es lo que aparece después del colon y en las líneas con sangría a continuación. Se pueden agregar fragmentos adicionales a la sección con Also: un encabezado y una sección termina cuando comienza uno nuevo o un End. o se alcanza el final del archivo.
Un archivo. Muchos se ejecuta de arriba a abajo, ejecutando secciones y fragmentos en el orden en que se encuentran. En particular, un archivo .many se ejecutará independientemente de si tiene errores de sintaxis o no. Cualquier sintaxis no válida será ignorada y mencionada en un mensaje de error.
En el ejemplo de archivo a continuación, el Stdin for Python: la sección tiene dos fragmentos, bar y baz , y se convierten en la entrada estándar para el programa Python en la sección Python: que tiene una print('foo' + input()) . La ejecución de este archivo ejecuta el programa Python dos veces, una vez para bar y una vez para baz , dando las respectivas salidas foobar y foobaz .
Stdin for Python:
bar
Also:
baz
End.
Python:
print('foo' + input())
End.
Siga leyendo para obtener detalles sobre toda la sintaxis de archivo .many, o consulte sintaxis. Many, que también tiene ejemplos de toda sintaxis.
%% como los primeros personajes no blancos en una línea hace un comentario hasta el final de esa línea.
%% this is a comment
Python: %% this is not a comment
%% this is a comment
print(1) %% this is not a comment
No hay comentarios de bloque, aunque Start & Stop tiene una funcionalidad cercana.
Como se mencionó, un archivo. Muchos consiste en secciones que comienzan con un encabezado y contienen fragmentos. Hay cuatro tipos de secciones:
<language>: o <language1>, <language2>, ...:Argv: o Argv for <language1>, <language2>, ...:Stdin: o Stdin for <language1>, <language2>, ...:Settings: Todos menos la sección Configuración pueden tener una lista separada por comas de los idiomas a los que se aplica en el encabezado. Estos idiomas, una vez despojados de espacios en blanco, deben coincidir con las claves "name" de los idiomas en la configuración JSON, pero no son sensibles a las minas. (Las palabras clave como "argv" y "stdin" son sensibles a los casos. Los lenguajes personalizados no deben usar las palabras clave de Runmany como nombres ni contienen los caracteres ,:%!@ .)
El encabezado Also: se usa para agregar fragmentos a una sección y End. Opcionalmente se puede usar para finalizar una sección.
El contenido de un fragmento es el texto después de cualquier espacio en blanco después del colon ( : en el encabezado del fragmento, más todas las líneas a continuación que están sangradas con una sola pestaña o 4 espacios (con estos sangros eliminados), hasta el siguiente encabezado o End. o final del archivo.
Entonces esta sección de código
Python: import math
print(math.pi)
Also: print('pie')
print('cake')
tiene dos fragmentos cuyos contenidos son:
import math
print ( math . pi ) print ( 'pie' )
print ( 'cake' )Las líneas en blanco por encima o por debajo de las secciones son solo para legibilidad y no requeridas. El código sin comisión fuera de las secciones no es válido.
Una sección de código comienza con una lista de idiomas separados por comas y su contenido de fragmento son los programas que se ejecutarán en esos idiomas.
Un idioma en la lista separada por coma es casi siempre suficiente a menos que esté escribiendo políglotas,
JavaScript:
console.log('Some code that will be run in JavaScript.')
Python, Python 2:
print('Some code that will be run in Python 3 then Python 2.')
Also:
print('Some more code that will be run in Python 3 then Python 2.')
Also: los encabezados de fragmento en las secciones del código son abreviadas para repetir el encabezado de la sección.
Argv es el vector de argumentos, también conocido como los argumentos de la línea de comandos enviados a los programas.
Una sección de Argv puede comenzar Argv: para aplicar a todos los idiomas, o Argv for <language1>, <language2>, ...: aplicar a los idiomas en la lista separada por comas. De cualquier manera, sobrescribe cualquier argv de Argv anterior para esos idiomas.
Cada fragmento en una sección Argv es un argv separado que se enviará a su vez a los programas de los idiomas a los que se aplica la sección. Esto facilita la prueba de muchos argvs a la vez.
Argv: argv sent to all languages
Argv for Python: 1
Also: 2
Also: 3
Python:
import sys
print(sys.argv[1])
Este código. Muchos Código ejecutarán el programa Python tres veces con Argv 1 y luego 2 y luego 3 .
Para que Argv funcione, el marcador de posición $argv debe colocarse correctamente en el comando del idioma.
Casi exactamente como una sección de Argv, pero para el flujo de entrada estándar, los usuarios normalmente escriben texto.
Una sección de Stdin puede comenzar Stdin: para aplicar a todos los idiomas, o Stdin for <language1>, <language2>, ...: aplicar a los idiomas en la lista separada por comas. De cualquier manera, sobrescribe cualquier stdin anterior para esos idiomas.
Cada fragmento en una sección Stdin es un Stdin separado que se enviará a su vez a los programas de los idiomas a los que solicita la sección. Esto facilita la prueba de muchos Stdins a la vez.
Stdin: stdin sent to all languages
Stdin for Python: A
Also: B
Also: C
Python:
print(input())
Este código. Muchos Código ejecutarán el programa Python tres veces con Stdin A , entonces B , entonces C .
Cuando múltiples argvs y Stdins se aplican a un idioma, todas las combinaciones posibles de cada argv y cada stdin se envían a programas de ese idioma.
Una sección de configuración comienza con Settings: y permite incrustar una configuración JSON en un archivo .many, que se usa hasta que se encuentra otra sección de configuración.
Estas configuraciones integradas solo se usan cuando la configuración no se proporcionó específicamente cuando se llamaba a Runmany. Cualquier configuración faltante predeterminada a sus valores en default_settings.json.
Settings:
{ "show_code": true }
Python:
print('this Python code will now be shown as part of the output')
También se puede usar una cadena JSON de la ruta a un archivo de configuración, como Settings: "path/to/mysettings.json" .
Also: los encabezados de fragmento en las secciones de configuración son abreviadas para repetir el encabezado de la sección. Por lo tanto, no tienen mucho propósito ya que inmediatamente sobrescriben la configuración anterior.
¡Putt !! Al comienzo de un encabezado de sección, deshabilita toda la sección y todos sus fragmentos.
¡Poniendo ! Al comienzo de un encabezado de fragmento, desactiva ese fragmento.
!!Python:
print('this is disabled')
Also:
print('this is also disabled')
!Python:
print('this is disabled')
Also:
print('this is not disabled')
!Also:
print('this is disabled')
Si algún encabezado de sección comienza con @@ , solo se ejecutan esas secciones, similar a una casilla de verificación "Solo" en el software de edición de audio/video.
Si algún encabezado de fragmento dentro de una sección comienza con @ , solo se ejecutan esos fragmentos cuando se ejecuta la sección.
@@@Python:
print('this is run')
Also:
print('this is not run')
@Also:
print('this is run')
Python:
print('this is not run')
@Also:
print('this is also not run')
Tenga en cuenta cómo la primera línea tiene tres @@@ , dos para solos la sección y otra para solo su primer fragmento.
Todo antes del último START: al comienzo de una línea por sí solo en un archivo. Muchos archivos se ignora.
Todo después de la primera STOP. Al comienzo de una línea por sí solo en un archivo. Muchos archivos se ignora.
Entonces, solo se ejecuta la sección JavaScript de este archivo .many:
Python: print('unseen')
START:
JavaScript: console.log('seen')
STOP.
Python: print('unseen')
Solo debería haber hasta un START: y una STOP. En un archivo .many.
La configuración de Runmany se define mediante un archivo JSON que se puede proporcionar cuando se llama a Runmany o se incrusta directamente en un archivo .many.
La configuración JSON define qué idiomas puede ejecutar y cómo los ejecutará. También define cómo se formateará la salida Runmany.
El archivo default_settings.json contiene los valores predeterminados para todas las configuraciones. Estos valores predeterminados se usan automáticamente si no están presentes en una configuración proporcionada o integrada JSON.
La mayoría de las configuraciones son banderas o valores simples que se pueden configurar en la configuración base JSON Object para aplicarlos a nivel mundial (ver lista de configuraciones) pero se utilizan cuatro claves especiales en el JSON para personalizar los idiomas que Runmany puede ejecutar o agregar más idiomas. Estos son "languages" , "languages_windows" , "languages_linux" y "languages_mac" ( "languages_<os>" se utilizará para referirse a los tres últimos). Son matrices de objetos JSON de nivel único que especifican la configuración del idioma que coincide con la clave "name" del objeto.
La matriz "languages_<os>" que coincide con el sistema operativo del sistema tiene la más alta prioridad al determinar la configuración de un idioma, seguida de la matriz "languages" , seguida de la matriz incorporada "supplied_languages_<os>" y "supplied_languages" . (Estas matrices "supplied_languages..." nunca deben establecerse en su configuración JSON). Los idiomas usan la configuración en el objeto Base JSON como un retroceso final.
Por ejemplo, la siguiente configuración JSON establece la configuración "show_code" (que es falsa de forma predeterminada) a verdaderas para todos los idiomas, excepto para Python y Python 2. También crea un nuevo idioma "Python 3.10" que se puede usar en un encabezado de sección de archivo.
{
"show_code" : true ,
"languages" : [
{ "name" : " Python " , "show_code" : false },
{ "name" : " Python 2 " , "show_code" : false }
],
"languages_windows" : [
{ "name" : " Python 3.10 " , "extension" : " .py " , "command" : " py -3.10 " }
]
} Se requiere la tecla "name" para cada objeto en una matriz de idiomas, y las teclas "command" y "extension" siempre deben proporcionarse para nuevos idiomas personalizados. Sin embargo, no todas las configuraciones tienen sentido para aplicar por idioma. Por ejemplo, "show_equal" se aplica a la ejecución del archivo .many en su conjunto, por lo que solo tiene sentido en el objeto JSON base.
Todas las configuraciones se describen y si pueden o no ser anuladas por otro idioma en los objetos de matriz "languages" y "languages_<os>" :
| Llave json | Tipo | Por defecto | Anulable | Descripción |
|---|---|---|---|---|
"command" | cadena | "echo NOCOMMAND" | Sí | El comando de la consola para ejecutar un idioma, siguiendo el formato de comando. |
"extension" | cadena | "" | Sí | La extensión del archivo de un idioma, incluido el punto. |
"timeout" | flotar | 10.0 | Sí | El límite de tiempo de cada programa en segundos, o null sin límite de tiempo. |
"runs" | intencionalmente | 1 | Sí | El número de veces que se ejecuta cada programa. Solo se muestra la salida de la última ejecución. |
"stderr" | cadena | "smart" | Sí | "yes" / true para combinar el programa Stderr con StDout. "no" / false para ocultar el programa stderr. "smart" / null para mostrar solo Stderr cuando los programas tienen códigos de salida no cerosos. |
"spacing" | intencionalmente | 1 | Sí | El número de líneas en blanco para agregar después de cada ejecución. |
"newline" | cadena | "n" | Sí | Con qué nuevas líneas se reemplazan en Code, Argv y Stdin Fnippet Content. O null para el valor predeterminado del sistema operativo. |
"tab" | cadena | "t" | Sí | Con el que se reemplaza el personaje de pestaña en Code, Argv y Stdin Snippet Content. |
"cwd" | cadena | null | Sí | El directorio de trabajo actual para ejecutar programas desde. Puede ser un camino relativo. Use null o "." Sin cambios en el directorio de trabajo actual. |
"minimalist" | bool | false | No | Si debe mostrar toda la salida en un formato mínimo donde no se muestran los divisores, el código, el argv y el stdin. |
"run_blanks" | bool | false | No | Si se ejecutan o ignoran los fragmentos en blanco que consisten puramente de espacios blancos. |
"show_time" | bool | false | Sí | Si se muestra el tiempo de ejecución. Útil para pruebas de rendimiento cuando se combina con "runs" . |
"show_command" | bool | false | Sí | Se muestra si se muestra el comando utilizado para ejecutar cada programa. Útil para los comandos de depuración para nuevos idiomas. |
"show_code" | bool | false | Sí | Si se muestra el código fuente del programa. |
"show_argv" | bool | true | Sí | Si se muestra el argv para el programa (cuando está presente). |
"show_stdin" | bool | true | Sí | Si se muestra el stdin para el programa (cuando está presente). |
"show_output" | bool | true | Sí | Si se muestra la salida para el programa. Esto incluye el stdout y, dependiendo de "stderr" , el stderr. |
"show_runs" | bool | true | No | Se muestra la lista de ejecuciones. Esta suele ser la mayor parte de la salida. |
"show_stats" | bool | true | No | Si los recuentos de éxito y fracaso se muestran después de que todo se haya ejecutado. |
"show_equal" | bool | true | No | Si los stdouts coincidentes se comparan y se agrupan después de que todo se ha ejecutado. |
"show_errors" | bool | true | No | Si los errores de lanzamiento como ` |
"strip_argv" | cadena | "smart" | No | "yes" / true para despojar el contenido de fragmento de espacios en blanco liderantes y finales. "no" / false para mantener el contenido de fragmento tal como está. "smart" / null para unir todas las líneas en el fragmento junto con los espacios como si estuvieran en una línea. |
"strip_stdin" | cadena | "smart" | No | "yes" / true para quitar el inicio y el final del fragmento de líneas solo para espacios en blanco. "no" / false para mantener el contenido de fragmento tal como está. "smart" / null para hacer lo mismo que "yes" / true , pero también agregar una sola nueva línea. |
"strip_code" | cadena | "smart" | Sí | "yes" / true para quitar el inicio y el final del fragmento de líneas solo para espacios en blanco. "no" / false para mantener el contenido de fragmento tal como está. "smart" / null para tratar la parte superior del archivo .many como el inicio del fragmento de código con todas las partes irrelevantes en blanco, por lo que los errores en los programas informan números de línea correctos. |
"strip_output" | cadena | "no" | Sí | "yes" / true del programa Fiel to Strip de espacios en blanco liderantes y finales. "no" / false para dejar la salida del programa tal como está. La salida del programa "smart" / null to Strip del programa de liderazgo vacío y finales. |
Debe mencionarse que las partes del código, Argv y Stdin de la salida del archivo .many están despojadas de líneas vacías para mantener las cosas visualmente limpias independientemente de los valores de "strip_code" , "strip_argv" y "strip_stdin" .
La clave "command" de un objeto en la matriz "languages" o "languages_<os>" define el comando terminal que se ejecuta para ejecutar ese idioma.
Los marcadores de posición como $file y $dir se pueden usar en un comando para referirse al archivo temporal que Runmany crea para el código de cada programa que ejecuta y el directorio en el que se almacena el archivo:
| Marcador de posición | Porción de .../dir/file.ext |
|---|---|
$rawdir | .../dir |
$dir | ".../dir" |
$rawfile | .../dir/file.ext |
$file | ".../dir/file.ext" |
$rawbranch | .../dir/file |
$branch | ".../dir/file" |
$name | file.ext |
$stem | file |
$ext | .ext |
$sep | / (OS específico) |
$argv | n/a - El argv se inserta aquí |
$code | N/A - El contenido de fragmento en bruto |
Tenga en cuenta que algunos marcadores de posición son "citados" y otros no. Algunos sistemas operativos como Windows pueden tener espacios en la ruta a los archivos temporales, por lo que la cita correcta es importante.
Si $ no está presente en ninguna parte de la cadena de comando, $file $argv se adjunta a él. Por ejemplo, el comando python es implícitamente python $file $argv .
Verifique la matriz "supplied_languages" en default_settings.json para obtener más ejemplos de comandos.
Estaba impulsado a hacer Runmany por mi deseo de aprender más lenguajes de programación, combinados con mi molestia de que cada vez que lo intentaba invariablemente tendría que hacer un proyecto completamente nuevo para ese idioma, o incluso cambiar de ides.
Planeo usarlo para practicar la resolución de desafíos de código en varios idiomas de sitios como Project Euler.
Echa un vistazo a algunos de mis otros paquetes de Python.
