Zugang argparse Variablen von einem externen Modul

Question

Ich habe 4 Module:

• entry_point.py
• utils.py
• runner.py
• client.py

Ich benutze argparse in utils.py und ich möchte in der Lage sein, um den Wert eines dieser arg abzurufen in client.py.

• Einsprungpunkt Modul (die, die von der Konsole aufgerufen wird):

  import utils 
  def main(): 
      console_args = utils.parse_arguments() # Get command-line arguments 
      runner.run(console_args) # The main function in the program 
  
  if __name__ == '__main__': 
      main() 
  

• utils.py Modul:

  def parse_arguments(): 
      parser = argparse.ArgumentParser() 
      parser.add_argument(
       # Several arguments, one of which should be 'url' 
      ) 
      return parser.parse_args() 
  

• runner.py Modul:

  import client 
  
  def run(arguments): 
      user = User.new(arguments.user_id) 
      client.get_user_info(user) 
  

• client.py Module:

  def get_user_info(user): 
      url = _compose_url('user_status') 
      resp = requests.post(url, data=user.id) 
  
  def _compose_url(method): 
      # TODO: get base_url from console arguments 
      # base_url = ? 
      return base_url + str(method) 
  

Ich will nicht url als Parameter an client.get_user_info() passieren, weil ich es als Parameter für diese Funktion zu haben, wäre nicht denken gut.

Also ich möchte in der Lage sein, die Argarseargumente, die ich von utils.parse_arguments() direkt erhalten habe, abrufen zu können. Gibt es eine Möglichkeit, das zu tun?

Answer 1

Wie der Vorschlag mein Kommentar und Mike Müllers Antwort, setzt der folgende Code eine Modulebenenvariable.
Um das Parsen von Argumenten beim Import zu verhindern, setze ich die Variable jedoch nur einmal, wenn parse_arguments aufgerufen wird. Da die Variable vorher auf None gesetzt wird, importiere ich die Variable nur bei Bedarf.
Auf diese Weise wird parse_arguments nur ausgeführt, wenn Sie es aufrufen, nicht beim Importieren des Moduls. Es wird wahrscheinlich nicht in Ihrem speziellen Fall benötigt, aber kann bequem sein, wenn z.B. Ein Modul wie utils wird in einem Paket verwendet.

utils.py:

CONSOLE_ARGUMENTS = None 

def parse_arguments(): 
    parser = argparse.ArgumentParser() 
    parser.add_argument(
     # Several arguments, one of which should be 'url' 
    ) 
    parser.parse_args() 
    global CONSOLE_ARGUMENTS 
    CONSOLE_ARGUMENTS = parser.parse_args() 
    return CONSOLE_ARGUMENTS 

client.py:

def _compose_url(method): 
    from .utils import CONSOLE_ARGUMENTS 
    base_url = CONSOLE_ARGUMENTS.base_url 
    return base_url + str(method) 

Answer 2

Machen Sie ein neues Modul console_args.py:

""" 
Parsing of command line arguments. 

No other functionality should be added to this module. 
The typically usage is: 

>>> from console_args import CONSOLE_ARGS 
""" 

def _parse_arguments(): 
    parser = argparse.ArgumentParser() 
    parser.add_argument(
     # Several arguments, one of which should be 'url' 
    ) 
    return parser.parse_args() 

CONSOLE_ARGS = _parse_arguments() 

# optional: delete function after use to prevent calling from other place 
del _parse_arguments 

Jetzt verwenden Sie es in allen Modulen:

from console_args import CONSOLE_ARGS 

Die Funktion _parse_arguments() wird nur einmal durchgeführt werden. Module in Python sind Singletons, d. H. Sie werden nur beim ersten Import ausgeführt. Jeder nachfolgende Import erhält ein Modulobjekt, ohne die gesamte Importprozedur auszuführen, die wiederum den gesamten Code auf Modulebene ausführt. Der Unterstrich in _parse_arguments() zeigt an, dass diese Funktion nicht außerhalb des Moduls console_args.py verwendet werden soll. Löschen _parse_arguments nach dem Aufruf wird während der Laufzeit des Programms jeden anderen Aufruf von _parse_arguments() verhindern (solange keine Nachladetricks angewendet werden).