gramps/gramps2/src/ArgHandler.py

726 lines
28 KiB
Python
Raw Normal View History

#
# Gramps - a GTK+/GNOME based genealogy program
#
# Copyright (C) 2000-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$
# Written by Alex Roitman
"""
Module responsible for handling the command line arguments for GRAMPS.
"""
#-------------------------------------------------------------------------
#
# Standard python modules
#
#-------------------------------------------------------------------------
import os
import getopt
from gettext import gettext as _
#-------------------------------------------------------------------------
#
# gramps modules
#
#-------------------------------------------------------------------------
import const
import GrampsDb
import GrampsMime
import QuestionDialog
import GrampsKeys
import RecentFiles
import PluginMgr
2004-12-22 07:26:37 +05:30
import Report
2005-12-06 12:08:09 +05:30
import Tool
#-------------------------------------------------------------------------
#
# ArgHandler
#
#-------------------------------------------------------------------------
class ArgHandler:
"""
This class is responsible for handling command line arguments (if any)
given to gramps. The valid arguments are:
FILE : filename to open.
All following arguments will be ignored.
-i, --import=FILE : filename to import.
-O, --open=FILE : filename to open.
-o, --output=FILE : filename to export.
-f, --format=FORMAT : format of the file preceding this option.
If the filename (no flags) is specified, the interactive session is
launched using data from filename. If the filename is not in a natvive
(grdb) format, dialog will be presented to set up a grdb database.
In this mode (filename, no flags), the rest of the arguments is ignored.
This is a mode suitable by default for GUI launchers, mime type handlers,
and the like
If no filename or -i option is given, a new interactive session (empty
database) is launched, since no data is given anyway.
If -O or -i option is given, but no -o or -a options are given, an
interactive session is launched with the FILE (specified with -i).
If both input (-O or -i) and processing (-o or -a) options are given,
interactive session will not be launched.
"""
def __init__(self,state,vm,args):
self.state = state
self.vm = vm
self.args = args
self.open_gui = None
self.open = None
self.exports = []
self.actions = []
self.imports = []
self.parse_args()
self.handle_args()
#-------------------------------------------------------------------------
#
# Argument parser: sorts out given arguments
#
#-------------------------------------------------------------------------
def parse_args(self):
"""
Fill in lists with open, exports, imports, and actions options.
"""
try:
options,leftargs = getopt.getopt(self.args[1:],
const.shortopts,const.longopts)
except getopt.GetoptError:
# return without filling anything if we could not parse the args
print "Error parsing arguments: %s " % self.args[1:]
return
if leftargs:
# if there were an argument without option, use it as a file to
# open and return
self.open_gui = leftargs[0]
print "Trying to open: %s ..." % leftargs[0]
return
for opt_ix in range(len(options)):
o,v = options[opt_ix]
if o in ( '-O', '--open'):
fname = v
ftype = GrampsMime.get_type(
os.path.abspath(os.path.expanduser(fname)))
if opt_ix<len(options)-1 \
and options[opt_ix+1][0] in ( '-f', '--format'):
format = options[opt_ix+1][1]
if format not in ('gedcom','gramps-xml','grdb'):
print "Invalid format: %s" % format
print "Ignoring input file: %s" % fname
continue
elif ftype == const.app_gedcom:
format = 'gedcom'
elif ftype == const.app_gramps_xml:
format = 'gramps-xml'
elif ftype == const.app_gramps:
format = 'grdb'
else:
print "Unrecognized format for input file %s" % fname
print "Ignoring input file: %s" % fname
continue
self.open = (fname,format)
elif o in ( '-i', '--import'):
fname = v
ftype = GrampsMime.get_type(
os.path.abspath(os.path.expanduser(fname)))
if opt_ix<len(options)-1 \
and options[opt_ix+1][0] in ( '-f', '--format'):
format = options[opt_ix+1][1]
if format not in ('gedcom',
'gramps-xml',
'gramps-pkg',
'grdb',
'geneweb'):
print "Invalid format: %s" % format
print "Ignoring input file: %s" % fname
continue
elif ftype == const.app_gedcom:
format = 'gedcom'
elif ftype == const.app_gramps_package:
format = 'gramps-pkg'
elif ftype == const.app_gramps_xml:
format = 'gramps-xml'
elif ftype == const.app_gramps:
format = 'grdb'
elif ftype == const.app_geneweb:
format = 'geneweb'
else:
print "Unrecognized format for input file %s" % fname
print "Ignoring input file: %s" % fname
continue
self.imports.append((fname,format))
elif o in ( '-o', '--output' ):
outfname = v
if opt_ix<len(options)-1 \
and options[opt_ix+1][0] in ( '-f', '--format'):
outformat = options[opt_ix+1][1]
if outformat not in ('gedcom',
'gramps-xml',
'gramps-pkg',
'grdb',
'iso',
'wft',
'geneweb'):
print "Invalid format: %s" % outformat
print "Ignoring output file: %s" % outfname
continue
elif outfname[-3:].upper() == "GED":
outformat = 'gedcom'
elif outfname[-4:].upper() == "GPKG":
outformat = 'gramps-pkg'
elif outfname[-3:].upper() == "WFT":
outformat = 'wft'
elif outfname[-2:].upper() == "GW":
outformat = 'geneweb'
elif outfname[-6:].upper() == "GRAMPS":
outformat = 'gramps-xml'
2005-12-06 12:08:09 +05:30
elif outfname[-4:].upper() == "GRDB":
outformat = 'grdb'
else:
print "Unrecognized format for output file %s" % outfname
print "Ignoring output file: %s" % outfname
continue
self.exports.append((outfname,outformat))
elif o in ( '-a', '--action' ):
action = v
2005-12-06 12:08:09 +05:30
if action not in ( 'check', 'summary', 'report', 'tool' ):
print "Unknown action: %s. Ignoring." % action
continue
2004-12-22 07:26:37 +05:30
options_str = ""
if opt_ix<len(options)-1 \
and options[opt_ix+1][0] in ( '-p', '--options' ):
options_str = options[opt_ix+1][1]
self.actions.append((action,options_str))
#-------------------------------------------------------------------------
#
# open data in native format
#
#-------------------------------------------------------------------------
def auto_save_load(self,filename):
filename = os.path.normpath(os.path.abspath(filename))
filetype = GrampsMime.get_type(filename)
if filetype in (const.app_gramps,
const.app_gramps_xml,
const.app_gedcom):
print "Here"
return self.vm.open_native(filename,filetype)
else:
return 0
#-------------------------------------------------------------------------
#
# Overall argument handler:
# sorts out the sequence and details of operations
#
#-------------------------------------------------------------------------
def handle_args(self):
"""
Depending on the given arguments, import or open data, launch
session, write files, and/or perform actions.
"""
if self.open_gui:
# Filename was given. Open a session with that file. Forget
# the rest of given arguments.
success = False
filename = os.path.abspath(os.path.expanduser(self.open_gui))
filetype = GrampsMime.get_type(filename)
if filetype in (const.app_gramps,const.app_gedcom,
const.app_gramps_xml):
# Say the type outloud
if filetype == const.app_gramps:
print "Type: GRAMPS database"
elif filetype == const.app_gedcom:
print "Type: GEDCOM file"
elif filetype == const.app_gramps_xml:
print "Type: GRAMPS XML database"
if self.auto_save_load(filename):
print "Opened successfully!"
success = True
else:
print "Cannot open %s. Exiting..."
elif filetype in (const.app_gramps_package,):
QuestionDialog.OkDialog( _("Opening non-native format"),
_("New GRAMPS database has to be set up "
"when opening non-native formats. The "
"following dialog will let you select "
"the new database."),
self.parent.topWindow)
prompter = NewNativeDbPrompter(self.parent)
if not prompter.chooser():
QuestionDialog.ErrorDialog(
_("New GRAMPS database was not set up"),
_('GRAMPS cannot open non-native data '
'without setting up new GRAMPS database.'))
print "Cannot continue without native database. Exiting..."
os._exit(1)
elif filetype == const.app_gramps_package:
print "Type: GRAMPS package"
self.parent.read_pkg(filename)
success = True
else:
print "Unknown file type: %s" % filetype
QuestionDialog.ErrorDialog(
_("Could not open file: %s") % filename,
_('File type "%s" is unknown to GRAMPS.\n\n'
'Valid types are: GRAMPS database, GRAMPS XML, '
'GRAMPS package, and GEDCOM.') % filetype)
print "Exiting..."
os._exit(1)
if success:
# Add the file to the recent items
RecentFiles.recent_files(filename,filetype)
self.parent.build_recent_menu()
else:
os._exit(1)
return
if self.open:
# Filename to open was given. Open it natively (grdb or any of
# the InMem formats, without setting up a new database. Then
# go on and process the rest of the command line arguments.
#self.parent.cl = bool(self.exports or self.actions)
name,format = self.open
success = False
filename = os.path.abspath(os.path.expanduser(name))
if format == 'grdb':
print "Type: GRAMPS database"
elif format == 'gedcom':
print "Type: GEDCOM"
elif format == 'gramps-xml':
print "Type: GRAMPS XML"
else:
print "Unknown file type: %s" % format
print "Exiting..."
os._exit(1)
if self.auto_save_load(filename):
print "Opened successfully!"
success = True
else:
print "Error opening the file."
print "Exiting..."
os._exit(1)
if self.imports:
#self.parent.cl = bool(self.exports or self.actions or self.parent.cl)
# Create dir for imported database(s)
self.impdir_path = os.path.expanduser("~/.gramps/import" )
self.imp_db_path = os.path.expanduser(
"~/.gramps/import/import_db.grdb" )
if not os.path.isdir(self.impdir_path):
try:
os.mkdir(self.impdir_path,0700)
except:
print "Could not create import directory %s. Exiting." \
% self.impdir_path
os._exit(1)
elif not os.access(self.impdir_path,os.W_OK):
print "Import directory %s is not writable. Exiting." \
% self.impdir_path
os._exit(1)
# and clean it up before use
files = os.listdir(self.impdir_path) ;
for fn in files:
if os.path.isfile(os.path.join(self.impdir_path,fn)):
os.remove(os.path.join(self.impdir_path,fn))
self.parent.load_database(self.imp_db_path)
for imp in self.imports:
print "Importing: file %s, format %s." % imp
self.cl_import(imp[0],imp[1])
elif len(self.args) > 1 and not self.open:
print "No data was given -- will launch interactive session."
print "To use in the command-line mode,", \
"supply at least one input file to process."
print "Launching interactive session..."
2005-12-07 02:39:00 +05:30
# if self.parent.cl:
# for (action,options_str) in self.actions:
# print "Performing action: %s." % action
# if options_str:
# print "Using options string: %s" % options_str
# self.cl_action(action,options_str)
2005-12-06 12:08:09 +05:30
2005-12-07 02:39:00 +05:30
# for expt in self.exports:
# print "Exporting: file %s, format %s." % expt
# self.cl_export(expt[0],expt[1])
2005-12-06 12:08:09 +05:30
2005-12-07 02:39:00 +05:30
# print "Cleaning up."
# # remove import db after use
# self.parent.db.close()
# if self.imports:
# os.remove(self.imp_db_path)
# print "Exiting."
# os._exit(0)
if self.imports:
self.parent.import_tool_callback()
elif GrampsKeys.get_lastfile() and GrampsKeys.get_autoload():
self.auto_save_load(GrampsKeys.get_lastfile())
#-------------------------------------------------------------------------
#
# Import handler
#
#-------------------------------------------------------------------------
def cl_import(self,filename,format):
"""
Command-line import routine. Try to import filename using the format.
Any errors will cause the os._exit(1) call.
"""
if format == 'grdb':
filename = os.path.normpath(os.path.abspath(filename))
try:
GrampsDb.gramps_db_reader_factory(const.app_gramps)(self.parent.db,filename,None)
except:
print "Error importing %s" % filename
os._exit(1)
elif format == 'gedcom':
from GrampsDb import GedcomParser
filename = os.path.normpath(os.path.abspath(filename))
try:
g = GedcomParser(self.parent.db,filename,None)
g.parse_gedcom_file()
g.resolve_refns()
del g
except:
print "Error importing %s" % filename
os._exit(1)
elif format == 'gramps-xml':
try:
GrampsDb.gramps_db_reader_factory(const.app_gramps_xml)(self.parent.db,filename,None,self.parent.cl)
except:
print "Error importing %s" % filename
os._exit(1)
elif format == 'geneweb':
import ImportGeneWeb
filename = os.path.normpath(os.path.abspath(filename))
try:
ImportGeneWeb.importData(self.parent.db,filename,None)
except:
print "Error importing %s" % filename
os._exit(1)
elif format == 'gramps-pkg':
# Create tempdir, if it does not exist, then check for writability
tmpdir_path = os.path.expanduser("~/.gramps/tmp" )
if not os.path.isdir(tmpdir_path):
try:
os.mkdir(tmpdir_path,0700)
except:
print "Could not create temporary directory %s" \
% tmpdir_path
os._exit(1)
elif not os.access(tmpdir_path,os.W_OK):
print "Temporary directory %s is not writable" % tmpdir_path
os._exit(1)
else: # tempdir exists and writable -- clean it up if not empty
2004-06-22 04:54:51 +05:30
files = os.listdir(tmpdir_path) ;
for fn in files:
os.remove( os.path.join(tmpdir_path,fn) )
try:
import TarFile
t = TarFile.ReadTarFile(filename,tmpdir_path)
2004-06-22 04:54:51 +05:30
t.extract()
t.close()
except:
print "Error extracting into %s" % tmpdir_path
os._exit(1)
dbname = os.path.join(tmpdir_path,const.xmlFile)
try:
GrampsDb.gramps_db_reader_factory(const.app_gramps_xml)(self.parent.db,dbname,None)
except:
print "Error importing %s" % filename
os._exit(1)
# Clean up tempdir after ourselves
files = os.listdir(tmpdir_path)
for fn in files:
os.remove(os.path.join(tmpdir_path,fn))
os.rmdir(tmpdir_path)
else:
print "Invalid format: %s" % format
os._exit(1)
if not self.parent.cl:
return self.parent.post_load(self.imp_db_path)
#-------------------------------------------------------------------------
#
# Export handler
#
#-------------------------------------------------------------------------
def cl_export(self,filename,format):
"""
Command-line export routine.
Try to write into filename using the format.
Any errors will cause the os._exit(1) call.
"""
2005-12-06 12:08:09 +05:30
if format == 'grdb':
try:
GrampsDb.gramps_db_writer_factory(const.app_gramps)(self.parent.db,filename)
2005-12-06 12:08:09 +05:30
except:
print "Error exporting %s" % filename
os._exit(1)
elif format == 'gedcom':
try:
gw = GrampsDb.GedcomWriter(self.parent.db,None,1,filename)
ret = gw.export_data(filename)
except:
print "Error exporting %s" % filename
os._exit(1)
elif format == 'gramps-xml':
filename = os.path.normpath(os.path.abspath(filename))
if filename:
try:
g = GrampsDb.XmlWriter(self.parent.db,None,0,1)
ret = g.write(filename)
except:
print "Error exporting %s" % filename
os._exit(1)
elif format == 'gramps-pkg':
try:
import WritePkg
writer = WritePkg.PackageWriter(self.parent.db,filename)
ret = writer.export()
except:
print "Error creating %s" % filename
os._exit(1)
elif format == 'iso':
import WriteCD
try:
writer = WriteCD.PackageWriter(self.parent.db,filename,1)
ret = writer.export()
except:
print "Error exporting %s" % filename
os._exit(1)
elif format == 'wft':
import WriteFtree
try:
writer = WriteFtree.FtreeWriter(self.parent.db,None,1,filename)
ret = writer.export_data()
except:
print "Error exporting %s" % filename
os._exit(1)
elif format == 'geneweb':
import WriteGeneWeb
try:
writer = WriteGeneWeb.GeneWebWriter(self.parent.db,
None,1,filename)
ret = writer.export_data()
except:
print "Error exporting %s" % filename
os._exit(1)
else:
print "Invalid format: %s" % format
os._exit(1)
#-------------------------------------------------------------------------
#
# Action handler
#
#-------------------------------------------------------------------------
2004-12-22 07:26:37 +05:30
def cl_action(self,action,options_str):
"""
Command-line action routine. Try to perform specified action.
Any errors will cause the os._exit(1) call.
"""
if action == 'check':
import Check
checker = Check.CheckIntegrity(self.parent.db,None,None)
checker.check_for_broken_family_links()
checker.cleanup_missing_photos(1)
checker.check_parent_relationships()
checker.cleanup_empty_families(0)
errs = checker.build_report(1)
if errs:
checker.report(1)
elif action == 'summary':
import Summary
text = Summary.build_report(self.parent.db,None)
print text
2004-12-22 07:26:37 +05:30
elif action == "report":
try:
options_str_dict = dict( [ tuple(chunk.split('='))
for chunk in options_str.split(',') ] )
except:
options_str_dict = {}
print "Ignoring invalid options string."
name = options_str_dict.pop('name',None)
if not name:
print "Report name not given. Please use name=reportname"
os._exit(1)
for item in PluginMgr.cl_list:
2004-12-22 07:26:37 +05:30
if name == item[0]:
category = item[1]
report_class = item[2]
options_class = item[3]
2005-12-06 12:08:09 +05:30
if category in (Report.CATEGORY_BOOK,Report.CATEGORY_CODE,
Report.CATEGORY_WEB):
options_class(self.parent.db,name,
category,options_str_dict)
2004-12-22 07:26:37 +05:30
else:
Report.cl_report(self.parent.db,name,category,
2005-12-06 12:08:09 +05:30
report_class,options_class,
options_str_dict)
2004-12-22 07:26:37 +05:30
return
print "Unknown report name. Available names are:"
for item in PluginMgr.cl_list:
2004-12-22 07:26:37 +05:30
print " %s" % item[0]
2005-12-06 12:08:09 +05:30
elif action == "tool":
try:
options_str_dict = dict( [ tuple(chunk.split('=')) for
chunk in options_str.split(',') ] )
except:
options_str_dict = {}
print "Ignoring invalid options string."
name = options_str_dict.pop('name',None)
if not name:
print "Tool name not given. Please use name=toolname"
os._exit(1)
for item in PluginMgr.cli_tool_list:
if name == item[0]:
category = item[1]
tool_class = item[2]
options_class = item[3]
Tool.cli_tool(self.parent.db,name,category,
tool_class,options_class,options_str_dict)
return
print "Unknown tool name. Available names are:"
for item in PluginMgr.cli_tool_list:
print " %s" % item[0]
else:
print "Unknown action: %s." % action
os._exit(1)
#-------------------------------------------------------------------------
#
# NewNativeDbPrompter
#
#-------------------------------------------------------------------------
class NewNativeDbPrompter:
"""
This class allows to set up a new empty native (grdb) database.
The filename is forced to have an '.grdb' extension. If not given,
it is appended.
"""
def __init__(self,parent,parent_window=None):
self.parent = parent
self.parent_window = parent_window
def chooser(self):
"""
Select the new file. Suggest the Untitled_X.grdb name.
Return 1 when selection is made and 0 otherwise.
"""
choose = gtk.FileChooserDialog(_('GRAMPS: Create GRAMPS database'),
self.parent_window,
gtk.FILE_CHOOSER_ACTION_SAVE,
(gtk.STOCK_CANCEL,
gtk.RESPONSE_CANCEL,
gtk.STOCK_OPEN,
gtk.RESPONSE_OK))
self.parent.clear_database()
# Always add automatic (macth all files) filter
add_all_files_filter(choose)
add_grdb_filter(choose)
# Suggested folder: try last open file, import, then last export,
# then home.
default_dir = os.path.split(GrampsKeys.get_lastfile())[0] + os.path.sep
if len(default_dir)<=1:
default_dir = GrampsKeys.get_last_import_dir()
if len(default_dir)<=1:
default_dir = GrampsKeys.get_last_export_dir()
if len(default_dir)<=1:
default_dir = '~/'
new_filename = Utils.get_new_filename('grdb',default_dir)
choose.set_current_folder(default_dir)
choose.set_current_name(os.path.split(new_filename)[1])
while (True):
response = choose.run()
if response == gtk.RESPONSE_OK:
filename = choose.get_filename()
if filename == None:
continue
if os.path.splitext(filename)[1] != ".grdb":
filename = filename + ".grdb"
choose.destroy()
self.parent.db = GrampsDb.gramps_db_factory(const.app_gramps)()
self.parent.read_file(filename)
# Add the file to the recent items
RecentFiles.recent_files(filename,const.app_gramps)
self.parent.build_recent_menu()
return True
else:
choose.destroy()
return False
choose.destroy()
return False
def add_all_files_filter(chooser):
"""
Add an all-permitting filter to the file chooser dialog.
"""
mime_filter = gtk.FileFilter()
mime_filter.set_name(_('All files'))
mime_filter.add_pattern('*')
chooser.add_filter(mime_filter)
def add_grdb_filter(chooser):
"""
Add a GRDB filter to the file chooser dialog.
"""
mime_filter = gtk.FileFilter()
mime_filter.set_name(_('GRAMPS databases'))
mime_filter.add_mime_type(const.app_gramps)
chooser.add_filter(mime_filter)