import datetime

import re

import sre_constants

import warnings

import angles

import dates

import exc

import format

import maps

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

funcs = {}

structural_funcs = set()

##### Public functions

def is_func_name(name):

def process(node, on_error=exc.raise_, rel_funcs=None, db=None):

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

    @param rel_funcs None|set(str...) Relational functions

        * container can be any iterable type

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

    @return The new node

    '''

    has_rel_funcs = rel_funcs != None

    changed = []

    for child in xml_dom.NodeElemIter(node):

        new = process(child, on_error, rel_funcs, db)

    name = node.tagName

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

    items = list(xml_dom.NodeTextEntryIter(node))

    # Parse function

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

    elif column_mode and not name in structural_funcs: # column-based mode

        value = pop_value(items, None)

    else: # local XML function

        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 functions

#### Structural

def _ignore(items, node):

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

funcs['_ignore'] = _ignore

structural_funcs.add('_ignore')

def _ref(items, node):

structural_funcs.add('_ref')

#### Conditionals

def _eq(items, node):

    items = dict(items)

def _if(items, node):

    items = dict(items)

    except KeyError, e: raise SyntaxError(e)

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

    cond = bool(cast(strings.ustr, cond))

    if cond: return then

#### Combining values

def _alt(items, node):

    items = list(items)

    try: return items[0][1] # value of lowest-numbered item

    except IndexError: return None # input got removed by e.g. FormatException

funcs['_alt'] = _alt

def _merge(items, node):

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

        # get *once* from iter, check types

    items.sort()

funcs['_merge'] = _merge

def _label(items, node):

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

        # get *once* from iter, check types

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

    except KeyError, e: raise SyntaxError(e)

    return label+': '+value

funcs['_label'] = _label

#### 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

types_by_name = {None: strings.ustr, 'str': strings.ustr, 'float': float}

def _nullIf(items, node):

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

    try: null = items['null']

    except KeyError, e: raise SyntaxError(e)

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

    type_str = items.get('type', None)

    except KeyError, e: raise SyntaxError(e)

    null = type_(null)

funcs['_nullIf'] = _nullIf

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

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

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

    return value

funcs['_noCV'] = _noCV

#### Dates

def _date(items, node):

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

    try: str_ = items['date']

    except KeyError:

        # Year is required

        except KeyError, e:

            else: raise FormatException(e)

                try: items['month'] = str(dates.strtotime(month).month)

                except ValueError, e: raise FormatException(e)

        items = dict(conv_items(format.str2int, items.iteritems()))

        items.setdefault('month', 1)

                if try_num > 0: raise FormatException(e)

                    # exception still raised after retry

                msg = strings.ustr(e)

                if msg == 'month must be in 1..12': # try swapping month and day

                else: raise FormatException(e)

    else:

        try: year = float(str_)

            try: date = dates.strtotime(str_)

            except ImportError: return str_

            except ValueError, e: raise FormatException(e)

        else: date = (datetime.date(int(year), 1, 1) +

    try: return dates.strftime('%Y-%m-%d', date)

    except ValueError, e: raise FormatException(e)

funcs['_date'] = _date

def _dateRangeStart(items, node):

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

    try: value = items['value']

    except KeyError: return None # input is empty

    return dates.parse_date_range(value)[0]

def _dateRangeEnd(items, node):

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

    try: value = items['value']

    except KeyError: return None # input is empty

    return dates.parse_date_range(value)[1]

#### Names

_name_parts_slices_items = [

def _name(items, node):

    items = dict(items)

    parts = []

    for part in name_parts:

    return ' '.join(parts)

funcs['_name'] = _name

def _namePart(items, node):

    out_items = []

        except KeyError, e: raise SyntaxError(e)

        out_items.append((part, ' '.join(value.split(' ')[slice_])))

    return _name(out_items, node)

funcs['_namePart'] = _namePart

#### Angles

def _compass(items, node):

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

#### Paths

def _simplifyPath(items, node):

    items = dict(items)

        next = cast(strings.ustr, items['next'])

        root = items['path']

    except KeyError, e: raise SyntaxError(e)

        if xpath.get_value(node, require, allow_rooted=False) == None: # empty

            xml_dom.replace(node, new_node) # remove current elem