85 lines
3.3 KiB
Python
85 lines
3.3 KiB
Python
import argparse
|
|
import os
|
|
import sys
|
|
from types import ModuleType
|
|
|
|
from . import actions
|
|
|
|
def argParserGenerator(actionQueue, namespaceQueue):
|
|
class MyArgParser(argparse.ArgumentParser):
|
|
def __init__(self, *args, **kwargs):
|
|
super().__init__(*args, **kwargs)
|
|
self.actionQueue = actionQueue
|
|
self.namespaceQueue = namespaceQueue
|
|
|
|
def get_actions(self):
|
|
actions = []
|
|
mutex_groups = []
|
|
|
|
# First add all actions (Including actions of mutex_groups)
|
|
for action in self._actions:
|
|
if type(action) != argparse._HelpAction:
|
|
actions.append(self.simplify_action(action))
|
|
|
|
|
|
# Then fill all mutex groups
|
|
mutex_groups = self.create_mutex_groups(self._mutually_exclusive_groups, self)
|
|
|
|
# And remove Actions, that are somewhere in the mutex groups
|
|
actions = self.clean_actions(actions, mutex_groups)
|
|
|
|
return actions, mutex_groups
|
|
|
|
|
|
def simplify_action(self, action):
|
|
if type(action) == argparse._HelpAction:
|
|
return None
|
|
elif type(action) == argparse._StoreConstAction:
|
|
return actions.StoreConstAction(action)
|
|
elif type(action) == argparse._StoreTrueAction:
|
|
return actions.StoreConstAction(action)
|
|
elif type(action) == argparse._StoreFalseAction:
|
|
return actions.StoreConstAction(action)
|
|
elif type(action) == argparse._StoreAction:
|
|
return actions.StoreAction(action)
|
|
elif type(action) == argparse._AppendAction:
|
|
return actions.AppendAction(action)
|
|
elif type(action) == argparse._CountAction:
|
|
return actions.StoreAction(action, type_function=int)
|
|
elif type(action) == argparse._SubParsersAction:
|
|
return actions.SubParserAction(action)
|
|
print("Unknown type: {}".format(type(action)), file=sys.__stderr__)
|
|
return None
|
|
|
|
def create_mutex_groups(self, groups, parent):
|
|
mutex_groups = []
|
|
for group in groups:
|
|
if group._container == parent:
|
|
new_group = actions.MutuallyExclusiveGroup()
|
|
new_group.mutex_groups = self.create_mutex_groups(groups, group)
|
|
for action in group._group_actions:
|
|
new_group.actions.append(self.simplify_action(action))
|
|
mutex_groups.append(new_group)
|
|
return mutex_groups
|
|
|
|
def clean_actions(self, actions, mutex_groups):
|
|
for mutex_group in mutex_groups:
|
|
actions = [action for action in actions if action.name not in [act.name for act in mutex_group.actions]]
|
|
return actions
|
|
|
|
def parse_args(self, args=None, namespace=None):
|
|
name = os.path.basename(sys.argv[0])
|
|
desc = self.description
|
|
|
|
actions, mutex_groups = self.get_actions()
|
|
|
|
print(actions, file=sys.__stdout__)
|
|
|
|
self.actionQueue.put((mutex_groups, actions, name, desc))
|
|
namespace = self.namespaceQueue.get()
|
|
return namespace
|
|
module = ModuleType('argparse', 'Argument Parser')
|
|
module.__dict__.update(argparse.__dict__)
|
|
module.__dict__['ArgumentParser'] = MyArgParser
|
|
return module
|
|
|