1 def _parse_known_args(self, arg_strings, namespace):
2 # replace arg strings that are file references
3 if self.fromfile_prefix_chars is not None:
4 arg_strings = self._read_args_from_files(arg_strings)
5
6 # map all mutually exclusive arguments to the other arguments
7 # they can't occur with
8 action_conflicts = {}
9 for mutex_group in self._mutually_exclusive_groups:
10 group_actions = mutex_group._group_actions
11 for i, mutex_action in enumerate(mutex_group._group_actions):
12 conflicts = action_conflicts.setdefault(mutex_action, [])
13 conflicts.extend(group_actions[:i])
14 conflicts.extend(group_actions[i + 1:])
15
16 # find all option indices, and determine the arg_string_pattern
17 # which has an 'O' if there is an option at an index,
18 # an 'A' if there is an argument, or a '-' if there is a '--'
19 option_string_indices = {}
20 arg_string_pattern_parts = []
21 arg_strings_iter = iter(arg_strings)
22 for i, arg_string in enumerate(arg_strings_iter):
23
24 # all args after -- are non-options
25 if arg_string == '--':
26 arg_string_pattern_parts.append('-')
27 for arg_string in arg_strings_iter:
28 arg_string_pattern_parts.append('A')
29
30 # otherwise, add the arg to the arg strings
31 # and note the index if it was an option
32 else:
33 option_tuple = self._parse_optional(arg_string)
34 if option_tuple is None:
35 pattern = 'A'
36 else:
37 option_string_indices[i] = option_tuple
38 pattern = 'O'
39 arg_string_pattern_parts.append(pattern)
40
41 # join the pieces together to form the pattern
42 arg_strings_pattern = ''.join(arg_string_pattern_parts)
43
44 # converts arg strings to the appropriate and then takes the action
45 seen_actions = set()
46 seen_non_default_actions = set()
47
48 def take_action(action, argument_strings, option_string=None):
49 seen_actions.add(action)
50 argument_values = self._get_values(action, argument_strings)
51
52 # error if this argument is not allowed with other previously
53 # seen arguments, assuming that actions that use the default
54 # value don't really count as "present"
55 if argument_values is not action.default:
56 seen_non_default_actions.add(action)
57 for conflict_action in action_conflicts.get(action, []):
58 if conflict_action in seen_non_default_actions:
59 msg = _('not allowed with argument %s')
60 action_name = _get_action_name(conflict_action)
61 raise ArgumentError(action, msg % action_name)
62
63 # take the action if we didn't receive a SUPPRESS value
64 # (e.g. from a default)
65 if argument_values is not SUPPRESS:
66 action(self, namespace, argument_values, option_string)
67
68 # function to convert arg_strings into an optional action
69 def consume_optional(start_index):
70
71 # get the optional identified at this index
72 option_tuple = option_string_indices[start_index]
73 action, option_string, explicit_arg = option_tuple
74
75 # identify additional optionals in the same arg string
76 # (e.g. -xyz is the same as -x -y -z if no args are required)
77 match_argument = self._match_argument
78 action_tuples = []
79 while True:
80
81 # if we found no optional action, skip it
82 if action is None:
83 extras.append(arg_strings[start_index])
84 return start_index + 1
85
86 # if there is an explicit argument, try to match the
87 # optional's string arguments to only this
88 if explicit_arg is not None:
89 arg_count = match_argument(action, 'A')
90
91 # if the action is a single-dash option and takes no
92 # arguments, try to parse more single-dash options out
93 # of the tail of the option string
94 chars = self.prefix_chars
95 if arg_count == 0 and option_string[1] not in chars:
96 action_tuples.append((action, [], option_string))
97 char = option_string[0]
98 option_string = char + explicit_arg[0]
99 new_explicit_arg = explicit_arg[1:] or None
100 optionals_map = self._option_string_actions
101 if option_string in optionals_map:
102 action = optionals_map[option_string]
103 explicit_arg = new_explicit_arg
104 else:
105 msg = _('ignored explicit argument %r')
106 raise ArgumentError(action, msg % explicit_arg)
107
108 # if the action expect exactly one argument, we've
109 # successfully matched the option; exit the loop
110 elif arg_count == 1:
111 stop = start_index + 1
112 args = [explicit_arg]
113 action_tuples.append((action, args, option_string))
114 break
115
116 # error if a double-dash option did not use the
117 # explicit argument
118 else:
119 msg = _('ignored explicit argument %r')
120 raise ArgumentError(action, msg % explicit_arg)
121
122 # if there is no explicit argument, try to match the
123 # optional's string arguments with the following strings
124 # if successful, exit the loop
125 else:
126 start = start_index + 1
127 selected_patterns = arg_strings_pattern[start:]
128 arg_count = match_argument(action, selected_patterns)
129 stop = start + arg_count
130 args = arg_strings[start:stop]
131 action_tuples.append((action, args, option_string))
132 break
133
134 # add the Optional to the list and return the index at which
135 # the Optional's string args stopped
136 assert action_tuples
137 for action, args, option_string in action_tuples:
138 take_action(action, args, option_string)
139 return stop
140
141 # the list of Positionals left to be parsed; this is modified
142 # by consume_positionals()
143 positionals = self._get_positional_actions()
144
145 # function to convert arg_strings into positional actions
146 def consume_positionals(start_index):
147 # match as many Positionals as possible
148 match_partial = self._match_arguments_partial
149 selected_pattern = arg_strings_pattern[start_index:]
150 arg_counts = match_partial(positionals, selected_pattern)
151
152 # slice off the appropriate arg strings for each Positional
153 # and add the Positional and its args to the list
154 for action, arg_count in zip(positionals, arg_counts):
155 args = arg_strings[start_index: start_index + arg_count]
156 start_index += arg_count
157 take_action(action, args)
158
159 # slice off the Positionals that we just parsed and return the
160 # index at which the Positionals' string args stopped
161 positionals[:] = positionals[len(arg_counts):]
162 return start_index
163
164 # consume Positionals and Optionals alternately, until we have
165 # passed the last option string
166 extras = []
167 start_index = 0
168 if option_string_indices:
169 max_option_string_index = max(option_string_indices)
170 else:
171 max_option_string_index = -1
172 while start_index <= max_option_string_index:
173
174 # consume any Positionals preceding the next option
175 next_option_string_index = min([
176 index
177 for index in option_string_indices
178 if index >= start_index])
179 if start_index != next_option_string_index:
180 positionals_end_index = consume_positionals(start_index)
181
182 # only try to parse the next optional if we didn't consume
183 # the option string during the positionals parsing
184 if positionals_end_index > start_index:
185 start_index = positionals_end_index
186 continue
187 else:
188 start_index = positionals_end_index
189
190 # if we consumed all the positionals we could and we're not
191 # at the index of an option string, there were extra arguments
192 if start_index not in option_string_indices:
193 strings = arg_strings[start_index:next_option_string_index]
194 extras.extend(strings)
195 start_index = next_option_string_index
196
197 # consume the next optional and any arguments for it
198 start_index = consume_optional(start_index)
199
200 # consume any positionals following the last Optional
201 stop_index = consume_positionals(start_index)
202
203 # if we didn't consume all the argument strings, there were extras
204 extras.extend(arg_strings[stop_index:])
205
206 # make sure all required actions were present and also convert
207 # action defaults which were not given as arguments
208 required_actions = []
209 for action in self._actions:
210 if action not in seen_actions:
211 if action.required:
212 required_actions.append(_get_action_name(action))
213 else:
214 # Convert action default now instead of doing it before
215 # parsing arguments to avoid calling convert functions
216 # twice (which may fail) if the argument was given, but
217 # only if it was defined already in the namespace
218 if (action.default is not None and
219 isinstance(action.default, str) and
220 hasattr(namespace, action.dest) and
221 action.default is getattr(namespace, action.dest)):
222 setattr(namespace, action.dest,
223 self._get_value(action, action.default))
224
225 if required_actions:
226 self.error(_('the following arguments are required: %s') %
227 ', '.join(required_actions))
228
229 # make sure all required groups had one option present
230 for group in self._mutually_exclusive_groups:
231 if group.required:
232 for action in group._group_actions:
233 if action in seen_non_default_actions:
234 break
235
236 # if no actions were used, report the error
237 else:
238 names = [_get_action_name(action)
239 for action in group._group_actions
240 if action.help is not SUPPRESS]
241 msg = _('one of the arguments %s is required')
242 self.error(msg % ' '.join(names))
243
244 # return the updated namespace and the extra arguments
245 return namespace, extras
浙公网安备 33010602011771号