termineter.options.AdvancedOptions

Here are the examples of the python api termineter.options.AdvancedOptions taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

2 Examples 7

Example 1

Project: termineter Source File: templates.py
Function: init
	def __init__(self, frmwk):
		self.frmwk = frmwk

		self.name = 'unknown'
		self.version = 0
		self.author = ['anonymous']
		self.description = 'This module is undocuemented.'
		self.detailed_description = 'This module is undocuemented.'
		self.options = Options(frmwk.directories)
		self.advanced_options = AdvancedOptions(frmwk.directories)

Example 2

Project: termineter Source File: core.py
	def __init__(self, stdout=None):
		self.modules = {}
		self.__package__ = '.'.join(self.__module__.split('.')[:-1])
		package_path = importlib.import_module(self.__package__).__path__[0]  # that's some python black magic trickery for you
		if stdout is None:
			stdout = sys.stdout
		self.stdout = stdout
		self.logger = logging.getLogger(self.__package__ + '.' + self.__class__.__name__.lower())

		self.directories = Namespace()
		self.directories.user_data = os.path.abspath(os.path.join(os.path.expanduser('~'), '.termineter'))
		self.directories.modules_path = os.path.abspath(os.path.join(package_path, 'modules'))
		self.directories.data_path = os.path.abspath(os.path.join(package_path, 'data'))
		if not os.path.isdir(self.directories.data_path):
			self.logger.critical('path to data not found')
			raise FrameworkConfigurationError('path to data not found')
		if not os.path.isdir(self.directories.user_data):
			os.mkdir(self.directories.user_data)

		self.serial_connection = None
		self.__serial_connected__ = False

		# setup logging stuff
		main_file_handler = logging.handlers.RotatingFileHandler(os.path.join(self.directories.user_data, self.__package__ + '.log'), maxBytes=262144, backupCount=5)
		main_file_handler.setLevel(logging.DEBUG)
		main_file_handler.setFormatter(logging.Formatter("%(asctime)s %(name)-50s %(levelname)-10s %(message)s"))
		logging.getLogger('').addHandler(main_file_handler)

		# setup and configure options
		# Whether or not these are 'required' is really enforced by the individual
		# modules get_missing_options method and by which options they require based
		# on their respective types.  See framework/templates.py for more info.
		self.options = Options(self.directories)
		self.options.add_boolean('USECOLOR', 'enable color on the console interface', default=False)
		self.options.add_string('CONNECTION', 'serial connection string')
		self.options.add_string('USERNAME', 'serial username', default='0000')
		self.options.add_integer('USERID', 'serial userid', default=0)
		self.options.add_string('PASSWORD', 'serial c12.18 password', default='00000000000000000000')
		self.options.add_boolean('PASSWORDHEX', 'if the password is in hex', default=True)
		self.advanced_options = AdvancedOptions(self.directories)
		self.advanced_options.add_boolean('AUTOCONNECT', 'automatically handle connections for modules', default=True)
		self.advanced_options.add_integer('BAUDRATE', 'serial connection baud rate', default=9600)
		self.advanced_options.add_integer('BYTESIZE', 'serial connection byte size', default=serial.EIGHTBITS)
		self.advanced_options.add_boolean('CACHETBLS', 'cache certain read-only tables', default=True)
		self.advanced_options.set_callback('CACHETBLS', self.__opt_callback_set_table_cache_policy)
		self.advanced_options.add_integer('STOPBITS', 'serial connection stop bits', default=serial.STOPBITS_ONE)
		self.advanced_options.add_integer('NBRPKTS', 'c12.18 maximum packets for reassembly', default=2)
		self.advanced_options.add_integer('PKTSIZE', 'c12.18 maximum packet size', default=512)
		if sys.platform.startswith('linux'):
			self.options.set_option('USECOLOR', 'True')

		# check and configure rfcat stuff
		self.rfcat_available = False
		try:
			import rflib
		except ImportError:
			self.logger.info('the rfcat library is not available, it can be found at https://code.google.com/p/rfcat/')
		else:
			self.logger.info('the rfcat library is available')
			self.rfcat_available = True
			# init the values to be used
			self.rfcat_connection = None
			self.__rfcat_connected__ = False
			self.is_rfcat_connected = lambda: self.__rfcat_connected__
			# self.options.add_integer('RFCATIDX', 'the rfcat device to use', default = 0)

		# start loading modules
		modules_path = os.path.abspath(self.directories.modules_path)
		self.logger.debug('searching for modules in: ' + modules_path)
		self.current_module = None
		if not os.path.isdir(modules_path):
			self.logger.critical('path to modules not found')
			raise FrameworkConfigurationError('path to modules not found')
		for module_path in FileWalker(modules_path, absolute_path=True, skip_dirs=True):
			module_path = module_path.replace(os.path.sep, '/')
			if not module_path.endswith('.py'):
				continue
			module_path = module_path[len(modules_path) + 1:-3]
			module_name = module_path.split(os.path.sep)[-1]
			if module_name.startswith('__'):
				continue
			if module_name.lower() != module_name:
				continue
			if module_path.startswith('rfcat') and not self.rfcat_available:
				self.logger.debug('skipping module: ' + module_path + ' because rfcat is not available')
				continue
			# looks good, proceed to load
			self.logger.debug('loading module: ' + module_path)
			try:
				module_instance = self.import_module(module_path)
			except FrameworkRuntimeError:
				continue
			if not isinstance(module_instance, TermineterModule):
				self.logger.error('module: ' + module_path + ' is not derived from the TermineterModule class')
				continue
			# if isinstance(module_instance, TermineterModuleRfcat) and not self.rfcat_available:
			# 	self.logger.debug('skipping module: ' + module_path + ' because rfcat is not available')
			#	continue
			if not hasattr(module_instance, 'run'):
				self.logger.critical('module: ' + module_path + ' has no run() method')
				raise FrameworkRuntimeError('module: ' + module_path + ' has no run() method')
			if not isinstance(module_instance.options, Options) or not isinstance(module_instance.advanced_options, Options):
				self.logger.critical('module: ' + module_path + ' options and advanced_options must be Options instances')
				raise FrameworkRuntimeError('options and advanced_options must be Options instances')
			module_instance.name = module_name
			module_instance.path = module_path
			self.modules[module_path] = module_instance
		self.logger.info("successfully loaded {0:,} modules into the framework".format(len(self.modules)))
		return