Como posso criar um comando com argumentos e um arquivo de configuração? [fechadas]

Question

Diretamente ao ponto, quero dar ao usuário a flexibilidade de passar argumentos para um comando, a fim de controlar como os comandos devem ser executados, algo como:

pcap -d 30 -w 2

Em outras palavras:

Eu quero fazer um comando que se pareça exatamente com os comandos do Linux. Um comando que funciona exatamente como comandos do Linux. Um comando que possui opções (por exemplo, argumentos) no mesmo estilo dos comandos do Linux.

Eu quero criar um comando que trabalhe pegando argumentos do usuário ou usando seus argumentos padrão (lidos de um arquivo de configuração) caso nenhum argumento seja fornecido pelo usuário, exatamente como qualquer outro comando do Linux.

Um comando com --help que mostra as diferentes opções.

Eu sei como fazer um comando no Linux. Mas eu não sei como fazer essas opções (argumentos de comando). Eu não sei como esses argumentos são programados.

um guia, um tutorial ou um exemplo farão

Nota :

1. Desculpas se esta pergunta for feita na pilha errada.
2. Também peço desculpas pela versão anterior da pergunta, que foi mal formulada.

Answer 1

Como você mencionou python , uma resposta em python:

se você quiser simplesmente definir um valor padrão para um argumento, você pode simplesmente definir o padrão para a função:

def show(val = 30):
    print(val)
# to print the default value (30)
show()
# to show another value (e.g. 40)
show(40)

Em outras palavras, isso irá imprimir o valor padrão se você não der nenhum argumento, enquanto ele usa o argumento se você o der.

Mais avançado; lendo os valores padrão de um arquivo, com a opção de anular por dando os argumentos

O mesmo pode ser feito, mas lendo argumentos padrão de um arquivo. Isso dará a oportunidade de definir argumentos em um arquivo de configurações, em vez de editá-los no próprio código.

Digamos que eu tenha um arquivo de configurações, testconf.txt :

length:4
height:7
width:6

... e quero ler esses valores em meu aplicativo como argumentos padrão , mas o usuário pode anulá-los por argumentos personalizados:

#!/usr/bin/env python3
import sys

# path to my config file
conf_file = "/home/jacob/Bureaublad/testconf.txt"
# read the default arguments from a file
def_args = [l.strip() for l in open(conf_file).readlines()]
# replace default args by possible custom args
cust_args = sys.argv[1:]
for cu in cust_args:
    argname = cu.split(":")[0]
    try:
        match = [arg for arg in def_args if arg.startswith(argname)][0]
    except IndexError:
        print("incorrect argument: ", cu)
    else:
        def_args[def_args.index(match)] = cu

def get_arg(s):
    return [val.split(":")[1] for val in def_args if val.startswith(s)][0]

l = get_arg("length")
w = get_arg("width")
h = get_arg("height")

print("l=", l, "w=", w, "h=", h)

Agora posso executar o script sem argumentos:

$ '/home/jacob/Bureaublad/pscript_4.py'
l= 4 w= 6 h= 7

ou argumentos de largura:

$ '/home/jacob/Bureaublad/pscript_4.py' length:10 height:456
l= 10 w= 6 h= 456

A ordem dos argumentos dados é, nessa configuração, irrelevante. No caso de um argumento incorreto:

$ '/home/jacob/Bureaublad/pscript_4.py' monkey
incorrect argument:  monkey
l= 4 w= 6 h= 7

Nota

No software "real", você pode (e deve) torná-lo mais avançado, adicionando um aviso se o arquivo de configurações estiver incorreto ou faltando, então decida o que fazer, mas esta é a idéia básica.

EDITAR

A partir dos seus comentários, entendo que, de duas formas, a resposta acima não é (ainda) o que você está procurando:

1. Você gostaria de executar o comando sem o caminho para o executável (script) e sua extensão e
2. Você gostaria de ter um formato mais "convencional" das opções.

Embora [1] já esteja em outro lugar, incluirei uma breve explicação aqui:

1. Execute o comando sem caminho e extensão

Você pode executar executáveis e scripts sem ter que incluir o caminho para o script, tornando-o executável ( chmod +x <files> ), e colocá-los em qualquer lugar $ PATH .

No Linux, a extensão ( .py ) não desempenha nenhum papel, então você pode usar o script sem extensão mesmo assim .

Para ser concreto:

• crie, se ainda não existir, o diretório ~/bin

• crie e salve o script, exatamente como mencionado na resposta original, como showsize (sem extenion) em ~/bin e tornar o script executável .

  Após um logout / in, você pode simplesmente executar o script pelo comando:

  showsize
  

2. Alterar o formato das opções

Como mencionado, você pode alterar o formato das opções facilmente, por exemplo: Para analisar as opções, como:

-l 23 -h 210 -w 321

• Se você incluir no script:

  args = sys.argv [1:]

  O resultado para args será uma lista:

  ["-l", "23", "-h", "210", "-w", "321"]
  

  Agora, o que precisamos fazer para obter o valor de -h é simplesmente procurar o índice de -h e escolher o primeiro próximo item da lista:

  height = args[args.index("-h")+1]
  print(height)
  
  > 210
  

  em um script:

  #!/usr/bin/env python3
  import sys
  
  # path to my config file
  conf_file = "/home/jacob/Bureaublad/testconf.txt"
  # read the default arguments from a file
  def_args = [l.strip().split(":") for l in open(conf_file).readlines()]
  # replace default args by possible custom args
  cust_args = sys.argv[1:]
  for carg in cust_args:
      if carg in ["-l", "-h", "-w"]:                        
          for d in def_args:
              d[1] = cust_args[cust_args.index(carg)+1] if d[0] == carg else d[1]
  
  def get_arg(s):
      # fetch values from the list
      return [val[1] for val in def_args if val[0] == s][0]
  
  l = get_arg("-l")
  w = get_arg("-w")
  h = get_arg("-h")
  
  print("length =", l, "\nwidth =", w, "\nheight =", h)
  

Como usar

1. Crie seu arquivo de configurações no formato:

   -l:4
   -h:7
   -w:6
   

2. Copie o script em um arquivo vazio, exiba-o como showsize (sem extensão) em ~/bin ou qualquer outro lugar em $PATH e torne-o executável .

3. Na seção head do script, defina o caminho para o arquivo de configurações:

   # path to my config file
   conf_file = "/home/jacob/Bureaublad/testconf.txt"
   

   Agora, execute o comando:

   $ showsize
   length = 4 
   width = 6 
   height = 7
   

   Ou:

   $ showsize -l 300 -h 345 -w 751
   length = 300 
   width = 751 
   height = 345
   

Answer 2

Arquivo de script:

#!/bin/bash

# set default values
X=10
Y="lorem ipsum"

source ~/.myscript.conf

echo "X = $X, Y = $Y"

arquivo

.myscript.conf:

X=20
Y="something else"

Agora, se um usuário executar um arquivo de script e não tiver o arquivo .myscript.conf em seu diretório inicial, o script usará X = 10 e Y="lorem ipsum", se houver um arquivo de configuração, ele usará valores de o arquivo.

O comando source executa o conteúdo do arquivo fornecido como um argumento no shell atual, portanto, aqui, ele atribuirá novos valores aos padrões de sobrescrita X e Y do arquivo de script.

Como ~ aponta para o diretório inicial do usuário, esta configuração funcionará para qualquer usuário em seu sistema (também root).

[Editar] E no seu exemplo específico:

#!/bin/bash
X=10
Y=2
source ~/.config.conf
pcap -d $X -w $Y

    

Answer 3

Bash : o mesmo que Marek com o fornecimento de um arquivo com os valores do usuário, com a ressalva de que esse arquivo pode fazer qualquer coisa e erros de digitação apenas provocam erros de sintaxe, portanto isso requer um pouco de conhecimento do usuário como. Você pode analisar parâmetros de linha de comando com getopts.

Python : consulte o módulo argparse para analisar os parâmetros da linha de comando e ConfigParser (v2) e configparser (v3) para analisar um arquivo .ini.

Normalmente você usa um arquivo de configuração para coisas que não mudam com frequência, e parâmetros de linha de comando para coisas que provavelmente são diferentes em cada execução. Editar um arquivo de configuração em cada execução é um PITA.