# -*- coding: latin-1 -*-

""" Date/Time string parsing module.

    Note about the Y2K problems:

       The parser can only handle years with at least 2 digits. 2

       digit year values get expanded by adding the century using

       DateTime.add_century(), while 3 digit year get converted

       literally. To have 2 digit years also be interpreted literally,

       add leading zeros, e.g. year 99 must be written as 099 or 0099.

    Copyright (c) 1998-2000, Marc-Andre Lemburg; mailto:mal@lemburg.com

    Copyright (c) 2000-2007, eGenix.com Software GmbH; mailto:info@egenix.com

    See the documentation for further information on copyrights,

    or contact the author. All Rights Reserved.

"""

import types,re,string

import DateTime,ISO,ARPA,Timezone

# Enable to produce debugging output

_debug = 0

# REs for matching date and time parts in a string; These REs

# parse a superset of ARPA, ISO, American and European style dates.

# Timezones are supported via the Timezone submodule.

_year = '(?P<year>-?\d+\d(?!:))'

_fullyear = '(?P<year>-?\d+\d\d(?!:))'

_year_epoch = '(?:' + _year + '(?P<epoch> *[ABCDE\.]+)?)'

_fullyear_epoch = '(?:' + _fullyear + '(?P<epoch> *[ABCDE\.]+)?)'

_relyear = '(?:\((?P<relyear>[-+]?\d+)\))'

_month = '(?P<month>\d?\d(?!:))'

_fullmonth = '(?P<month>\d\d(?!:))'

_litmonth = ('(?P<litmonth>'

             'jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec|'

             'm�r|mae|mrz|mai|okt|dez|'

             'fev|avr|juin|juil|aou|ao�|d�c|'

             'ene|abr|ago|dic|'

             'out'

             ')[a-z,\.;]*')

litmonthtable = {

    # English

    'jan':1, 'feb':2, 'mar':3, 'apr':4, 'may':5, 'jun':6,

    'jul':7, 'aug':8, 'sep':9, 'oct':10, 'nov':11, 'dec':12,

    # German

    'm�r':3, 'mae':3, 'mrz':3, 'mai':5, 'okt':10, 'dez':12,

    # French

    'fev':2, 'avr':4, 'juin':6, 'juil':7, 'aou':8, 'ao�':8,

    'd�c':12,

    # Spanish

    'ene':1, 'abr':4, 'ago':8, 'dic':12,

    # Portuguese

    'out':10,

    }

_relmonth = '(?:\((?P<relmonth>[-+]?\d+)\))'

_day = '(?P<day>\d?\d(?!:))'

_usday = '(?P<day>\d?\d(?!:))(?:st|nd|rd|th|[,\.;])?'

_fullday = '(?P<day>\d\d(?!:))'

_litday = ('(?P<litday>'

           'mon|tue|wed|thu|fri|sat|sun|'

           'die|mit|don|fre|sam|son|'

           'lun|mar|mer|jeu|ven|sam|dim|'

           'mie|jue|vie|sab|dom|'

           'pri|seg|ter|cua|qui'

           ')[a-z]*')

litdaytable = {

    # English

    'mon':0, 'tue':1, 'wed':2, 'thu':3, 'fri':4, 'sat':5, 'sun':6,

    # German

    'die':1, 'mit':2, 'don':3, 'fre':4, 'sam':5, 'son':6,

    # French

    'lun':0, 'mar':1, 'mer':2, 'jeu':3, 'ven':4, 'sam':5, 'dim':6,

    # Spanish

    'mie':2, 'jue':3, 'vie':4, 'sab':5, 'dom':6,

    # Portuguese

    'pri':0, 'seg':1, 'ter':2, 'cua':3, 'qui':4,

    }

_relday = '(?:\((?P<relday>[-+]?\d+)\))'

_hour = '(?P<hour>[012]?\d)'

_minute = '(?P<minute>[0-6]\d)'

_second = '(?P<second>[0-6]\d(?:[.,]\d+)?)'

_days = '(?P<days>\d*\d(?:[.,]\d+)?)'

_hours = '(?P<hours>\d*\d(?:[.,]\d+)?)'

_minutes = '(?P<minutes>\d*\d(?:[.,]\d+)?)'

_seconds = '(?P<seconds>\d*\d(?:[.,]\d+)?)'

_reldays = '(?:\((?P<reldays>[-+]?\d+(?:[.,]\d+)?)\))'

_relhours = '(?:\((?P<relhours>[-+]?\d+(?:[.,]\d+)?)\))'

_relminutes = '(?:\((?P<relminutes>[-+]?\d+(?:[.,]\d+)?)\))'

_relseconds = '(?:\((?P<relseconds>[-+]?\d+(?:[.,]\d+)?)\))'

_sign = '(?:(?P<sign>[-+]) *)'

_week = 'W(?P<week>\d?\d)'

_zone = Timezone.zone

_ampm = '(?P<ampm>[ap][m.]+)'

_time = (_hour + ':' + _minute + '(?::' + _second + '|[^:]|$) *'

         + _ampm + '? *' + _zone + '?')

_isotime = _hour + ':?' + _minute + ':?' + _second + '? *' + _zone + '?'

_weekdate = _year + '-?(?:' + _week + '-?' + _day + '?)?'

_eurodate = _day + '\.' + _month + '\.' + _year_epoch + '?'

_usdate = _month + '/' + _day + '(?:/' + _year_epoch + '|[^/]|$)'

_altusdate = _month + '-' + _day + '-' + _fullyear_epoch

_isodate = _year + '-' + _month + '-?' + _day + '?(?!:)'

_altisodate = _year + _fullmonth + _fullday + '(?!:)'

_usisodate = _fullyear + '/' + _fullmonth + '/' + _fullday

_litdate = ('(?:'+ _litday + ',? )? *' + 

            _usday + ' *' + 

            '[- ] *(?:' + _litmonth + '|'+ _month +') *[- ] *' +

            _year_epoch + '?')

_altlitdate = ('(?:'+ _litday + ',? )? *' + 

               _litmonth + '[ ,.a-z]+' +

               _usday + 

               '(?:[ a-z]+' + _year_epoch + ')?')

_eurlitdate = ('(?:'+ _litday + ',?[ a-z]+)? *' + 

               '(?:'+ _usday + '[ a-z]+)? *' +

               _litmonth + 

               '(?:[ ,.a-z]+' + _year_epoch + ')?')

_relany = '[*%?a-zA-Z]+'

_relisodate = ('(?:(?:' + _relany + '|' + _year + '|' + _relyear + ')-' +

               '(?:' + _relany + '|' + _month + '|' + _relmonth + ')-' +

               '(?:' + _relany + '|' + _day + '|' + _relday + '))')

_asctime = ('(?:'+ _litday + ',? )? *' + 

                _usday + ' *' + 

                '[- ] *(?:' + _litmonth + '|'+ _month +') *[- ]' +

                '(?:[0-9: ]+)' + 

                _year_epoch + '?')

_relisotime = ('(?:(?:' + _relany + '|' + _hour + '|' + _relhours + '):' +

               '(?:' + _relany + '|' + _minute + '|' + _relminutes + ')' +

               '(?::(?:' + _relany + '|' + _second + '|' + _relseconds + '))?)')

_isodelta1 = (_sign + '?' +

              _days + ':' + _hours + ':' + _minutes + ':' + _seconds)

_isodelta2 = (_sign + '?' + 

              _hours + ':' + _minutes + ':' + _seconds)

_isodelta3 = (_sign + '?' + 

              _hours + ':' + _minutes)

_litdelta = (_sign + '?' +

             '(?:' + _days + ' *d[a-z]*[,; ]*)?' + 

             '(?:' + _hours + ' *h[a-z]*[,; ]*)?' + 

             '(?:' + _minutes + ' *m[a-z]*[,; ]*)?' +

             '(?:' + _seconds + ' *s[a-z]*[,; ]*)?')

_litdelta2 = (_sign + '?' +

             '(?:' + _days + ' *d[a-z]*[,; ]*)?' + 

              _hours + ':' + _minutes + '(?::' + _seconds + ')?')

_timeRE = re.compile(_time, re.I)

_isotimeRE = re.compile(_isotime, re.I)

_isodateRE = re.compile(_isodate, re.I)

_altisodateRE = re.compile(_altisodate, re.I)

_usisodateRE = re.compile(_usisodate, re.I)

_eurodateRE = re.compile(_eurodate, re.I)

_usdateRE = re.compile(_usdate, re.I)

_altusdateRE = re.compile(_altusdate, re.I)

_litdateRE = re.compile(_litdate, re.I)

_altlitdateRE = re.compile(_altlitdate, re.I)

_eurlitdateRE = re.compile(_eurlitdate, re.I)

_relisodateRE = re.compile(_relisodate, re.I)

_asctimeRE = re.compile(_asctime, re.I)

_isodelta1RE = re.compile(_isodelta1)

_isodelta2RE = re.compile(_isodelta2)

_isodelta3RE = re.compile(_isodelta3)

_litdeltaRE = re.compile(_litdelta)

_litdelta2RE = re.compile(_litdelta2)

_relisotimeRE = re.compile(_relisotime, re.I)

# Available date parsers

_date_formats = ('euro',

                 'usiso', 'us', 'altus',

                 'iso', 'altiso', 

                 'lit', 'altlit', 'eurlit',

                 'unknown')

# Available time parsers

_time_formats = ('standard',

                 'iso',

                 'unknown')

def _parse_date(text, formats=_date_formats, defaultdate=None,

                int=int,float=float,lower=string.lower,

                add_century=DateTime.add_century,

                now=DateTime.now,us_formats=('us', 'altus'),

                iso_formats=('iso', 'altiso', 'usiso')):

    """ Parses the date part given in text and returns a tuple

        (text,day,month,year,style) with the following

        meanings:

        * text gives the original text without the date part

        * day,month,year give the parsed date

        * style gives information about which parser was successful:

          'euro' - the European date parser

          'us' - the US date parser

          'altus' - the alternative US date parser (with '-' instead of '/')

          'iso' - the ISO date parser

          'altiso' - the alternative ISO date parser (without '-')

          'usiso' - US style ISO date parser (yyyy/mm/dd)

          'lit' - the US literal date parser

          'altlit' - the alternative US literal date parser

          'eurlit' - the Eurpean literal date parser

          'unknown' - no date part was found, defaultdate was used

        formats may be set to a tuple of style strings specifying

        which of the above parsers to use and in which order to try

        them. Default is to try all of them in the above order.

        defaultdate provides the defaults to use in case no date part

        is found. Most other parsers default to the current year

        January 1 if some of these date parts are missing.

        If 'unknown' is not given in formats and the date cannot be

        parsed, a ValueError is raised.

    """

    match = None

    style = ''

    # Apply parsers in the order given in formats

    for format in formats:

        if format == 'euro':

            # European style date

            match = _eurodateRE.search(text)

            if match is not None:

                day,month,year,epoch = match.groups()

                if year:

                    if len(year) == 2:

                        # Y2K problem:

                        year = add_century(int(year))

                    else:

                        year = int(year)

                else:

                    if defaultdate is None:

                        defaultdate = now()

                    year = defaultdate.year

                if epoch and 'B' in epoch:

                    year = -year + 1

                month = int(month)

                day = int(day)

                # Could have mistaken euro format for us style date

                # which uses month, day order

                if month > 12 or month == 0:

                    match = None

                    continue

                break

        elif format in iso_formats:

            # ISO style date

            if format == 'iso':

                match = _isodateRE.search(text)

            elif format == 'altiso':

                match = _altisodateRE.search(text)

                # Avoid mistaking ISO time parts ('Thhmmss') for dates

                if match is not None:

                    left, right = match.span()

                    if left > 0 and \

                       text[left - 1:left] == 'T':

                        match = None

                        continue

            else:

                match = _usisodateRE.search(text)

            if match is not None:

                year,month,day = match.groups()

                if len(year) == 2:

                    # Y2K problem:

                    year = add_century(int(year))

                else:

                    year = int(year)

                # Default to January 1st

                if not month:

                    month = 1

                else:

                    month = int(month)

                if not day:

                    day = 1

                else:

                    day = int(day)

                break

        elif format in us_formats:

            # US style date

            if format == 'us':

                match = _usdateRE.search(text)

            else:

                match = _altusdateRE.search(text)

            if match is not None:

                month,day,year,epoch = match.groups()

                if year:

                    if len(year) == 2:

                        # Y2K problem:

                        year = add_century(int(year))

                    else:

                        year = int(year)

                else:

                    if defaultdate is None:

                        defaultdate = now()

                    year = defaultdate.year

                if epoch and 'B' in epoch:

                    year = -year + 1

                # Default to 1 if no day is given

                if day:

                    day = int(day)

                else:

                    day = 1

                month = int(month)

                # Could have mistaken us format for euro style date

                # which uses day, month order

                if month > 12 or month == 0:

                    match = None

                    continue

                break

        elif format == 'lit':

            # US style literal date

            match = _litdateRE.search(text)

            if match is not None:

                litday,day,litmonth,month,year,epoch = match.groups()

                break

        elif format == 'altlit':

            # Alternative US style literal date

            match = _altlitdateRE.search(text)

            if match is not None: 

                litday,litmonth,day,year,epoch = match.groups()

                month = '<missing>'

                break

        elif format == 'eurlit':

            # European style literal date

            match = _eurlitdateRE.search(text)

            if match is not None: 

                litday,day,litmonth,year,epoch = match.groups()

                month = '<missing>'

                break

        elif format == 'unknown':

            # No date part: use defaultdate

            if defaultdate is None:

                defaultdate = now()

            year = defaultdate.year

            month = defaultdate.month

            day = defaultdate.day

            style = format

            break

    # Check success

    if match is not None:

        # Remove date from text

        left, right = match.span()

        if 0 and _debug:

            print 'parsed date:',repr(text[left:right]),\

                  'giving:',year,month,day

        text = text[:left] + text[right:]

        style = format

    elif not style:

        # Not recognized: raise an error

        raise ValueError, 'unknown date format: "%s"' % text

    # Literal date post-processing

    if style in ('lit', 'altlit', 'eurlit'):

        if 0 and _debug: print match.groups()

        # Default to current year, January 1st

        if not year:

            if defaultdate is None:

                defaultdate = now()

            year = defaultdate.year

        else:

            if len(year) == 2:

                # Y2K problem:

                year = add_century(int(year))

            else:

                year = int(year)

        if epoch and 'B' in epoch:

            year = -year + 1

        if litmonth:

            litmonth = lower(litmonth)

            try:

                month = litmonthtable[litmonth]

            except KeyError:

                raise ValueError,\

                      'wrong month name: "%s"' % litmonth

        elif month:

            month = int(month)

        else:

            month = 1

        if day:

            day = int(day)