comictagger/comictaggerlib/options.py

"""
CLI options class for comictagger app
"""

"""
Copyright 2012  Anthony Beville

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

	http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
"""

import sys
import getopt
import platform
import os
import traceback
import ctversion
import utils
from genericmetadata import GenericMetadata
from comicarchive import MetaDataStyle
from versionchecker import VersionChecker

class Options:
	help_text = """	
Usage: {0} [OPTION]... [FILE LIST]

A utility for reading and writing metadata to comic archives.

If no options are given, {0} will run in windowed mode

  -p, --print                Print out tag info from file.  Specify type
                             (via -t) to get only info of that tag type
      --raw                  With -p, will print out the raw tag block(s)
                             from the file
  -d, --delete               Deletes the tag block of specified type (via -t)
  -c, --copy=SOURCE          Copy the specified source tag block to destination style
                             specified via via -t (potentially lossy operation)
  -s, --save                 Save out tags as specified type (via -t)
                             Must specify also at least -o, -p, or -m
      --nooverwrite          Don't modify tag block if it already exists ( relevent for -s or -c )  
  -1, --assume-issue-one     Assume issue number is 1 if not found ( relevent for -s )  
  -n, --dryrun               Don't actually modify file (only relevent for -d, -s, or -r)
  -t, --type=TYPE            Specify TYPE as either "CR", "CBL", or "COMET" (as either 
                             ComicRack, ComicBookLover, or CoMet style tags, respectivly)
  -f, --parsefilename        Parse the filename to get some info, specifically
                             series name, issue number, volume, and publication 
                             year
  -i, --interactive          Interactively query the user when there are multiple matches for
                             an online search
      --nosummary            Suppress the default summary after a save operation
  -o, --online               Search online and attempt to identify file using 
                             existing metadata and images in archive. May be used
                             in conjuntion with -f and -m
      --id=ID                Use the issue ID when searching online.  Overrides all other metadata
  -m, --metadata=LIST        Explicity define, as a list, some tags to be used                           
                                e.g. "series=Plastic Man , publisher=Quality Comics"
                                     "series=Kickers^, Inc., issue=1, year=1986"
                             Name-Value pairs are comma separated.  Use a "^" to 
                             escape an "=" or a ",", as shown in the example above
                             Some names that can be used:
                                 series, issue, issueCount, year, publisher, title
  -r, --rename               Rename the file based on specified tag style.
      --noabort              Don't abort save operation when online match is of low confidence
  -e, --export-to-zip        Export RAR archive to Zip format
      --delete-rar           Delete original RAR archive after successful export to Zip
      --abort-on-conflict    Don't export to zip if intended new filename exists (Otherwise, creates
                             a new unique filename)
  -S, --script=FILE          Run an "add-on" python script that uses the comictagger library for custom
                             processing.  Script arguments can follow the script name  
  -R, --recursive            Recursively include files in sub-folders                            
  -v, --verbose              Be noisy when doing what it does                            
      --terse                Don't say much (for print mode)                            
      --version              Display version                            
  -h, --help                 Display this message
  
For more help visit the wiki at: http://code.google.com/p/comictagger/
	"""


	def __init__(self):
		self.data_style = None
		self.no_gui = False
		self.filename = None  
		self.verbose = False
		self.terse = False
		self.metadata = None
		self.print_tags = False
		self.copy_tags = False
		self.delete_tags = False
		self.export_to_zip = False
		self.abort_export_on_conflict = False
		self.delete_rar_after_export = False
		self.search_online = False
		self.dryrun = False
		self.abortOnLowConfidence = True
		self.save_tags = False
		self.parse_filename = False
		self.show_save_summary = True
		self.raw = False
		self.rename_file = False
		self.no_overwrite = False
		self.interactive = False
		self.issue_id = None
		self.recursive = False
		self.run_script = False
		self.script = None
		self.assume_issue_is_one_if_not_set = False
		self.file_list = []
		
	def display_msg_and_quit( self, msg, code, show_help=False ):
		appname = os.path.basename(sys.argv[0])
		if msg is not None:
			print( msg )
		if show_help:
			print self.help_text.format(appname)
		else:
			print "For more help, run with '--help'"
		sys.exit(code)
	
	def parseMetadataFromString( self, mdstr ):
		# The metadata string is a comma separated list of name-value pairs
		# The names match the attributes of the internal metadata struct (for now)
		# The caret is the special "escape character", since it's not common in 
		# natural language text

		# example = "series=Kickers^, Inc. ,issue=1, year=1986"
		
		escaped_comma = "^,"
		escaped_equals = "^="		
		replacement_token = "<_~_>"
		
		md = GenericMetadata()

		# First, replace escaped commas with with a unique token (to be changed back later)
		mdstr = mdstr.replace( escaped_comma, replacement_token)
		tmp_list = mdstr.split(",")
		md_list = []
		for item in tmp_list:
			item = item.replace( replacement_token, "," )
			md_list.append(item)
			
		# Now build a nice dict from the list
		md_dict = dict()
		for item in md_list:
			# Make sure to fix any escaped equal signs
			i = item.replace( escaped_equals, replacement_token)
			key,value = i.split("=")
			value = value.replace( replacement_token, "=" ).strip()
			key = key.strip()
			if key.lower() == "credit":
				cred_attribs = value.split(":")
				role = cred_attribs[0]
				person = ( cred_attribs[1] if len( cred_attribs ) > 1 else  "" )
				primary = (cred_attribs[2] if len( cred_attribs ) > 2 else None )
				md.addCredit( person.strip(), role.strip(), True if primary is not None else False )
			else:			
				md_dict[key] = value
		
		# Map the dict to the metadata object
		for key in md_dict:
			if not hasattr(md, key):
				print "Warning: '{0}' is not a valid tag name".format(key)
			else:
				md.isEmpty = False
				setattr( md, key, md_dict[key] )
		#print md
		return md
		
	def parseCmdLineArgs(self):
		
		if platform.system() == "Darwin" and hasattr(sys, "frozen") and sys.frozen == 1:
			# remove the PSN ("process serial number") argument from OS/X
			input_args = [a for a in sys.argv[1:] if "-psn_0_" not in  a ]
		else:
			input_args = sys.argv[1:]
			
		# parse command line options
		try:
			opts, args = getopt.getopt( input_args, 
			           "hpdt:fm:vonsrc:ieRS:1", 
			           [ "help", "print", "delete", "type=", "copy=", "parsefilename", "metadata=", "verbose",
			            "online", "dryrun", "save", "rename" , "raw", "noabort", "terse", "nooverwrite",
			            "interactive", "nosummary", "version", "id=" , "recursive", "script=",
			            "export-to-zip", "delete-rar", "abort-on-conflict", "assume-issue-one" ] )

		except getopt.GetoptError as err:
			self.display_msg_and_quit( str(err), 2 )
		
		# process options
		for o, a in opts:
			if o in ("-h", "--help"):
				self.display_msg_and_quit( None, 0, show_help=True )
			if o in ("-v", "--verbose"):
				self.verbose = True
			if o in ("-S", "--script"):
				self.run_script = True
				self.script = a
			if o in ("-R", "--recursive"):
				self.recursive = True
			if o in ("-p", "--print"):
				self.print_tags = True
			if o in ("-d", "--delete"):
				self.delete_tags = True
			if o in ("-i", "--interactive"):
				self.interactive = True
			if o in ("-c", "--copy"):
				self.copy_tags = True
				if a.lower() == "cr":
					self.copy_source = MetaDataStyle.CIX
				elif a.lower() == "cbl":
					self.copy_source = MetaDataStyle.CBI
				elif a.lower() == "comet":
					self.copy_source = MetaDataStyle.COMET
				else:
					self.display_msg_and_quit( "Invalid copy tag source type", 1 )
			if o in ("-o", "--online"):
				self.search_online = True
			if o in ("-n", "--dryrun"):
				self.dryrun = True
			if o in ("-m", "--metadata"):
				self.metadata = self.parseMetadataFromString(a)
			if o in ("-s", "--save"):
				self.save_tags = True
			if o in ("-r", "--rename"):
				self.rename_file = True
			if o in ("-e", "--export_to_zip"):
				self.export_to_zip = True
			if o  == "--delete-rar":
				self.delete_rar_after_export = True
			if o  == "--abort-on-conflict":
				self.abort_export_on_conflict = True				
			if o in ("-f", "--parsefilename"):
				self.parse_filename = True
			if o == "--id":
				self.issue_id = a
			if o == "--raw":
				self.raw = True
			if o  == "--noabort":
				self.abortOnLowConfidence = False
			if o == "--terse":
				self.terse = True
			if o == "--nosummary":
				self.show_save_summary = False
			if o in ("-1", "--assume-issue-one"):
				self.assume_issue_is_one_if_not_set = True
			if o  == "--nooverwrite":
				self.no_overwrite = True
			if o  == "--version":
				print "ComicTagger {0}:  Copyright (c) 2012-2013 Anthony Beville".format(ctversion.version)
				print "Distributed under Apache License 2.0 (http://www.apache.org/licenses/LICENSE-2.0)"
				new_version = VersionChecker().getLatestVersion("", False)
				if new_version is not None:
					print "----------------------------------------"
					print "New version available online: {0}".format(new_version)
					print "----------------------------------------"
				sys.exit(0)
			if o in ("-t", "--type"):
				if a.lower() == "cr":
					self.data_style = MetaDataStyle.CIX
				elif a.lower() == "cbl":
					self.data_style = MetaDataStyle.CBI
				elif a.lower() == "comet":
					self.data_style = MetaDataStyle.COMET
				else:
					self.display_msg_and_quit( "Invalid tag type", 1 )
						
		if self.print_tags or self.delete_tags or self.save_tags or self.copy_tags or self.rename_file or self.export_to_zip:
			self.no_gui = True

		count = 0
		if self.run_script: count += 1
		if self.print_tags: count += 1
		if self.delete_tags: count += 1
		if self.save_tags: count += 1
		if self.copy_tags: count += 1
		if self.rename_file: count += 1
		if self.export_to_zip: count +=1
		
		if count > 1:
			self.display_msg_and_quit( "Must choose only one action of print, delete, save, copy, rename, export, or run script", 1 )

		if self.script is not None:
			# we were given a script.  special case for the args:
			#  1. ignore everthing before the -S,
			#  2. pass all the ones that follow (including script name) to the script 
			script_args = list()
			for idx, arg in enumerate(sys.argv):
				if arg in [ '-S', '--script']:
					#found script!
					script_args = sys.argv[idx+1:]
					break
			sys.argv = script_args
			if not os.path.exists(self.script):
				print "Can't find {0}".format( self.script )
			else:
				# I *think* this makes sense:
				#  assume the base name of the file is the module name
				#  add the folder of the given file to the python path
				#  import module
				dirname = os.path.dirname(self.script)
				module_name = os.path.splitext(os.path.basename(self.script))[0]
				sys.path = [dirname] + sys.path
				try:
					script =  __import__(module_name)
				
					# Determine if the entry point exists before trying to run it
					if "main" in dir(script):
						script.main()
					else:
						print "Can't find entry point \"main()\" in module \"{0}\"".format( module_name )
				except Exception as e:
					print "Script raised an unhandled exception: ", e	
					print traceback.format_exc()
	
			sys.exit(0)
		
		if len(args) > 0:
			if platform.system() == "Windows":
				# no globbing on windows shell, so do it for them
				import glob
				self.file_list = []
				for item in args:
					self.file_list.extend(glob.glob(item))
				if len(self.file_list) > 0:
					self.filename = self.file_list[0]
			else:
				self.filename = args[0]
				self.file_list = args

		if self.no_gui and self.filename is None:
			self.display_msg_and_quit( "Command requires at least one filename!", 1 )
			
		if self.delete_tags and self.data_style is None:
			self.display_msg_and_quit( "Please specify the type to delete with -t", 1 )
			
		if self.save_tags and self.data_style is None:
			self.display_msg_and_quit( "Please specify the type to save with -t", 1 )

		if self.copy_tags and self.data_style is None:
			self.display_msg_and_quit( "Please specify the type to copy to with -t", 1 )
			
		#if self.rename_file and self.data_style is None:
		#	self.display_msg_and_quit( "Please specify the type to use for renaming with -t", 1 )
		
		if self.recursive:
			self.file_list = utils.get_recursive_filelist( self.file_list )