docs: def _process_arguments(self, args, kw):
  		"""Map positional to keyword arguments, identify invalid assignments, and return the result.
  		
  		This is likely generic enough to be useful as a standalone utility function, and goes to a fair amount of
  		effort to ensure raised exceptions are as Python-like as possible.
  		"""
  		
  		# Ensure we were not passed too many arguments.
  		if len(args) > len(self.__attributes__):
  			raise TypeError('{0} takes no more than {1} argument{2} ({3} given)'.format(
  					self.__class__.__name__,
  					len(self.__attributes__),
  					'' if len(self.__attributes__) == 1 else 's',
  					len(args)
  				))
  		
  		# Retrieve the names associated with the positional parameters.
  		names = [name for name in self.__attributes__.keys() if name[0] != '_' or name == '__name__'][:len(args)]
  		
  		# Sets provide a convienent way to identify intersections.
  		duplicates = set(kw.keys()) & set(names)
  		
  		# Given duplicate values, explode gloriously.
  		if duplicates:
  			raise TypeError('{0} got multiple values for keyword argument{1}: {2}'.format(
  					self.__class__.__name__,
  					'' if len(duplicates) == 1 else 's',
  					', '.join(duplicates)
  				))
  		
  		def field_values(args, kw):
  			"""A little closure to yield out fields and their assigned values in field order."""
  			
  			for i, arg in enumerate(self.__attributes__.keys()):
  				if len(args):
  					yield arg, args.popleft()
  				
  				if arg in kw:
  					yield arg, kw.pop(arg)
  		
  		result = odict(field_values(deque(args), dict(kw)))
  		
  		# Again use sets, this time to identify unknown keys.
  		unknown = set(kw.keys()) - set(result.keys())
  		
  		# Given unknown keys, explode gloriously.
  		if unknown:
  			raise TypeError('{0} got unexpected keyword argument{1}: {2}'.format(
  					self.__class__.__name__,
  					'' if len(unknown) == 1 else 's',
  					', '.join(unknown)
  				))
  		
  		return result