# XML "function" nodes that transform their contents

import datetime

import operator

import os

import re

import sre_constants

import warnings

import angles

import dates

import exc

import format

import maps

import sql

import sql_io

import strings

import term

import units

import util

import xml_dom

import xpath

##### Exceptions

class SyntaxError(exc.ExceptionWithCause):

    def __init__(self, cause):

        exc.ExceptionWithCause.__init__(self, 'Invalid XML function syntax',

            cause)

class FormatException(exc.ExceptionWithCause):

    def __init__(self, cause):

        exc.ExceptionWithCause.__init__(self, 'Invalid input value', cause)

##### Helper functions

def map_names(func, params):

    return [(func(name), value) for name, value in params]

def variadic_args(node):

    args = map_names(float, xml_dom.NodeEntryIter(node))

    args.sort()

    return [value for name, value in args]

def map_items(func, items):

    return [(name, func(value)) for name, value in items]

def cast(type_, val):

    '''Throws FormatException if can't cast'''

    try: return type_(val)

    except ValueError, e: raise FormatException(e)

def conv_items(type_, items):

    return map_items(lambda val: cast(type_, val),

        xml_dom.TextEntryOnlyIter(items))

def pop_value(items, name='value'):

    '''@param name Name of value param, or None to accept any name'''

    try: last = items.pop() # last entry contains value

    except IndexError: return None # input is empty and no actions

    if name != None and last[0] != name: return None # input is empty

    return last[1]

def merge_tagged(root):

    '''Merges siblings in root that are marked as mergeable.

    Used to recombine pieces of nodes that were split apart in the mappings.

    '''

    for name in set((c.tagName for c in xpath.get(root, '*[@merge=1]'))):

        xml_dom.merge_by_name(root, name)

    # Recurse

    for child in xml_dom.NodeElemIter(root): merge_tagged(child)

funcs = {}

simplifying_funcs = {}

##### Public functions

var_name_prefix = '$'

def is_var_name(str_): return str_.startswith(var_name_prefix)

def is_var(node):

    return xml_dom.is_text_node(node) and is_var_name(xml_dom.value(node))

def is_func_name(name):

    return name.startswith('_') and name != '_' # '_' is default root node name

def is_func(node): return is_func_name(node.tagName)

def is_xml_func_name(name): return is_func_name(name) and name in funcs

def is_xml_func(node): return is_xml_func_name(node.tagName)

def passthru(node):

    '''Passes through single child node. First prunes the node.'''

    xml_dom.prune(node)

    children = list(xml_dom.NodeEntryIter(node))

    if len(children) == 1: xml_dom.replace(node, children[0][1])

def simplify(node):

    '''Simplifies an XML tree.

    * Merges nodes tagged as mergable

    * Runs simplifying functions

    '''

    for child in xml_dom.NodeElemIter(node): simplify(child)

    merge_tagged(node)

    name = node.tagName

    # Pass-through optimizations

    if is_func_name(name):

        try: func = simplifying_funcs[name]

        except KeyError: xml_dom.prune_empty(node)

        else: func(node)

    # Pruning optimizations

    else: # these should not run on functions because they would remove args

        xml_dom.prune_children(node)

def process(node, on_error=exc.reraise, is_rel_func=None, db=None):

    '''Evaluates the XML functions in an XML tree.

    @param is_rel_func None|f(str) Tests if a name is a relational function.

        * If != None: Non-relational functions are removed, or relational

          functions are treated specially, depending on the db param (below).

    @param db

        * If None: Non-relational functions other than structural functions are

          replaced with their last parameter (usually the value), not evaluated.

          This is used in column-based mode to remove XML-only functions.

        * If != None: Relational functions are evaluated directly. This is used

          in row-based mode to combine relational and XML functions.

    '''

    has_rel_funcs = is_rel_func != None

    assert db == None or has_rel_funcs # rel_funcs required if db set

    for child in xml_dom.NodeElemIter(node):

        process(child, on_error, is_rel_func, db)

    merge_tagged(node)

    name = node.tagName

    if not is_func_name(name): return node # not any kind of function

    row_mode = has_rel_funcs and db != None

    column_mode = has_rel_funcs and db == None

    func = funcs.get(name, None)

    items = list(xml_dom.NodeTextEntryIter(node))

    # Parse function

    if len(items) == 1 and items[0][0].isdigit(): # has single numeric param

        # pass-through optimization for aggregating functions with one arg

        value = items[0][1] # pass through first arg

    elif row_mode and (is_rel_func(name) or func == None): # row-based mode

        if reduce(operator.or_, (xml_dom.is_node(v) for n, v in items)):

            return # preserve complex funcs

        # Evaluate using DB

        try: value = sql_io.put(db, name, dict(items), on_error=on_error)

        except sql.DoesNotExistException: return # preserve unknown funcs

            # possibly a built-in function of db_xml.put()

    elif column_mode or func == None:

        # local XML function can't be used or does not exist

        if column_mode and is_rel_func(name): return # preserve relational funcs

        # otherwise XML-only in column mode, or DB-only in XML output mode

        value = pop_value(items, None) # just replace with last param

    else: # local XML function

        try: value = func(items, node)

        except Exception, e: # also catch non-wrapped exceptions (XML func bugs)

            # Save in case another exception raised, overwriting sys.exc_info()

            exc.add_traceback(e)

            str_ = strings.ustr(node)

            exc.add_msg(e, 'function:\n'+str_)

            xml_dom.replace(node, xml_dom.mk_comment(node.ownerDocument,

                '\n'+term.emph_multiline(str_)))

            on_error(e)

            return # in case on_error() returns

    xml_dom.replace_with_text(node, value)

##### Simplifying functions

# Function names must start with _ to avoid collisions with real tags

# Functions take params (node) and have no return value

#### Logic

simplifying_funcs['_and'] = passthru

simplifying_funcs['_or'] = passthru

def _exists(node):

    '''Returns whether its node is non-empty'''

    xml_dom.replace_with_text(node, not xml_dom.is_empty(node))

simplifying_funcs['_exists'] = _exists

def _if(node):

    '''

    *Must* be run to remove conditions that functions._if() can't handle.

    Note: Can add `@name` attr to distinguish separate _if statements.

    '''

    params = dict(xml_dom.NodeEntryIter(node))

    then = params.get('then', None)

    cond = params.get('cond', None)

    else_ = params.get('else', None)

    if cond == None: xml_dom.replace(node, else_) # always False

    elif then == else_: xml_dom.replace(node, then) # always same value

    elif is_var(cond): pass # can't simplify variable conditions

    elif xml_dom.is_text_node(cond) and bool(xml_dom.value(cond)): # always True

        xml_dom.replace(node, then)

simplifying_funcs['_if'] = _if

def _nullIf(node):

    '''

    *Must* be run to remove conditions that functions._nullIf() can't handle.

    '''

    params = dict(xml_dom.NodeEntryIter(node))

    null = params.get('null', None)

    value = params.get('value', None)

    if value == None: xml_dom.prune_parent(node) # empty

    elif null == None: xml_dom.replace(node, value) # nothing to null out

simplifying_funcs['_nullIf'] = _nullIf

#### Merging

simplifying_funcs['_alt'] = passthru

simplifying_funcs['_join'] = passthru

simplifying_funcs['_join_words'] = passthru

simplifying_funcs['_merge'] = passthru

simplifying_funcs['_min'] = passthru

simplifying_funcs['_max'] = passthru

def _first(node):

    '''Chooses the first param (after sorting by numeric param name)'''

    args = variadic_args(node)

    try: first = args[0]

    except IndexError: first = None

    xml_dom.replace(node, first)

simplifying_funcs['_first'] = _first

#### Environment access

def _env(node):

    params = dict(xml_dom.NodeTextEntryIter(node))

    try: name = params['name']

    except KeyError, e: raise SyntaxError(e)

    xml_dom.replace_with_text(node, os.environ[name])

simplifying_funcs['_env'] = _env

##### XML functions

# Function names must start with _ to avoid collisions with real tags

# Functions take arguments (items, node)

#### Transforming values

def _replace(items, node):

    items = conv_items(strings.ustr, items) # get *once* from iter, check types

    value = pop_value(items)

    if value == None: return None # input is empty

    try:

        for repl, with_ in items:

            if re.match(r'^\w+$', repl):

                repl = r'(?<![^\W_])'+repl+r'(?![^\W_])' # match whole word

            value = re.sub(repl, with_, value)

    except sre_constants.error, e: raise SyntaxError(e)

    return util.none_if(value.strip(), u'') # empty strings always mean None

funcs['_replace'] = _replace

#### Quantities

def _units(items, node):

    value = pop_value(items)

    if value == None: return None # input is empty

    quantity = units.str2quantity(value)

    try:

        for action, units_ in items:

            units_ = util.none_if(units_, u'')

            if action == 'default': units.set_default_units(quantity, units_)

            elif action == 'to':

                try: quantity = units.convert(quantity, units_)

                except ValueError, e: raise FormatException(e)

            else: raise SyntaxError(ValueError('Invalid action: '+action))

    except units.MissingUnitsException, e: raise FormatException(e)

    return units.quantity2str(quantity)

funcs['_units'] = _units

def parse_range(str_, range_sep='-'):

    default = (str_, None)

    start, sep, end = str_.partition(range_sep)

    if sep == '': return default # not a range

    if start == '' and range_sep == '-': return default # negative number

    return tuple(d.strip() for d in (start, end))

def _rangeStart(items, node):

    items = dict(conv_items(strings.ustr, items))

    try: value = items['value']

    except KeyError: return None # input is empty

    return parse_range(value)[0]

funcs['_rangeStart'] = _rangeStart

def _rangeEnd(items, node):

    items = dict(conv_items(strings.ustr, items))

    try: value = items['value']

    except KeyError: return None # input is empty

    return parse_range(value)[1]

funcs['_rangeEnd'] = _rangeEnd

def _range(items, node):

    items = dict(conv_items(float, items))

    from_ = items.get('from', None)

    to = items.get('to', None)

    if from_ == None or to == None: return None

    return str(to - from_)

funcs['_range'] = _range

def _avg(items, node):

    count = 0

    sum_ = 0.

    for name, value in conv_items(float, items):

        count += 1

        sum_ += value

    if count == 0: return None # input is empty

    else: return str(sum_/count)

funcs['_avg'] = _avg

class CvException(Exception):

    def __init__(self):

        Exception.__init__(self, 'CV (coefficient of variation) values are only'

            ' allowed for ratio scale data '

            '(see <http://en.wikipedia.org/wiki/Coefficient_of_variation>)')

def _noCV(items, node):

    items = list(conv_items(strings.ustr, items))

    try: name, value = items.pop() # last entry contains value

    except IndexError: return None # input is empty

    if re.match('^(?i)CV *\d+$', value): raise FormatException(CvException())

    return value

funcs['_noCV'] = _noCV

#### Angles

def _compass(items, node):

    '''Converts a compass direction (N, NE, NNE, etc.) into a degree heading'''

    items = dict(conv_items(strings.ustr, items))

    try: value = items['value']

    except KeyError: return None # input is empty

    if not value.isupper(): return value # pass through other coordinate formats

    try: return util.cast(str, angles.compass2heading(value)) # ignore None

    except KeyError, e: raise FormatException(e)

funcs['_compass'] = _compass