runmany
1.0.0
Introdução | Instalação | Uso | Sintaxe | Configurações | Sobre
Uma ferramenta para executar muitos programas escritos em vários idiomas de um arquivo.
Normalmente, para praticar várias linguagens de programação ao mesmo tempo, você precisa de vários arquivos ou vários projetos, talvez vários IDEs. RunMany é uma ferramenta que permite escrever vários programas no mesmo arquivo usando qualquer linguagem de programação desejada e executá -los de uma só vez.
RunMany usa ".Many" como extensão de arquivo, por exemplo, se um arquivo chamado simple.many tiver o seguinte conteúdo:
Python:
print("Hi")
JavaScript:
console.log("Hi")
C:
#include <stdio.h>
int main() {
printf("Hin");
return 0;
}
Em seguida, fazer runmany simple.many in Terminal produzirá esta produção organizada de execução dos programas Python, JavaScript e C dentro de:
************************************************************
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!
************************************************************
O ARGV e o STDIN também podem ser especificados no arquivo. Muitos por uma base por linguagem, e existem muitas configurações que podem personalizar como os idiomas são executados e exibidos na saída.
Em geral, RunMany pode ser usado para:
O RunMany, em geral, é uma ferramenta útil para quem deseja brincar com várias linguagens de programação por vez.
Certifique -se de ter o Python versão 3.6 ou acima do instalado e, em seguida, execute
pip install runmany
no terminal para instalar o mais recente pacote RunMany Python da Pypi. Em seguida, runmany <filename> deve trabalhar para executar arquivos. Muitos. Veja mais maneiras de executar em uso.
RunMany funciona melhor no VSCode com a extensão Companion RunMany VScode, que fornece sintaxe destacando para muitos arquivos e maneiras rápidas de executá -las. Instale a extensão gratuitamente no mercado ou executando:
code --install-extension discretegames.runmany
Você também precisa das linguagens de programação que você deseja executar o RunMany instalado no seu computador, porque RunMany usa seus intérpretes/compiladores nos bastidores para realmente executar programas.
RunMany tem suporte interno para os seguintes idiomas:
Ada, Bash, Batch, C, C#, C++, Dart, Fortran, Go, Groovy, Haskell, Java, JavaScript, Julia, Kotlin, Lisp, Lua, MIPS, Pascal, Perl, PHP, PowerShell, Print, Python, Python 2, R, Racket, Ruby, Rust, Scala, TypeScript, VBScript, and Visual Basic
Ou seja, se você já possui um desses idiomas instalados, há uma boa chance de funcionar em RunMany automaticamente.
A extensão RunMany VSCode fornece destaque para todos esses idiomas e mais alguns.
Existem maneiras de adicionar linguagens personalizadas e alterar o comportamento dos idiomas internos e até torná-los diferentes em diferentes sistemas operacionais. Para mais informações, consulte Linguagens de personalização.
Observe que a Print é um idioma utilitário que simplesmente imprime o conteúdo do código para Stdout, e MIPS espera que mars.jar esteja no diretório de trabalho atual.
Se pip install runmany não funcionou, tente pip3 install runmany ou python -m pip install runmany ou python3 -m pip install runmany .
No Windows, se nada funcionar, pode ser necessário garantir que os diretórios de instalação e scripts do Python estejam na sua variável de ambiente de caminho, reinicie seu terminal e tente novamente.
RunMany foi fabricado no Python 3.9 no Windows e foi minuciosamente testado nas versões Python 3.6, 3.7, 3,8, 3,9 e 3.10 nas janelas. Também deve funcionar bem no Linux e no MacOS, mas tem sido testado menos extensivamente nesses sistemas operacionais, especialmente quando se trata dos comandos que executam os intérpretes/compiladores de outras linguagens de programação.
RunMany está agora na versão 2 com uma sintaxe de arquivo. Muitos e mais configurações. A versão antiga 1.0.3 ainda está disponível no Pypi.
Para executar um arquivo RunMany chamado myfile.many , use o comando do terminal:
runmany myfile.many
Também existem argumentos opcionais para obter ajuda e especificar as configurações e arquivos de saída:
runmany [-h --help] [-s --settings <settings-file>] [-o --outfile <output-file>] <input-file>
<input-file> é o arquivo. Muitos no arquivo. Muitos a serem executados.<settings-file> é o arquivo .json opcional que define como os idiomas são executados e como a saída é formatada.<output-file> é o arquivo opcional para o envio da saída. Quando omitido, a saída vai para o stdout. Por exemplo, o comando para executar myfile.many com as configurações mysettings.json e enviar saída para myoutput.txt seria:
runmany -s mysettings.json -o myoutput.txt myfile.many
Quando um arquivo de configurações é fornecido na linha de comando, quaisquer seções de configurações incorporadas no arquivo de entrada são ignoradas. Se nenhum deles estiver presente, ou para qualquer configuração ausente, o Default_settings.json é usado como fallback. Veja mais informações nas configurações.
Para alguns exemplos de arquivos. Muitos e sua saída, verifique a pasta Exemplos no Github ou o repo ManyChalleges, onde vários desafios de código para sites como o Project Euler são resolvidos em muitos idiomas ao mesmo tempo.
A extensão. Muitos arquivos RunMany não são necessários, mas recomendados para maior clareza.
RunMany pode ser importado e usado do Python da seguinte forma:
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 ) Nas funções runmany.runmany e runmany.runmanys , from_string=True farão com que o argumento do None . Assim como a execução da linha de comando, fornecer configurações aqui significa que todas as configurações incorporadas no arquivo. Muitos são ignorados.
A função runmany.cmdline , que leva uma lista de argumentos da linha de comando, também está presente como uma alternativa ao uso diretamente da linha de comando.
O formato de arquivo. Muitos é o que RunMany espera quando recebe um arquivo a ser executado.
Principalmente, um arquivo. Muitos consiste em seções que contêm um ou mais trechos. Uma seção começa com uma linha de cabeçalho não independente, como Python: ou Stdin for Python: então o conteúdo do primeiro trecho é o que aparece depois do cólon e nas linhas recuadas abaixo. Os trechos adicionais podem ser adicionados à seção com um não indentado Also: cabeçalho, e uma seção termina quando um novo inicia ou uma End. ou o final do arquivo é alcançado.
Um arquivo. Muitos é executado de cima para baixo, executando seções e trechos na ordem em que são encontrados. Notavelmente, um arquivo. Muitos será executado independentemente de ter erros de sintaxe ou não. Qualquer sintaxe inválida será ignorada e mencionada em uma mensagem de erro.
No exemplo. Muitos arquivos abaixo, o Stdin for Python: a seção possui dois trechos, bar e baz , e eles se tornam a entrada padrão para o programa Python na seção Python: que possui um snippet print('foo' + input()) . A execução deste arquivo executa o programa Python duas vezes, uma para bar e uma vez para baz , dando aos respectivos saídas foobar e foobaz .
Stdin for Python:
bar
Also:
baz
End.
Python:
print('foo' + input())
End.
Continue lendo para obter detalhes sobre toda a sintaxe de arquivo. Muitos arquivos ou confira a sintaxe.
%% como os primeiros caracteres não-espaciais em uma linha faz um comentário até o final dessa linha.
%% this is a comment
Python: %% this is not a comment
%% this is a comment
print(1) %% this is not a comment
Não há comentários em bloco, embora o Start & Stop esteja próximo em funcionalidade.
Como mencionado, um arquivo. Muitos consiste em seções que começam com um cabeçalho e contêm trechos. Existem quatro tipos de seções:
<language>: ou <language1>, <language2>, ...:Argv: ou Argv for <language1>, <language2>, ...:Stdin: ou Stdin for <language1>, <language2>, ...:Settings: Todos, exceto a seção de configurações, podem ter uma lista separada por vírgula dos idiomas aos quais se aplica no cabeçalho. Esses idiomas, uma vez despojados do espaço em branco, devem corresponder às teclas "name" dos idiomas nas configurações JSON, mas não são sensíveis ao caso. (Palavras -chave como "argv" e "stdin" são sensíveis ao caso. Os idiomas personalizados não devem usar as palavras -chave RunMany como nomes nem conter os caracteres ,:%!@ .)
O cabeçalho Also: é usado para adicionar trechos a uma seção e End. Opcionalmente pode ser usado para encerrar uma seção.
O conteúdo de um snippet é o texto após qualquer espaço em branco após o cólon ( : no cabeçalho do snippet, além de todas as linhas abaixo que são recuadas com uma única guia ou 4 espaços (com esses recuos removidos), até o próximo cabeçalho ou End. ou final do arquivo.
Então, esta seção de código
Python: import math
print(math.pi)
Also: print('pie')
print('cake')
tem dois trechos cujo conteúdo é:
import math
print ( math . pi ) print ( 'pie' )
print ( 'cake' )As linhas em branco acima ou abaixo das seções são apenas para legibilidade e não são necessárias. O código não declarado fora das seções é inválido.
Uma seção de código inicia com uma lista separada por vírgula de idiomas e seu conteúdo de snippet são os programas a serem executados nesses idiomas.
Um idioma na lista separada por vírgula é quase sempre suficiente, a menos que você esteja escrevendo poliglotas,
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: os cabeçalhos de snippet nas seções de código são abreviados para repetir o cabeçalho da seção.
Argv é o vetor de argumento, também conhecido como os argumentos da linha de comando enviados aos programas.
Uma seção ARGV pode iniciar Argv: aplicar a todos os idiomas ou Argv for <language1>, <language2>, ...: aplicar aos idiomas na lista separada por vírgula. De qualquer maneira, substitui qualquer argv anterior para esses idiomas.
Cada trecho de uma seção ARGV é um ARGV separado que será enviado para os programas dos idiomas aos quais a seção se aplica. Isso facilita testar muitos argvs de uma só vez.
Argv: argv sent to all languages
Argv for Python: 1
Also: 2
Also: 3
Python:
import sys
print(sys.argv[1])
Esse código. Muitos executarão o programa Python três vezes com o argv 1 e depois 2 e 3 .
Para que o ARGV trabalhe, o espaço reservado $argv deve ser colocado corretamente no comando do idioma.
Quase exatamente como uma seção ARGV, mas para os usuários padrão de fluxo de entrada normalmente digitam o texto.
Uma seção STDIN pode iniciar Stdin: para aplicar a todos os idiomas ou Stdin for <language1>, <language2>, ...: aplicar aos idiomas na lista separada por vírgula. De qualquer maneira, substitui qualquer conjunto anterior do Stdin para esses idiomas.
Cada trecho de uma seção STDIN é um Stdin separado que será enviado, por sua vez, aos programas dos idiomas aos quais a seção se aplica. Isso facilita testar muitos stdins de uma só vez.
Stdin: stdin sent to all languages
Stdin for Python: A
Also: B
Also: C
Python:
print(input())
Esse código. Muitos executarão o programa Python três vezes com o stdin A e depois B e depois C .
Quando vários argvs e stdins se aplicam a um idioma, todas as combinações possíveis de todas as argv e todos os stdin são enviados para programas desse idioma.
Uma seção de configurações começa com Settings: e permite incorporar uma configuração JSON em um arquivo. Muitos, que é usado até que outra seção de configurações seja encontrada.
Essas configurações incorporadas são usadas apenas quando as configurações não foram fornecidas especificamente quando RunMany foi chamado. Quaisquer configurações ausentes padrão para seus valores em default_settings.json.
Settings:
{ "show_code": true }
Python:
print('this Python code will now be shown as part of the output')
Uma sequência JSON do caminho para um arquivo de configurações também pode ser usada, como Settings: "path/to/mysettings.json" .
Also: os cabeçalhos de snippet nas seções de configurações são abreviadas para repetir o cabeçalho da seção. Portanto, eles não terão muito objetivo, pois substituem imediatamente as configurações anteriores.
Colocando !! No início de um cabeçalho de seção, desativa a seção inteira e todos os seus trechos.
Colocando ! No início de um cabeçalho de snippet, desativa esse trecho.
!!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')
Se qualquer cabeçalho de seção começar com @@ , apenas essas seções serão executadas, semelhante a uma caixa de seleção "Solo" no software de edição de áudio/vídeo.
Se algum toque de snippet dentro de uma seção iniciar com @ , apenas esses trechos serão executados quando a seção é executada.
@@@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')
Observe como a primeira linha tem três @@@ , dois para solo a seção e outra para solo seu primeiro snippet.
Tudo antes da última START: no início de uma linha por si só, em um arquivo. Muitas coisas são ignoradas.
Tudo após a primeira STOP. No início de uma linha por si só, em um arquivo. Muitos é ignorado.
Portanto, apenas a seção JavaScript deste arquivo. Many é executada:
Python: print('unseen')
START:
JavaScript: console.log('seen')
STOP.
Python: print('unseen')
Deveria haver apenas um START: e uma STOP. em um arquivo. muitos.
A configuração de RunMany é definida por um arquivo JSON que pode ser fornecido quando RunMany é chamado ou diretamente incorporado em um arquivo. Muitos.
As configurações JSON definem quais idiomas RunMany podem executar e como as executará. Ele também define como a saída RunMany será formatada.
O arquivo default_settings.json detém os valores padrão para todas as configurações. Esses padrões são usados automaticamente se não estiverem presentes em um JSON de configurações fornecidas ou incorporadas.
A maioria das configurações são sinalizadores ou valores simples que podem ser definidos no objeto JSON de configurações de base para aplicá -las globalmente (consulte a lista de configurações), mas quatro chaves especiais no JSON são usadas para personalizar os idiomas que RunMany pode ser executado ou para adicionar mais idiomas. São "languages" , "languages_windows" , "languages_linux" e "languages_mac" ( "languages_<os>" serão usados para se referir aos três últimos). São matrizes de objetos JSON de nível único que especificam as configurações para o idioma que corresponde à tecla "name" do objeto.
A matriz "languages_<os>" que corresponde ao sistema operacional do sistema tem maior prioridade ao determinar as configurações de um idioma, seguidas pela matriz "languages" , seguidas pelas matrizes "supplied_languages_<os>" e "fornecimento" e "supplied_languages" . (Essas matrizes "supplied_languages..." nunca devem ser definidas em suas configurações JSON.) Os idiomas usam as configurações no objeto JSON base como um fallback final.
Por exemplo, as seguintes configurações JSON definem a configuração "show_code" (que é falsa por padrão) como true para todos os idiomas, exceto para Python e Python 2. Também cria um novo idioma "Python 3.10" que pode ser usado em um cabeçalho da seção de arquivos.
{
"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 " }
]
} A tecla "name" é necessária para todos os objetos em uma matriz de idiomas, e as teclas "command" e "extension" devem sempre ser fornecidas para novos idiomas personalizados. Nem toda configuração faz sentido se aplicar em uma base por língua. Por exemplo, "show_equal" se aplica à execução do arquivo. Muitos como um todo, por isso só faz sentido no objeto JSON base.
Todas as configurações descritas e se elas podem ou não ser substituídas em uma base por língua nos objetos de matriz "languages" e "languages_<os>" :
| Chave JSON | Tipo | Padrão | Superestável | Descrição |
|---|---|---|---|---|
"command" | corda | "echo NOCOMMAND" | sim | O comando do console para executar um idioma, seguindo o formato de comando. |
"extension" | corda | "" | sim | A extensão do arquivo de um idioma, incluindo o ponto. |
"timeout" | flutuador | 10.0 | sim | O prazo de cada programa em segundos, ou null sem limite de tempo. |
"runs" | int | 1 | sim | O número de vezes que cada programa é executado. Somente a saída da última execução é mostrada. |
"stderr" | corda | "smart" | sim | "yes" / true para combinar o programa Stderr com o stdout. "no" / false para ocultar o programa Stderr. "smart" / null para mostrar apenas Stderr quando os programas têm códigos de saída diferentes de zero. |
"spacing" | int | 1 | sim | O número de linhas em branco para adicionar após cada execução. |
"newline" | corda | "n" | sim | Com o que as novas linhas são substituídas no conteúdo de snippet de código, argv e stdin. Ou null para o padrão do sistema operacional. |
"tab" | corda | "t" | sim | Com o que o caractere da guia é substituído no conteúdo de snippet de código, argv e stdin. |
"cwd" | corda | null | sim | O diretório de trabalho atual para executar programas. Pode ser um caminho relativo. Use null ou "." sem alteração no diretório de trabalho atual. |
"minimalist" | bool | false | não | Se deve exibir toda a saída em um formato mínimo em que os divisores, código, argv e stdin não são mostrados. |
"run_blanks" | bool | false | não | Se os trechos em branco que consistem puramente em espaço em branco são executados ou ignorados. |
"show_time" | bool | false | sim | Se o tempo de execução é mostrado. Útil para testes de desempenho quando combinado com "runs" . |
"show_command" | bool | false | sim | Se o comando usado para executar cada programa é mostrado. Útil para depurar comandos para novos idiomas. |
"show_code" | bool | false | sim | Se o código -fonte do programa é mostrado. |
"show_argv" | bool | true | sim | Se o argv para o programa é mostrado (quando presente). |
"show_stdin" | bool | true | sim | Se o stdin para o programa é mostrado (quando presente). |
"show_output" | bool | true | sim | Se a saída para o programa é mostrada. Isso inclui o stdout e, dependendo de "stderr" , o Stderr. |
"show_runs" | bool | true | não | Se a lista de execuções é mostrada. Esta é geralmente a maior parte da saída. |
"show_stats" | bool | true | não | Se o sucesso e a contagem de falhas são mostrados após a execução de tudo. |
"show_equal" | bool | true | não | Se os stdouts correspondentes são comparados e agrupados após a execução de tudo. |
"show_errors" | bool | true | não | Se os erros de RunMany como ` |
"strip_argv" | corda | "smart" | não | "yes" / true para retirar o conteúdo do snippet do espaço em branco principal e à direita. "no" / false para manter o conteúdo do snippet como está. "smart" / null para se juntar a todas as linhas no trecho junto com os espaços como se estivessem em uma linha. |
"strip_stdin" | corda | "smart" | não | "yes" / true para tirar o início e o final do trecho de linhas somente de espaço em branco. "no" / false para manter o conteúdo do snippet como está. "smart" / null para fazer o mesmo que "yes" / true , mas também anexar uma única nova linha. |
"strip_code" | corda | "smart" | sim | "yes" / true para tirar o início e o final do trecho de linhas somente de espaço em branco. "no" / false para manter o conteúdo do snippet como está. "smart" / null para tratar a parte superior do arquivo. Muitos como o início do snippet de código com todas as peças irrelevantes que os erros nos programas relatam números de linha corretos. |
"strip_output" | corda | "no" | sim | "yes" / true to Strip Program Sapath of lidence e arrastando espaço em branco. "no" / false para deixar a saída do programa como está. "smart" / null TO TILHO O PROGRAMA SAPATE DE LINHAS PRINCIPAL E PROTIVAS EXBOLAMENTE. |
Deve -se mencionar que as partes do código, argv e stdin da saída do arquivo. Muitas são despojadas de linhas vazias para manter as coisas visualmente limpas, independentemente dos valores de "strip_code" , "strip_argv" e "strip_stdin" .
A tecla "command" de um objeto nos "languages" ou "languages_<os>" define o comando de terminal que é executado para executar esse idioma.
Os espaços reservados como $file e $dir podem ser usados em um comando para se referir ao arquivo temporário que RunMany cria para o código de cada programa que ele é executado e o diretório em que o arquivo é armazenado:
| Espaço reservado | Parte 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 - o argv é inserido aqui |
$code | N/A - O teor de trechos crus |
Observe que alguns espaços reservados são "citados" e outros não. Alguns sistemas operacionais como o Windows podem ter espaços no caminho para arquivos temporários, para que a citação correta seja importante.
Se $ não estiver presente em nenhum lugar da sequência de comando, $file $argv será anexado a ele. Por exemplo, o comando python é implicitamente python $file $argv .
Verifique a matriz "supplied_languages" em Default_settings.json para obter mais exemplos de comandos.
Fui levado a fazer RunMany pelo meu desejo de aprender mais linguagens de programação, combinadas com meu aborrecimento de que, sempre que eu tentava, invariavelmente teria que fazer um projeto totalmente novo para esse idioma, ou até mudar de IDES.
Eu pretendo usá -lo para praticar a solução de desafios de código em vários idiomas de sites como o Project Euler.
Confira alguns dos meus outros pacotes Python.
