#!/usr/bin/env python

# Maps one datasource to another, using a map spreadsheet if needed

# http://vegbank.org/vegdocs/xml/vegbank_example_ver1.0.2.xml

import sys

    values = []

        try: value = map_[key_]

        values.append(value)

    if values != []: return values

    else: raise e # re-raise last KeyError

    if val == None: return val

    def usage_err():

        # never redo in commit mode (manually run `make empty_db` instead)

    # Ranges

    start = util.cast(int, opts.get_env_var('start', '0', env_names))

    else: end_default = None

    end = util.cast(int, util.none_if(

        opts.get_env_var('n', end_default, env_names), u''))

    # Debugging

    db_config_names = ['engine', 'host', 'user', 'password', 'database']

    def get_db_config(prefix):

        return opts.get_env_vars(db_config_names, prefix, env_names)

    in_db_config = get_db_config('in')

    out_db_config = get_db_config('out')

    in_is_db = 'engine' in in_db_config

    out_is_db = 'engine' in out_db_config

    ##

        if on: sys.stderr.write(msg)

        if in_is_db or not out_is_db: usage_err()

        else: map_paths = [None]

    else: end_str = 'end'

    log_start('Processing input rows '+str(start)+'-'+end_str)

    profiler = profiling.ItersProfiler(start_now=True, iter_text='row')

    doc = xml_dom.create_doc()

    root = doc.documentElement

    def update_in_label():

        if in_label_ref[0] != None:

            xpath.get(root, '/_ignore/inLabel="'+in_label_ref[0]+'"', True)

    def prep_root():

        root.clear()

        update_in_label()

    prep_root()

        # Load map header

        in_is_xpaths = True

        if map_path != None:

            metadata = []

            mappings = []

            stream = open(map_path, 'rb')

            reader = csv.reader(stream)

            in_label, out_label = reader.next()[:2]

                label, sep2, prefixes_str = label.partition('[')

                prefixes_str = strings.remove_suffix(']', prefixes_str)

                prefixes = strings.split(',', prefixes_str)

                return label, sep != '', root, prefixes

            in_is_xpaths = in_root != None

            update_in_label()

            out_is_xpaths = out_root != None

            if out_is_xpaths: has_types = out_root.startswith('/*s/')

                # outer elements are types

                in_, out = row[:2]

                if out != '':

                    if out_is_xpaths: out = xpath.parse(out_root+out)

                    mappings.append((in_, out))

            root.ownerDocument.documentElement.tagName = out_label

        in_is_xml = in_is_xpaths and not in_is_db

            @param process_row(in_row, i)

                if end != None and i >= end: break

                process_row(row, i)

                row_ready(i, row)

        def map_rows(get_value, rows):

            '''Maps input rows

            @param get_value(in_, row):str

            '''

            def process_row(row, i):

                for in_, out in mappings:

                    value = metadata_value(in_)

                        log_start('Putting '+str(out), debug)

            i = 0

            while i < len(mappings): # mappings len changes in loop

                in_, out = mappings[i]

                if metadata_value(in_) == None:

                        get_with_prefix(col_idxs, prefixes, in_), out)

                    except KeyError:

                        del mappings[i]

                        continue # keep i the same

            def get_value(in_, row):

                return util.ListDict(util.list_as_length(row, col_names_ct),

                    col_names, col_idxs) # handle CSV rows of different lengths

            return map_rows(get_value, util.WrapIter(wrap_row, rows))

            in_pkeys = {}

            cur = sql.select(in_db, table=in_root, fields=None, conds=None,

                limit=end, start=0)

                for in_xml_root in xml_parse.docs_iter(sys.stdin):

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

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

                        iter_)

                def doc_rows(in_xml_root):

                        +in_root+'" not found in input')

                    return rows

                def get_value(in_, row):

                    in_ = './{'+(','.join(strings.with_prefixes(

                        ['']+prefixes, in_)))+'}' # also with no prefix

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

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

                    else: return None

                row_ct = map_rows(get_value, iters.flatten(itertools.imap(

                    doc_rows, xml_parse.docs_iter(sys.stdin))))

        return row_ct

        for map_path in map_paths:

            row_ct += process_input(root, row_ready, map_path)

        return row_ct

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

                    assert xml_dom.has_one_child(root)

                    try:

                            lambda: db_xml.put(out_db, root.firstChild,

                                out_pkeys, row_ins_ct_ref, on_error))

            sys.stdout.write('Inserted '+str(row_ins_ct_ref[0])+

            out_db.close()

            doc.writexml(sys.stdout, **xml_dom.prettyxml_config)

        else: # output is CSV

            raise NotImplementedError('CSV output not supported yet')

    ex_tracker.add_iters(row_ct)

        sys.stderr.write('Processed '+str(row_ct)+' input rows\n')

        sys.stderr.write(profiler.msg()+'\n')

        sys.stderr.write(ex_tracker.msg()+'\n')

    try: main_()

    except Parser.SyntaxException, e: raise SystemExit(str(e))

    if profile_to != None:

        import cProfile

    else: main()