很经典的一段代码-django source code

Posted 2020-12-12 fmaj7

  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