#!/usr/bin/env python

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

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

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

import os.path

import sys

    def usage_err():

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

    # Get db config from env vars

    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

    # Get other config from env vars

    end = util.cast(int, opts.get_env_var('n', None, env_names))

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

    if end != None: end += start

    commit = not test and opts.env_flag('commit') # never commit in test mode

    verbose = debug or opts.env_flag('verbose')

        if on: sys.stderr.write(msg)

    def log_done(on=verbose): log('Done\n', on)

        if in_is_db or not out_is_db: usage_err()

        else: map_paths = [None]

        # Load map header

        in_is_xpaths = True

        if map_path != None:

            import copy

            import csv

            import xpath

            metadata = []

            mappings = []

            stream = open(map_path, 'rb')

            reader = csv.reader(stream)

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

            def split_col_name(name):

                name, sep, root = name.partition(':')

                return name, sep != '', root

            in_label, in_is_xpaths, in_root = split_col_name(in_label)

            out_label, out_is_xpaths, out_root = split_col_name(out_label)

            has_types = out_root.startswith('/*s/') # outer elements are types

            for row in reader:

                in_, out = row[:2]

                if out != '':

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

                    mappings.append((in_, out))

            stream.close()

            root.ownerDocument.documentElement.tagName = out_label

        in_is_xml = in_is_xpaths and not in_is_db

            doc0 = minidom.parse(sys.stdin)

            if out_label == None: out_label = doc0.documentElement.tagName

            '''Processes input rows

            @param process_row(in_row, i)

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

                process_row(row, i)

                row_ready(i, row)

            sys.stderr.write('Processed '+str(i-start+1)+' input rows\n')

        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('Getting '+str(in_), debug)

                        value = get_value(in_, row)

                        log_done(debug)

                        has_types, strings.cleanup(value))

            iter_ = xml_dom.NodeElemIter(doc0.documentElement)

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

                in_, out = mapping

                if metadata_value(in_) == None:

                xml_dom.set_id(xpath.get(in_, in_root), pkey)

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

                if value != None: return str(value)

                else: return None

                in_pkeys, end)))

                node = xpath.get(row, in_)

                if node != None: return xml_dom.value(node)

                else: return None

            row0 = xpath.get(doc0.documentElement, in_root)

                in_, out = mapping

                if metadata_value(in_) == None:

                    try: mappings[i] = (col_idxs[in_], out)

                    except KeyError: pass

                value = row[in_]

                if value != '': return value

                else: return None

        for map_path in map_paths: process_input(root, row_ready, map_path)

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

                    assert xml_dom.has_one_child(root)

                    try:

                        sql.with_savepoint(out_db, lambda: db_xml.put(out_db,

            out_db.close()

        process_inputs(root, row_ready)

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

        else: # output is CSV

            raise NotImplementedError('CSV output not supported yet')

    try: main_()

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

    if profile_to != None:

        import cProfile

        cProfile.run(main.func_code, profile_to)

    else: main()