docs: def get_flags(self, args):
  
  		"""
  		Checks and retrieves positional and 'always' (keyword) flags
  		from the many ways in which they may be passed to the
  		constructor (or the beautify() method on package-level).
  
  		Positional arguments can be passed either:
  
  		* Individually, where each flag-combination is one positional argument.
  		* Packaged inside a list, which is then expanded. There can be
  		  multiple of such lists passed as arguments because it facilitates
  		  interaction with the ecastasy module (one may want to organize
  		  and update styles in certain ways depending on one's program), but
  		  each list will be expanded and all flag-combinations found inside
  		  each list will be interpreted as a single style argument, as if it
  		  had been passed in the way desribed above (individually).
  
  		'Always' arguments can be passed either:
  
  		* Individually, with keyword-argument syntax, i.e. <word>=<style>
  		* In a dictionary, which is expanded exactly like positional
  		  arguments passed in lists (i.e. each key/value pair in the
  		  dictionary is interpreted as if it had been passed individually,
  		  as key=value to the constructor/the external beautify() method).
  
  		Note:
  			self.always is set equal to the keyword arguments passed to the
  			constructor and then modified directly (when 'always'-arguments
  			are found), while the positional arguments are put into a list
  			here and returned (i.e. no interaction with self.positional).
  
  		Arguments:
  			args (list): The positional arguments passed to the constructor.
  
  		Returns:
  			The positional arguments.
  
  		Raises:
  			errors.FlagError: If an invalid (out-of-range)
  							  flag combination was passed.
  
  			errors.EcstasyError: If one of the arguments is of invalid type.
  
  		"""
  
  		positional = []
  
  		for argument in args:
  			# A flag is an instance of a subclass of
  			# flags.Flags if it was passed alone
  			if isinstance(argument, flags.Flags):
  				positional.append(argument)
  
  			# or is an integer if it was (bitwise) OR'd
  			# with another flag (a "flag combination")
  			elif isinstance(argument, int):
  				if argument < 0 or argument >= flags.LIMIT:
  					raise errors.FlagError("Flag value '{0}' is out of range "
  										   "!".format(argument))
  				positional.append(argument)
  
  			# Dictionaries store 'always'-arguments
  			elif isinstance(argument, dict):
  				for key, value in argument.items():
  					# Simple 'always'-argument where one string
  					# is mapped to one formatting flag-combination
  					if isinstance(key, str):
  						self.always[key] = value
  
  					# Complex 'always'-argument with a
  					# tuple containing strings, each with the same
  					# flag-combination (same value)
  					elif isinstance(key, tuple):
  						for i in key:
  							self.always[i] = value
  					else:
  						raise errors.EcstasyError("Key '{0}' in dictionary "
  												  "argument passed is neither "
  												  "a string nor a tuple "
  												  "of strings!".format(key))
  
  			elif isinstance(argument, collections.Iterable):
  				positional += self.get_flags(argument)
  
  			else:
  				raise errors.EcstasyError("Argument '{0}' is neither a flag, a "
  										  "(bitwise) OR'd flag-combination, a "
  										  "dictionary nor an  iterable of "
  										  "positional arguments "
  										  "!".format(argument))
  
  		return positional