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