From 5e84a41178edc354d13c260b072dfea01e6f05c3 Mon Sep 17 00:00:00 2001 From: Alex Roitman Date: Thu, 9 Mar 2006 19:42:48 +0000 Subject: [PATCH] update svn: r6118 --- src/PluginUtils/Tool/_Options.py | 513 ------------------------------- src/PluginUtils/Tool/_Tool.py | 279 ----------------- 2 files changed, 792 deletions(-) delete mode 100644 src/PluginUtils/Tool/_Options.py delete mode 100644 src/PluginUtils/Tool/_Tool.py diff --git a/src/PluginUtils/Tool/_Options.py b/src/PluginUtils/Tool/_Options.py deleted file mode 100644 index 871f5a26a..000000000 --- a/src/PluginUtils/Tool/_Options.py +++ /dev/null @@ -1,513 +0,0 @@ -# -# Gramps - a GTK+/GNOME based genealogy program -# -# Copyright (C) 2004-2005 Donald N. Allingham -# -# This program is free software; you can redistribute it and/or modify -# it under the terms of the GNU General Public License as published by -# the Free Software Foundation; either version 2 of the License, or -# (at your option) any later version. -# -# This program is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -# GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License -# along with this program; if not, write to the Free Software -# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -# -# $Id$ - -# Written by Alex Roitman - -""" -General option handling, including saving and parsing. -""" - -#------------------------------------------------------------------------- -# -# Standard Python modules -# -#------------------------------------------------------------------------- -import os -from gettext import gettext as _ - -#------------------------------------------------------------------------- -# -# SAX interface -# -#------------------------------------------------------------------------- -try: - from xml.sax import make_parser,handler,SAXParseException -except: - from _xmlplus.sax import make_parser,handler,SAXParseException - -#------------------------------------------------------------------------- -# -# gramps modules -# -#------------------------------------------------------------------------- -import Utils - -#------------------------------------------------------------------------- -# -# List of options for a single module -# -#------------------------------------------------------------------------- -class OptionList: - """ - Implements a set of options to parse and store for a given module. - """ - - def __init__(self): - self.options = {} - - def set_options(self,options): - """ - Sets the whole bunch of options for the OptionList. - @param options: list of options to set. - @type options: list - """ - self.options = options - - def get_options(self): - """ - Returns the whole bunch of options for the OptionList. - @returns: list of options - @rtype: list - """ - return self.options - - def set_option(self,name,value): - """ - Sets a particular option in the OptionList. - @param name: name of the option to set. - @type name: str - @param value: value of the option to set. - @type str - """ - self.options[name] = value - - def remove_option(self,name): - """ - Removes a particular option from the OptionList. - @param name: name of the option to remove. - @type name: str - """ - if self.options.has_key(name): - del self.options[name] - - def get_option(self,name): - """ - Returns the value of a particular option in the OptionList. - @param name: name of the option to retrieve - @type name: str - @returns: value associated with the passed option - @rtype: str - """ - return self.options.get(name,None) - -#------------------------------------------------------------------------- -# -# Collection of option lists -# -#------------------------------------------------------------------------- -class OptionListCollection: - """ - Implements a collection of option lists. - """ - - def __init__(self,filename): - """ - Creates an OptionListCollection instance from the list defined - in the specified file. - @param filename: XML file that contains option definitions - @type filename: str - """ - - self.filename = os.path.expanduser(filename) - self.option_list_map = {} - self.init_common() - self.parse() - - def init_common(self): - pass - - def get_option_list_map(self): - """ - Returns the map of module names to option lists. - @returns: Returns the map of module names to option lists. - @rtype: dictionary - """ - return self.option_list_map - - def get_option_list(self,name): - """ - Returns the option_list associated with the module name - @param name: name associated with the desired module. - @type name: str - @returns: returns the option list associated with the name, - or None of no such option exists - @rtype: str - """ - return self.option_list_map.get(name,None) - - def get_module_names(self): - """ - Returns a list of all the module names in the OptionListCollection - @returns: returns the list of module names - @rtype: list - """ - return self.option_list_map.keys() - - def set_option_list(self,name,option_list): - """ - Adds or replaces an option_list in the OptionListCollection. - @param name: name assocated with the module to add or replace. - @type name: str - @param option_list: list of options - @type option_list: str - """ - self.option_list_map[name] = option_list - - def write_common(self,f): - """ - Stub function for common options. Overridden by reports. - """ - pass - - def write_module_common(self,f,option_list): - """ - Stub function for common options. Overridden by reports. - """ - pass - - def save(self): - """ - Saves the current OptionListCollection to the associated file. - """ - f = open(self.filename,"w") - f.write("\n") - f.write('\n') - - self.write_common(f) - - for module_name in self.get_module_names(): - option_list = self.get_option_list(module_name) - f.write('\n' % module_name) - options = option_list.get_options() - for option_name in options.keys(): - if type(options[option_name]) in (type(list()),type(tuple())): - f.write(' \n') - else: - f.write(' \n') - - f.write('\n') - f.close() - - def parse(self): - """ - Loads the OptionList from the associated file, if it exists. - """ - try: - p = make_parser() - p.setContentHandler(OptionParser(self)) - p.parse('file://' + self.filename) - except (IOError,OSError,SAXParseException): - pass - -#------------------------------------------------------------------------- -# -# OptionParser -# -#------------------------------------------------------------------------- -class OptionParser(handler.ContentHandler): - """ - SAX parsing class for the OptionListCollection XML file. - """ - - def __init__(self,collection): - """ - Creates a OptionParser class that populates the passed collection. - - collection: OptionListCollection to be loaded from the file. - """ - handler.ContentHandler.__init__(self) - self.collection = collection - - self.mname = None - self.option_list = None - self.oname = None - self.o = None - self.an_o = None - self.list_class = OptionList - - def startElement(self,tag,attrs): - """ - Overridden class that handles the start of a XML element - """ - if tag in ("report","module"): - self.mname = attrs['name'] - self.option_list = self.list_class() - self.o = {} - elif tag == "option": - self.oname = attrs['name'] - if attrs.has_key('length'): - self.an_o = [] - else: - self.an_o = attrs['value'] - elif tag == "listitem": - self.an_o.append(attrs['value']) - - def endElement(self,tag): - "Overridden class that handles the end of a XML element" - if tag == "option": - self.o[self.oname] = self.an_o - elif tag in ("report","module"): - self.option_list.set_options(self.o) - self.collection.set_option_list(self.mname,self.option_list) - -#------------------------------------------------------------------------- -# -# Class handling options for plugins -# -#------------------------------------------------------------------------- -class OptionHandler: - """ - Implements handling of the options for the plugins. - """ - - def __init__(self,module_name,options_dict,person_id=None): - self.module_name = module_name - self.default_options_dict = options_dict.copy() - self.options_dict = options_dict - - # Retrieve our options from whole collection - self.init_subclass() - self.option_list_collection = self.collection_class(self.filename) - self.init_common() - self.saved_option_list = self.option_list_collection.get_option_list(module_name) - self.person_id = person_id - - # Whatever was found should override the defaults - if self.saved_option_list: - self.set_options() - else: - # If nothing was found, set up the option list - self.saved_option_list = self.list_class() - self.option_list_collection.set_option_list(module_name, - self.saved_option_list) - - def init_subclass(self): - self.collection_class = OptionListCollection - self.list_class = OptionList - self.filename = None - - def init_common(self): - pass - - def set_options(self): - """ - Sets options to be used in this plugin according to the passed - options dictionary. - - Dictionary values are all strings, since they were read from XML. - Here we need to convert them to the needed types. We use default - values to determine the type. - """ - # First we set options_dict values based on the saved options - options = self.saved_option_list.get_options() - bad_opts = [] - for option_name in options.keys(): - if not self.options_dict.has_key(option_name): - print "Option %s is present in the %s but is not known "\ - "to the module." % (option_name, - self.option_list_collection.filename) - print "Ignoring..." - bad_opts.append(option_name) - continue - try: - converter = Utils.get_type_converter(self.options_dict[option_name]) - self.options_dict[option_name] = converter(options[option_name]) - except ValueError: - pass - - for option_name in bad_opts: - options.pop(option_name) - - # Then we set common options from whatever was found - self.set_common_options() - - def set_common_options(self): - pass - - def save_options(self): - """ - Saves options to file. - - We need to only store non-default options. Therefore, we remove all - options whose values are the defaults prior to saving. - """ - - # First we save options from options_dict - for option_name in self.options_dict.keys(): - if self.options_dict[option_name] == self.default_options_dict[option_name]: - self.saved_option_list.remove_option(option_name) - else: - self.saved_option_list.set_option(option_name,self.options_dict[option_name]) - - # Handle common options - self.save_common_options() - - # Finally, save the whole collection into file - self.option_list_collection.save() - - def save_common_options(self): - pass - - def get_filter_number(self): - if self.default_options_dict.has_key('filter'): - return self.options_dict.get('filter', - self.default_options_dict['filter']) - else: - return None - - def set_filter_number(self,val): - self.options_dict['filter'] = val - - def get_person_id(self): - return self.person_id - - def set_person_id(self,val): - self.person_id = val - -#------------------------------------------------------------------------ -# -# Base Options class -# -#------------------------------------------------------------------------ -class Options: - - """ - Defines options and provides handling interface. - - This is a base Options class for the modules. All modules' options - classes should derive from it. - """ - - def __init__(self,name,person_id=None): - """ - Initializes the class, performing usual house-keeping tasks. - Subclasses MUST call this in their __init__() method. - """ - self.set_new_options() - self.enable_options() - - if self.enable_dict: - self.options_dict.update(self.enable_dict) - self.handler = OptionHandler(name,self.options_dict,person_id) - - def set_new_options(self): - """ - Sets options specific for this module. - - Modules that need custom options need to override this method. - Two dictionaries MUST be defined here: - - self.options_dict - This is a dictionary whose keys are option names - and values are the default option values. - - self.options_help - This is a dictionary whose keys are option names - and values are 3- or 4- lists or tuples: - ('=example','Short description',VALUES,DO_PREPEND) - The VALUES is either a single string (in that case - the DO_PREPEND does not matter) or a list/tuple of - strings to list. In that case, if DO_PREPEND evaluates - as True then each string will be preneded with the ordinal - number when help is printed on the command line. - - NOTE: Both dictionaries must have identical keys. - - NOTE: If a particular module does not use custom options, - then it should not override this method. - """ - self.options_dict = {} - self.options_help = {} - - def enable_options(self): - """ - Enables semi-common options for this module. - - The semi-common option is the option which GRAMPS is aware of, - but not common enough to be present in all modules. Here's the list - of possible keys for semi-commons: - - 'filter' - Filter number, selected among filters - available for this module. If defined, - get_module_filters() method must be defined - which returns the list of available filters. - - A self.enable_dict dictionary MUST be defined here, whose keys - are the valid semi-common keys above, and whose values are the - desired default values for semi-commons. - - NOTE: If a particular module does not use semi-common options, - then it should not override this method. - """ - self.enable_dict = {} - - def add_user_options(self,dialog): - """ - Sets up UI controls (widgets) for the options specific for this modul. - - This method MUST be overridden by modules that define new options. - The single argument 'dialog' is the Report.BareReportDialog instance. - Any attribute of the dialog is available. - - After the widgets are defined, they MUST be added to the dialog - using the following call: - dialog.add_options(LABEL,widget) - - NOTE: To really have any effect besides looking pretty, each widget - set up here must be also parsed in the parse_user_options() - method below. - """ - pass - - def parse_user_options(self,dialog): - """ - Parses UI controls (widgets) for the options specific for this module. - - This method MUST be overridden by modules that define new options. - The single argument 'dialog' is the Report.BareReportDialog instance. - Any attribute of the dialog is available. - - After obtaining values from the widgets, they MUST be used to set the - appropriate options_dict values. Otherwise the values will not have - any user-visible effect. - - NOTE: Any widget parsed here MUST be defined and added to the dialog - in the add_user_options() method above. - """ - pass - - def get_filter_number(self): - """ - Return number of a filter to use. - - This method MUST NOT be overridden by subclasses. - """ - return self.handler.get_filter_number() diff --git a/src/PluginUtils/Tool/_Tool.py b/src/PluginUtils/Tool/_Tool.py deleted file mode 100644 index 09b0f9652..000000000 --- a/src/PluginUtils/Tool/_Tool.py +++ /dev/null @@ -1,279 +0,0 @@ -# -# Gramps - a GTK+/GNOME based genealogy program -# -# Copyright (C) 2005-2006 Donald N. Allingham -# -# This program is free software; you can redistribute it and/or modify -# it under the terms of the GNU General Public License as published by -# the Free Software Foundation; either version 2 of the License, or -# (at your option) any later version. -# -# This program is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -# GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License -# along with this program; if not, write to the Free Software -# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -# - -# $Id$ - -"ToolGeneration Framework" - -__author__ = "Alex Roitman" -__version__ = "$Revision$" - -#------------------------------------------------------------------------- -# -# Python modules -# -#------------------------------------------------------------------------- -from types import ClassType, InstanceType -from gettext import gettext as _ -import logging -log = logging.getLogger(".") - -#------------------------------------------------------------------------- -# -# GRAMPS modules -# -#------------------------------------------------------------------------- -import const -import Utils -import GenericFilter -import NameDisplay -from _Options import * - -#------------------------------------------------------------------------- -# -# Constants -# -#------------------------------------------------------------------------- -# Modes for running tools -MODE_GUI = 1 # Standrt tool using GUI -MODE_CLI = 2 # Command line interface (CLI) - -# Tool categories -TOOL_DEBUG = -1 -TOOL_ANAL = 0 -TOOL_DBPROC = 1 -TOOL_DBFIX = 2 -TOOL_REVCTL = 3 -TOOL_UTILS = 4 - -tool_categories = { - TOOL_DEBUG : _("Debug"), - TOOL_ANAL : _("Analysis and Exploration"), - TOOL_DBPROC : _("Database Processing"), - TOOL_DBFIX : _("Database Repair"), - TOOL_REVCTL : _("Revision Control"), - TOOL_UTILS : _("Utilities"), - } - -#------------------------------------------------------------------------- -# -# Report -# -#------------------------------------------------------------------------- -class Tool: - """ - The Tool base class. This is a base class for generating - customized tools. It cannot be used as is, but it can be easily - sub-classed to create a functional tool. - """ - - def __init__(self,database,person,options_class,name): - self.db = database - self.person = person - if type(options_class) == ClassType: - self.options = options_class(name) - elif type(options_class) == InstanceType: - self.options = options_class - - def run_tool(self): - pass - - -#------------------------------------------------------------------------ -# -# Command-line tool -# -#------------------------------------------------------------------------ -class CommandLineTool: - """ - Provides a way to run tool from the command line. - - """ - - def __init__(self,database,name,category,option_class,options_str_dict, - noopt=False): - self.database = database - self.category = category - self.option_class = option_class(name) - self.show = options_str_dict.pop('show',None) - self.options_str_dict = options_str_dict - self.init_options(noopt) - self.parse_option_str() - self.show_options() - - def init_options(self,noopt): - self.options_dict = { - 'id' : '' - } - - self.options_help = { - 'id' : ["=ID","Gramps ID of a central person."], - 'filter' : ["=num","Filter number."], - } - - if noopt: - return - - # Add tool-specific options - for key in self.option_class.handler.options_dict.keys(): - if key not in self.options_dict.keys(): - self.options_dict[key] = self.option_class.handler.options_dict[key] - - # Add help for tool-specific options - for key in self.option_class.options_help.keys(): - if key not in self.options_help.keys(): - self.options_help[key] = self.option_class.options_help[key] - - def parse_option_str(self): - for opt in self.options_str_dict.keys(): - if opt in self.options_dict.keys(): - converter = Utils.get_type_converter(self.options_dict[opt]) - self.options_dict[opt] = converter(self.options_str_dict[opt]) - self.option_class.handler.options_dict[opt] = self.options_dict[opt] - else: - print "Ignoring unknown option: %s" % opt - - person_id = self.options_dict['id'] - self.person = self.database.get_person_from_gramps_id(person_id) - id_list = [] - for person_handle in self.database.get_person_handles(): - person = self.database.get_person_from_handle(person_handle) - id_list.append("%s\t%s" % ( - person.get_gramps_id(), - NameDisplay.displayer.display(person))) - self.options_help['id'].append(id_list) - self.options_help['id'].append(False) - - if self.options_dict.has_key('filter'): - filter_num = self.options_dict['filter'] - self.filters = self.option_class.get_report_filters(self.person) - self.option_class.handler.set_filter_number(filter_num) - - filt_list = [ filt.get_name() for filt in self.filters ] - cust_filt_list = [ filt2.get_name() for filt2 in - GenericFilter.CustomFilters.get_filters() ] - filt_list.extend(cust_filt_list) - self.options_help['filter'].append(filt_list) - self.options_help['filter'].append(True) - - def show_options(self): - if not self.show: - return - elif self.show == 'all': - print " Available options:" - for key in self.options_dict.keys(): - print " %s" % key - print " Use 'show=option' to see description and acceptable values" - elif self.show in self.options_dict.keys(): - print ' %s%s\t%s' % (self.show, - self.options_help[self.show][0], - self.options_help[self.show][1]) - print " Available values are:" - vals = self.options_help[self.show][2] - if type(vals) in [list,tuple]: - if self.options_help[self.show][3]: - for num in range(len(vals)): - print " %d\t%s" % (num,vals[num]) - else: - for val in vals: - print " %s" % val - else: - print " %s" % self.options_help[self.show][2] - - else: - self.show = None - -#------------------------------------------------------------------------ -# -# Generic task functions for tools -# -#------------------------------------------------------------------------ -# Standard GUI tool generic task -def gui_tool(database,person,tool_class,options_class,translated_name, - name,category,callback,parent): - """ - tool - task starts the report. The plugin system requires that the - task be in the format of task that takes a database and a person as - its arguments. - """ - - try: - tool_class(database,person,options_class,name,callback,parent) - except: - log.error("Failed to start tool.", exc_info=True) - -# Command-line generic task -def cli_tool(database,name,category,tool_class,options_class,options_str_dict): - - clt = CommandLineTool(database,name,category, - options_class,options_str_dict) - - # Exit here if show option was given - if clt.show: - return - - # run tool - try: - tool_class(database,clt.person,clt.option_class,name) - except: - log.error("Failed to start tool.", exc_info=True) - -#------------------------------------------------------------------------- -# -# Class handling options for plugins -# -#------------------------------------------------------------------------- -class OptionHandler(OptionHandler): - """ - Implements handling of the options for the plugins. - """ - def __init__(self,module_name,options_dict,person_id=None): - OptionHandler.__init__(self,module_name,options_dict,person_id) - - def init_subclass(self): - self.collection_class = OptionListCollection - self.list_class = OptionList - self.filename = const.tool_options - -#------------------------------------------------------------------------ -# -# Tool Options class -# -#------------------------------------------------------------------------ -class ToolOptions(Options): - - """ - Defines options and provides handling interface. - - This is a base Options class for the tools. All tools' options - classes should derive from it. - """ - - def __init__(self,name,person_id=None): - """ - Initializes the class, performing usual house-keeping tasks. - Subclasses MUST call this in their __init__() method. - """ - self.set_new_options() - self.enable_options() - - if self.enable_dict: - self.options_dict.update(self.enable_dict) - self.handler = OptionHandler(name,self.options_dict,person_id)