import datetime

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',

class FormatException(exc.ExceptionWithCause):

##### Helper functions

def map_items(func, items):

def merge_tagged(root):

funcs = {}

structural_funcs = set()

##### Public functions

def is_func_name(name):

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

    '''

    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

    func = funcs.get(name, None)

    items = list(xml_dom.NodeTextEntryIter(node))

    # Parse function

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

        try: value = sql_io.put(db, name, dict(items)) # evaluate using DB

    elif (column_mode and not name in structural_funcs) or func == None:

    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()

            str_ = strings.ustr(node)

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

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

            on_error(e)

            return # in case on_error() returns

    xml_dom.replace_with_text(node, value)

##### XML functions

#### Structural

def _ignore(items, node):

    '''Used to "comment out" an XML subtree'''

funcs['_ignore'] = _ignore

structural_funcs.add('_ignore')

def _ref(items, node):

    target = xpath.get_1(node.parentNode, addr)

        warnings.warn(UserWarning('_ref: XPath reference target missing: '

        value = None

    return value

structural_funcs.add('_ref')

#### Conditionals

def _eq(items, node):

    items = dict(items)

    except KeyError: return '' # a value was not mapped to

    return util.bool2str(left == right)

def _if(items, node):

    '''Can add `name` param to distinguish separate _if statements'''

    items = dict(items)

    try: then = items['then']

    except KeyError, e: raise SyntaxError(e)

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

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

    if cond: return then

#### Transforming values

def _collapse(items, node):

    '''Collapses a subtree if the "value" element in it is NULL'''

    if xpath.get_value(value, require, allow_rooted=False) == None: return None

    else: return value

def repl(repls, value):

    '''Raises error if value not in map and no special '*' entry

    @param repls dict repl:with

    '''

    try: new_value = repls[value]

    except KeyError, e:

        # Save traceback right away in case another exception raised

        fe = FormatException(e)

        try: new_value = repls['*']

        except KeyError: raise fe

    if new_value == '*': new_value = value # '*' means keep input value the same

    return new_value

def _map(items, node):

    '''See repl()

    return util.none_if(repl(dict(items), value), u'') # empty value means None

funcs['_map'] = _map

def _replace(items, node):

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

    value = pop_value(items)

    try:

    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):

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

    value = pop_value(items)

    quantity = units.str2quantity(value)

    try:

            elif action == 'to':

                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='-'):

    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]

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]

def _range(items, node):

    items = dict(conv_items(float, items))

def _avg(items, node):

    count = 0

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

        count += 1

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

funcs['_avg'] = _avg

class CvException(Exception):

def _noCV(items, node):

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

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

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

    return value

funcs['_noCV'] = _noCV

#### Names

_name_parts_slices_items = [

def _name(items, node):

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

    parts = []

    for part in name_parts:

    return ' '.join(parts)

funcs['_name'] = _name

#### Angles

def _compass(items, node):

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