def main():
usage = """usage: %prog [options] langid
"""
parser = GlobalOptionsParser(usage=usage)
(options, args) = parser.parse_args()
parser.check_args(1, args)
session = LionDB(options.config, options.trace, options.app)
langid = args[0]
table = session.make_table_name(langid)
session.execute_query("SELECT remarks, xmlid, textstring from %s" % table)
results = session.cursor.fetchall()
skipped = 0
changed = 0
for remarks, xmlid, textstring in results:
if remarks != None and remarks != "":
request = """UPDATE %s SET textstring="%s" WHERE xmlid="%s" """ % (table, remarks, xmlid)
# print request
session.execute_query(request)
changed +=1
else:
print "skipping %s (text = %s)" % (xmlid, textstring)
skipped +=1
print "Skipped %d, Changed %d" % (skipped, changed)
def main():
usage = """usage: %prog [options] langid localaudiodir"""
parser = GlobalOptionsParser(usage=usage)
(options, args) = parser.parse_args()
parser.check_args(2, args)
session = LionDB(options.config, options.trace, options.app)
langid, audiodir = args
data = session.get_text_audio_data(langid, audiodir)
table = ""
for reftext, text, audio, xmlid in data:
row = HTML_TR % {
"xmlid": xmlid,
"reftext": reftext,
"text": text,
"audio": audio,
"audiofile": os.path.basename(audio)
}
table += row
doc = HTML5 % {
"title": "Text and audio data",
"lang": langid,
"table": table
}
print doc
def main():
usage = """usage: %prog [options] sqlstatement
Type %(table)s as a token for the language table name
This will run the sql query on all language tables"""
parser = GlobalOptionsParser(usage=usage)
(options, args) = parser.parse_args()
parser.check_args(1, args)
session = LionDB(options.config, options.trace, options.app)
sql = args[0]
request = "SELECT langid FROM languages"
session.execute_query(request)
all_langs = session.cursor.fetchall()
if parser.safety_check("run this query on each language table") == False:
exit(1)
for l in all_langs:
request = sql % {"table": session.make_table_name(l[0])}
try:
session.execute_query(request)
if session.cursor.rowcount > 0:
for r in session.cursor.fetchall():
for field in r:
print field
except Exception, e:
print "Exception: %s" % e
def main():
usage = """usage: %prog
Report if all tables are the same length"""
parser = GlobalOptionsParser(usage=usage)
(options, args) = parser.parse_args()
parser.check_args(0, args)
session = LionDB(options.config, options.trace, options.app)
# first get a list of the diffs between each language and the master language
request = "SELECT langid FROM languages"
session.execute_query(request)
langs = session.cursor.fetchall()
any_diffs_found = False
for l in langs:
lid = l[0]
diffs = session.list_langtable_diffs(lid, session.masterlang)
if diffs != None:
any_diffs_found = True
longer, shorter, data = diffs
if longer == lid:
print "%s has more entries than %s" % (lid, session.masterlang)
else:
print "%s has fewer entries than %s" % (lid,
session.masterlang)
if any_diffs_found == False:
print "All tables are the same length as %s" % session.masterlang
def main():
usage = """usage: %prog"""
parser = GlobalOptionsParser(usage=usage)
parser.add_option("-s",
"--short",
dest="shortlist",
help="Show only the language name",
action="store_true",
default=False)
parser.add_option("-d",
"--date",
dest="orderbydate",
help="Order by login date",
action="store_true",
default=False)
parser.add_option(
"-w",
"--work",
dest="orderbytodo",
help="Order by the number of work items remaining (new or todo)",
action="store_true",
default=False)
(options, args) = parser.parse_args()
parser.check_args(0, args)
session = LionDB(options.config, options.trace, options.app)
results = session.list_all_languages(options.orderbydate,
options.orderbytodo)
# the data coming back looks like this:
# workleft (optional), langid, langname, realname, username, password, lastlogin (optional)
# workleft and lastlogin are mutually exclusive
# if workleft is being returned, then the remaining results are wrapped up in a tuple
# as in (34, ('langid', 'langname', etc))
print "%d languages" % len(results)
if options.orderbydate == True:
print "Showing most recently logged-in first"
if options.orderbytodo == True:
print session.get_table_length(session.masterlang)
print session.masterlang
print "Showing the most work remaining first (items out of %s total still needing translation)" % \
session.get_table_length(session.masterlang)
for r in results:
if options.orderbytodo == False:
usernamepwd = "(%s, %s)" % (r[3], r[4])
if options.shortlist == True:
line = r[1]
else:
if options.orderbydate == True:
line = "%-25s%-10s%-30s%-20s %-10s" % (r[5], r[0], r[1], r[2],
usernamepwd)
elif options.orderbytodo == True:
usernamepwd = "(%s, %s)" % (r[1][3], r[1][4])
line = "%-25s%-10s%-30s%-20s %-10s" % (r[0], r[1][0], r[1][1],
r[1][2], usernamepwd)
else:
line = "%-10s%-30s%-20s %-10s" % (r[0], r[1], r[2],
usernamepwd)
print line.encode("utf-8")
def main():
usage = """usage: %prog [options] langid audioDir"""
parser = GlobalOptionsParser(usage=usage)
(options, args) = parser.parse_args()
parser.check_args(2, args)
session = LionDB(options.config, options.trace, options.app)
langid, audio_dir = args
session.import_audio_by_number(langid, audio_dir)
def main():
parser = GlobalOptionsParser(usage="usage: %prog [options] langid dir")
(options, args) = parser.parse_args()
parser.check_args(2, args)
session = LionDB(options.config, options.trace)
langid, dir = args
session.trace_msg("Export for langid=%s to directory %s" % (langid, dir))
additional_params = (dir, )
print session.module_export(langid, 0, additional_params)
def main():
usage = """usage: %prog [options] langid string stringid"""
parser = GlobalOptionsParser(usage=usage)
(options, args) = parser.parse_args()
parser.check_args(3, args)
session = LionDB(options.config, options.trace, options.app)
langid, string, stringid = args
session.change_item(langid, string, stringid)
def main():
usage = """usage: %prog [options] local_langpack_dir"""
parser = GlobalOptionsParser(usage=usage)
parser.add_option("-v",
"--amisversion",
dest="amis_version",
type="string",
default="3.1",
help="Target version of AMIS (default = 3.1)")
parser.add_option("-y",
"--tmp",
dest="tmp",
default=False,
action="store_true",
help="Save output files in /tmp")
parser.add_option("-x",
"--all",
dest="all",
default=False,
action="store_true",
help="Export all languages")
parser.add_option("-l",
"--langid",
dest="langid",
default="",
help="language ID")
parser.add_option("-z",
"--custom",
dest="custom",
default="",
help="a comma-separated list of language IDs")
(options, args) = parser.parse_args()
parser.check_args(1, args)
langpacks_dir = args[0]
session = LionDB(options.config, options.trace, "amis")
# export all languages (see LANGS list above)
if options.all == True:
for l in LANGS:
process_one(l, langpacks_dir, options, session)
# export one language
else:
if options.custom != "":
custom_langs = options.custom.split(",")
for l in custom_langs:
process_one(l.strip(), langpacks_dir, options, session)
else:
if options.langid != "":
process_one(options.langid, langpacks_dir, options, session)
else:
session.die(
"No lang ID specified. Use --all, --custom, or --langid to specify all, a custom set, or a single language."
)
return
def main():
usage = """usage: %prog [options] string stringid
Edits the master language and updates all other languages."""
parser = GlobalOptionsParser(usage=usage)
(options, args) = parser.parse_args()
parser.check_args(2, args)
session = LionDB(options.config, options.trace, options.app)
string, stringid = args
session.change_item_master(string, stringid)
def main():
usage = """usage: %prog [options] langid"""
parser = GlobalOptionsParser(usage=usage)
(options, args) = parser.parse_args()
parser.check_args(1, args)
session = LionDB(options.config, options.trace, options.app)
langid = args[0]
if parser.safety_check("remove %s" % langid) == True:
session.remove_language(langid)
def main():
usage = """usage: %prog [options] langid"""
parser = GlobalOptionsParser(usage=usage)
(options, args) = parser.parse_args()
parser.check_args(1, args)
session = LionDB(options.config, options.trace, "amis")
langid = args[0]
print session.module_export(langid, 2, None)
def main():
usage = """usage: %prog langid"""
parser = GlobalOptionsParser(usage=usage)
(options, args) = parser.parse_args()
parser.check_args(1, args)
session = LionDB(options.config, options.trace, options.app)
results = session.all_strings_bilingual(args[0])
for r in results:
print "%s, %s" % (r[0], r[1])
def main():
usage = """usage: %prog [options] langid stringid"""
parser = GlobalOptionsParser(usage=usage)
(options, args) = parser.parse_args()
parser.check_args(2, args)
session = LionDB(options.config, options.trace, options.app)
langid, stringid = args
# do a safety check to see if the user really wants to remove a string
if parser.safety_check("remove a string") == True:
session.remove_item(langid, stringid)
def main():
usage = """usage: %prog [options] stringid
Edits the master language and updates all other languages."""
parser = GlobalOptionsParser(usage=usage)
(options, args) = parser.parse_args()
parser.check_args(1, args)
session = LionDB(options.config, options.trace, options.app)
stringid = args[0]
# do a safety check to see if the user really wants to remove a string
if parser.safety_check("remove a string in ALL tables") == True:
session.remove_item_master(stringid)
def main():
usage = """usage: %prog [options] langid output_dir local_audio_dir"""
parser = GlobalOptionsParser(usage=usage)
(options, args) = parser.parse_args()
parser.check_args(3, args)
session = LionDB(options.config, options.trace, "amis")
langid = args[0]
outputdir = args[1]
local_audio_dir = args[2]
session.module_export(langid, 3, (outputdir, local_audio_dir))
def main():
usage = """usage: %prog [options] langid
"""
parser = GlobalOptionsParser(usage=usage)
(options, args) = parser.parse_args()
parser.check_args(1, args)
session = LionDB(options.config, options.trace, options.app)
langid = args[0]
user_info = session.get_user_info(langid)
s = ""
for i in user_info:
s += "%-25s" % i
print s
def main():
parser = GlobalOptionsParser(
usage="usage: %prog [options] langid file ...")
parser.add_option("-i",
"--importtype",
dest="import_type",
default=1,
help="Import type (1: import, 2: populate, 3: update")
(options, args) = parser.parse_args()
parser.check_args_atleast(2, args)
session = LionDB(options.config, options.trace)
langid = args.pop(0)
session.trace_msg("Import for langid=%s with %s" % (langid, args))
session.module_import(args, langid, int(options.import_type))
def main():
"""Generate the TTS prompts for AMIS. Run on OS X; be configured to use the server DB."""
usage = """usage: %prog [options] langid"""
parser = GlobalOptionsParser(usage=usage)
(options, args) = parser.parse_args()
parser.check_args(1, args)
session = LionDB(options.config, options.trace, "amis")
langid = args[0]
dir = "/tmp/%s/" % langid
session.generate_audio(langid, dir)
print "your audio files are in " + dir
def main():
usage = """usage: %prog [options] langid username password
The language referenced by langid must already exist.
"""
parser = GlobalOptionsParser(usage=usage)
parser.add_option("-r", "--realname", dest="realname", default="",
help="The full name of the user")
parser.add_option("-e", "--email", dest="email", default="",
help="The user's email address")
(options, args) = parser.parse_args()
parser.check_args(3, args)
session = LionDB(options.config, options.trace, options.app)
langid, username, pwd = args
session.add_user(langid, username, pwd, options.realname, options.email)
def main():
usage = """usage: %prog [options] sqlstatement
Run a single SQL query."""
parser = GlobalOptionsParser(usage=usage)
(options, args) = parser.parse_args()
parser.check_args(1, args)
session = LionDB(options.config, options.trace, options.app)
sql = args[0]
session.execute_query(sql)
if session.cursor.rowcount != 0:
for r in session.cursor.fetchall():
for field in r:
print field
def main():
usage = """usage: %prog [options] langid"""
parser = GlobalOptionsParser(usage=usage)
parser.add_option("-v",
"--amisversion",
dest="amis_version",
default="3.1",
help="Target version of AMIS (default = 3.1)")
(options, args) = parser.parse_args()
parser.check_args(1, args)
session = LionDB(options.config, options.trace, "amis")
langid = args[0]
print session.module_export(langid, 2, (options.amis_version, ))
def main():
usage = """usage: %prog [options] sqlstatement
Type %(table)s as a token for the language table name
This will run the sql query on all language tables"""
parser = GlobalOptionsParser(usage=usage)
(options, args) = parser.parse_args()
parser.check_args(1, args)
session = LionDB(options.config, options.trace, options.app)
if parser.safety_check("run this query on each language table") == False:
exit(1)
sql = args[0]
run_sql_on_all_lang_tables(session, sql)
def main():
usage = """usage: %prog langid1 langid2"""
parser = GlobalOptionsParser(usage=usage)
(options, args) = parser.parse_args()
parser.check_args(2, args)
session = LionDB(options.config, options.trace, options.app)
results = session.list_langtable_diffs(args[0], args[1])
if results == None:
print "Tables are equal"
else:
longer, shorter, data = results
print "Items in %s that are not in %s" % (longer, shorter)
for r in data:
print "%-10s%-10s" % (r[0], r[1])
def main():
import_choices = {1: "Rebuild a language table from an AMIS Accessible UI XML file.",
2: "Update existing data from an AMIS Accessible UI XML file.",
3: "Update only the audio data for existing table elements from an AMIS Accessible UI XML file."}
import_description = '\n'.join(["%d: %s" % (a, b) for a, b in import_choices.items()])
usage = """usage: %prog [options] langid file"""
parser = GlobalOptionsParser(usage=usage)
parser.add_option("-i", "--importtype", dest="import_type", type="int", default=1,
help=import_description)
(options, args) = parser.parse_args()
parser.check_args(2, args)
session = LionDB(options.config, options.trace, "amis")
langid, file = args
session.module_import(file, langid, options.import_type)
def main():
usage = """usage: %prog [options] langid string stringid refid keys
string: the human-readable name for the accelerator shortcut
refid: the id of the string label for the command referenced by the accelerator
keys: the actual keys used to access the accelerator shortcut
e.g.
%prog eng-US Escape t123 t345 esc
"""
parser = GlobalOptionsParser(usage=usage)
(options, args) = parser.parse_args()
parser.check_args(5, args)
session = LionDB(options.config, options.trace, options.app)
langid, string, stringid, refid, keys = args
session.add_accelerator(langid, string, stringid, refid, keys)
def main():
usage = """usage: %prog [options] langid output_dir local_audio_dir"""
parser = GlobalOptionsParser(usage=usage)
parser.add_option("-v",
"--amisversion",
dest="amis_version",
default="3.1",
help="Target version of AMIS (default = 3.1)")
(options, args) = parser.parse_args()
parser.check_args(3, args)
session = LionDB(options.config, options.trace, "amis")
langid = args[0]
outputdir = args[1]
local_audio_dir = args[2]
session.module_export(langid, 3,
(options.amis_version, outputdir, local_audio_dir))
def main():
# who customized the menu mnemonics?
usage = """usage: %prog [options]"""
parser = GlobalOptionsParser(usage=usage)
(options, args) = parser.parse_args()
parser.check_args(0, args)
session = LionDB(options.config, options.trace, options.app)
# top level menu items
request = "SELECT xmlid FROM eng_US WHERE istoplevel=1 and role=\"MENUITEM\""
session.execute_query(request)
menuitems = session.cursor.fetchall()
mnemonic_ids = []
for id in menuitems:
request = "SELECT xmlid FROM eng_US WHERE target=\"%s\" and role=\"MNEMONIC\"" % id
session.execute_query(request)
mnemonic_ids.append(session.cursor.fetchone()[0])
tablelist = []
# look in each table vs eng_US for the mnemonic value and see if it's different
for id in mnemonic_ids:
request = """select eng_US.textstring, %%(table)s.textstring from eng_US,
%%(table)s where eng_US.xmlid="%s" and %%(table)s.xmlid="%s" """ % (id, id)
result = run_sql_on_all_lang_tables(session, request)
# result is a langtable:rows dictionary
# ('hin_IN', ( ('H', 'X'),() ) )
for item in result.items():
table = item[0]
row = item[1][0]
eng = row[0]
other = row[1]
if eng != other and table not in tablelist: tablelist.append(table)
for table in tablelist:
langid = table.replace("_", "-")
request = "SELECT email FROM users WHERE langid=\"%s\" " % langid
session.execute_query(request)
e = session.cursor.fetchone()
if e is not None:
e = e[0]
print "%s, " % e
def main():
usage = """usage: %prog [options] string stringid refid keys
Edits the master language and updates all other languages.
string: the human-readable name for the accelerator shortcut
refid: the id of the string label for the command referenced by the accelerator
keys: the actual keys used to access the accelerator shortcut
e.g.
%prog Escape t123 t345 esc
"""
parser = GlobalOptionsParser(usage=usage)
(options, args) = parser.parse_args()
parser.check_args(4, args)
session = LionDB(options.config, options.trace, options.app)
string, stringid, refid, keys = args
session.add_accelerator_master(string, stringid, refid, keys)
def main():
"""Update the release date and version info for the english table"""
usage = """usage: %prog [options] version_info release_date"""
parser = GlobalOptionsParser(usage=usage)
(options, args) = parser.parse_args()
parser.check_args(2, args)
session = LionDB(options.config, options.trace, "amis")
# t164 = version info
# t165 = release date
session.execute_query(
"""UPDATE eng_US SET textstring="%s" WHERE xmlid="t164" """ % args[0])
session.execute_query(
"""UPDATE eng_US SET textstring="%s" WHERE xmlid="t165" """ % args[1])
print "Successfully updated"
