# Exit status is the # of errors in the import, up to the maximum exit status

# For outputting an XML file to a PostgreSQL database, use the general format of

import csv

import os.path

import xml.dom.minidom as minidom

sys.path.append(os.path.dirname(__file__)+"/../lib")

import exc

import opts

import Parser

import profiling

import sql

import strings

import term

import util

import xpath

import xml_dom

import xml_func

def metadata_value(name):

    if util.is_str(name) and name.startswith(':'): return name[1:]

    else: return None

def main_():

    env_names = []

        raise SystemExit('Usage: '+opts.env_usage(env_names, True)+' '

            +sys.argv[0]+' [map_path...] [<input] [>output]')

    test = opts.env_flag('test', False, env_names)

    commit = opts.env_flag('commit', False, env_names) and not test

        # never commit in test mode

    redo = opts.env_flag('redo', test, env_names) and not commit

    debug = opts.env_flag('debug', False, env_names)

    sql.run_raw_query.debug = debug

    verbose = debug or opts.env_flag('verbose', False, env_names)

    opts.get_env_var('profile_to', None, env_names) # add to env_names

    # Logging

    def log(msg, on=verbose):

    def log_start(action, on=verbose): log(action+'...\n', on)

    # Parse args

    map_paths = sys.argv[1:]

    if map_paths == []:

    def connect_db(db_config):

        log_start('Connecting to '+sql.db_config_str(db_config))

        return sql.connect(db_config)

    ex_tracker = exc.ExPercentTracker(iter_text='row')

    out_is_xml_ref = [False]

    in_label_ref = [None]

    def process_input(root, row_ready, map_path):

        '''Inputs datasource to XML tree, mapping if needed'''

        out_is_xpaths = True

        out_label = None

            in_label_ref[0] = in_label

            out_label, out_is_xpaths, out_root = split_col_name(out_label)

        out_is_xml_ref[0] = out_is_xpaths and not out_is_db

        if in_is_xml:

            doc0_root = doc0.documentElement

        def process_rows(process_row, rows):

            '''

            i = -1 # in case for loop does not execute

            for i, row in enumerate(rows):

                if i < start: continue

            row_ct = i-start+1

            return row_ct

                row_id = str(i)

                    if value == None:

                        log_start('Getting '+str(in_), debug)

                        value = get_value(in_, row)

                    if value != None: xpath.put_obj(root, out, row_id,

            return process_rows(process_row, rows)

        if map_path == None:

            iter_ = xml_dom.NodeElemIter(doc0_root)

            util.skip(iter_, xml_dom.is_text) # skip metadata

            row_ct = process_rows(lambda row, i: root.appendChild(row), iter_)

        elif in_is_db:

            assert in_is_xpaths

            import db_xml

            in_root_xml = xpath.path2xml(in_root)

            for i, mapping in enumerate(mappings):

                    mappings[i] = (xpath.path2xml(in_root+'/'+in_), out)

            in_db = connect_db(in_db_config)

            in_pkeys = {}

            def get_value(in_, row):

                pkey, = row

                in_ = in_.cloneNode(True) # don't modify orig value!

                xml_dom.set_id(xpath.get(in_, in_root)[0], pkey)

                value = sql.value_or_none(db_xml.get(in_db, in_, in_pkeys))

            row_ct = map_rows(get_value, sql.rows(db_xml.get(in_db, in_root_xml,

                in_pkeys, end, 0)))

            in_db.close()

        elif in_is_xml:

            def get_value(in_, row):

                nodes = xpath.get(row, in_, allow_rooted=False)

                if nodes != []: return xml_dom.value(nodes[0])

                else: return None

            rows = xpath.get(doc0_root, in_root, limit=end)

            if rows == []: raise SystemExit('Map error: Root "'+in_root

                +'" not found in input')

            row_ct = map_rows(get_value, rows)

        else: # input is CSV

            map_ = dict(mappings)

            reader = csv.reader(sys.stdin)

            cols = reader.next()

            col_idxs = dict([(value, idx) for idx, value in enumerate(cols)])

            for i, mapping in enumerate(mappings):

            def get_value(in_, row):

            row_ct = map_rows(get_value, reader)

    def process_inputs(root, row_ready):

        row_ct = 0

    if out_is_db:

        import db_xml

        out_db = connect_db(out_db_config)

        out_pkeys = {}

        try:

            if redo: sql.empty_db(out_db)

            row_ins_ct_ref = [0]

            def row_ready(row_num, input_row):

                def on_error(e):

                    exc.add_msg(e, term.emph('row #:')+' '+str(row_num))

                    exc.add_msg(e, term.emph('input row:')+'\n'+str(input_row))

                    ex_tracker.track(e)

                xml_func.process(root, on_error)

                if not xml_dom.is_empty(root):

                        sql.with_savepoint(out_db,

                        if commit: out_db.commit()

                    except sql.DatabaseErrors, e: on_error(e)

                prep_root()

            row_ct = process_inputs(root, row_ready)

                ' new rows into database\n')

        finally:

            out_db.rollback()

    else:

        def on_error(e): ex_tracker.track(e)

        def row_ready(row_num, input_row): pass

        row_ct = process_inputs(root, row_ready)

        xml_func.process(root, on_error)

        if out_is_xml_ref[0]:

    profiler.stop(row_ct)

    if verbose:

    ex_tracker.exit()

def main():

if __name__ == '__main__':

    profile_to = opts.get_env_var('profile_to', None)