3
=y] ! @ s d Z ddlmZmZmZ ddlZddlZddlZddlZddl Z ddl
Z
ddl Z ddl Z
ddlmZmZmZ ddlmZmZ ddlmZ dZd Zd
Zd Zd Z d
Z dZ dZ yddlm Z W n& e!k
r G dd dej"Z Y nX ej#e$Z%e%j&e dZ'e(dd eD Z)dd Z*dd Z+dd Z,d d Z-e- Z.[-e/d d d d!d"d#d$d%d&d'd(d)d*d+d,d-d"d.d/d0d1d2d3d4gZ0e/d5d6d7d8d9d:d;gZ1dZ4G d?d@ d@e5Z6dAdB Z7G dCdD dDe5Z8dS )EzRparsedatetime
Parse human-readable date/time text.
Requires Python 2.7 or later
)with_statementabsolute_importunicode_literalsN )localesget_icu load_locale)
pdtContextpdtContextStack)pdt20DeprecationWarningz Mike Taylorz bear@bear.imz Copyright (c) 2017 Mike TaylorzApache License 2.0z2.5z%https://github.com/bear/parsedatetimez*https://pypi.python.org/pypi/parsedatetimez$Parse human-readable date/time text.) NullHandlerc @ s e Zd Zdd ZdS )r c C s d S )N )selfrecordr
r
/usr/lib/python3.6/__init__.pyemit= s zNullHandler.emitN)__name__
__module__ __qualname__r r
r
r
r r ; s r Fc C s g | ]}|t |fqS r
)r ).0xr
r
r
E s r c
C sd t | jd}|dk r6dt tj d d t | }|dk rBd
S | jd}|rt |}|d d }|d d }d }x||kr
tj|||ddddddf }tj|d }t|| }||kr||k r|| }n |d }d }qx||k rx|| d
k r || }qx|d }qxW |||fS | jd }d}|d kr4d}n&t |}| jd }|rVt |}nd}|||fS )Nyeard r i julian r monthday)r r r )intgrouptimeZgmtimemktimeabs)mr r r r Zjdaytdiffr
r
r
_extract_dateL sF
r* c C sn | sdS | j d}|sd S t|}t| j d}| j d}|r`|jddjddd }t|}nd}|||fS )
Nr hoursminutesseconds,.r )r r r )r r r )r# r" replacesplit)r' r+ r, r- r
r
r
_extract_timez s
r2 c C sN | sd S | j dr |j|j | j dr4|j|j | j drJ|j|j d S )Nr+ r, r- )r# updateAccuracyACU_HOURACU_MINACU_SEC)r' ctxr
r
r _pop_time_accuracy s
r8 c s> dd } fdd}d}d}d| }d||f }t j| |S ) Nc S sv | sdS | j d}|sdS |dkr&dS t| j d}| j d}|rLt|}nd}|d | d }|d dkrr| S |S )zAReturn the Time Zone Designator as an offset in seconds from UTC.r tzdZZtzdhoursZ
tzdminutes< +)r# r" )r' r9 r+ r, offsetr
r
r
__extract_tzd s
z1__closure_parse_date_w3dtf..__extract_tzdc s6 j | }|d ks |j | kr"d S t|t| d S )Nr )r r r )matchr# r* r2 )
dateStringr' )
__datetime_rxr
r _parse_date_w3dtf s
z5__closure_parse_date_w3dtf.._parse_date_w3dtfzd(?P\d\d\d\d)(?:(?P-|)(?:(?P\d\d\d)|(?P\d\d)(?:(?P=dsep)(?P\d\d))?))?z;(?P[-+](?P\d\d)(?::?(?P\d\d))|Z)zW(?P\d\d)(?P:|)(?P\d\d)(?:(?P=tsep)(?P\d\d(?:[.,]\d+)?))?z
%s(?:T%s)?)recompile)r> rB Z __date_reZ__tzd_reZ __time_reZ
__datetime_rer
)rA r __closure_parse_date_w3dtf s
rE ZjanZfebZmarZaprZmayZjunZjulZaugsepoctZnovZdecZjanuaryZfebruaryZmarchZaprilZjuneZjulyZaugustZ septemberZoctoberZnovemberZdecemberZmonZtueZwedZthuZfriZsatZsunc C s | j }|d d dks(|d j tkr.|d= t|dkr||d }|j dd}t|dkrh||dd < n
|jd
d j|} t|d k r| d
7 } tjj| S )z8Parse an RFC822, RFC1123, RFC2822, or asctime-style dater r r. r/ r< r N z
00:00:00 GMT)r. r/ ) r1 lower _daynameslenappendjoinemailZutilsZ parsedate_tz)r@ datasr
r
r _parse_date_rfc822 s
rV r c @ sN e Zd ZdZdefddZejdd Ze dd Z
d d
Z d d Z dKd
dZ
dLddZdMddZdd Zdd Zdd Zdd Zdd Zd d Zd d Zd!d" Zd#d$ Zd%d& Zd'd( Zd)d* Zd+d, Z d-d. Z d/d0 Z d1d2 Z d3d4 Z d5d6 Z!d7d8 Z"d9d: Z#d;d< Z$d=d> Z%d?d@ Z&dAdB Z'dNdCdDZ(dOdEdFZ)dPdGdHZ*dQdIdJZ+dS )RCalendarz
A collection of routines to input, parse and manipulate date and times.
The text can either be 'normal' date values or it can be human readable.
Nc C s> |dkrt | _n|| _|| _|tkr2tjdt t | _dS )a
Default constructor for the L{Calendar} class.
@type constants: object
@param constants: Instance of the class L{Constants}
@type version: integer
@param version: Default style version of current Calendar instance.
Valid value can be 1 (L{VERSION_FLAG_STYLE}) or
2 (L{VERSION_CONTEXT_STYLE}). See L{parse()}.
@rtype: object
@return: L{Calendar} instance
NzFlag style will be deprecated in parsedatetime 2.0. Instead use the context style by instantiating `Calendar()` with argument `version=parsedatetime.VERSION_CONTEXT_STYLE`.) ConstantsptcversionVERSION_FLAG_STYLEwarningswarnr r
_ctxStack)r Z constantsrZ r
r
r __init__ s
zCalendar.__init__c c s< t }| jj| |V | jj }| jj s8| jj| d S )N)r r^ pushpopZisEmptycurrentContextupdate)r r7 r
r
r context s
zCalendar.contextc C s
| j j S )N)r^ last)r r
r
r rb $ s zCalendar.currentContextc C s t jd|dd }}}x|D ]x}| jjj|}|dk rB||7 }q |dkrT|d9 }q | jjj|}|dk r|||| 7 }d}q || jjkrq td| q W || S )z
Converts text units into their number value.
@type unitText: string
@param unitText: number text to convert
@rtype: integer
@return: numerical value of unitText
z[,\s-]+r NZhundredr zUnknown number: )rC r1 rY ZsmallgetZ magnitudeignore Exception)r ZunitTextZ word_listabZwordr r
r
r _convertUnitAsWords( s
z Calendar._convertUnitAsWordsc C s^ | j }totjd||| |dkr*tj }|dkr8d}n|j }| j|}|| jjkrz|| jj| }|dksv|dkrzd}|\ }}} }
} } }
}
}
t j ||| |
| | }|}|}x&| jj
j D ]\}}||kr|}P qW totjd||| yL|dkr| j |f|dd |i}n"|dkr2t j
f ||i}|| }W n tk
rJ Y n X |j| |j S )a
Take C{quantity}, C{modifier} and C{unit} strings and convert them
into values. After converting, calcuate the time and return the
adjusted sourceTime.
@type source: time
@param source: time to use as the base (or source)
@type quantity: string
@param quantity: quantity string
@type modifier: string
@param modifier: how quantity and units modify the source time
@type units: string
@param units: unit of the quantity (i.e. hours, days, months, etc)
@rtype: struct_time
@return: C{struct_time} of the calculated time
z_buildTime: [%s][%s][%s]NrJ dyz!units %s --> realunit %s (qty=%s)yearsmonthsr daysr+ r, r- weeks)rm rn rM )ro r+ r, r- rp )rb debuglogr$ localtimestrip_quantityToRealrY Modifiersdatetimeunitsitemsinc timedelta
OverflowErrorr3 timetuple)r sourcequantitymodifierrx r7 qtyyrmthrl hrmnsec_starttargetZrealunitkeyvaluesdeltar
r
r
_buildTimeD sB
zCalendar._buildTimec C sz |dkr$t j \ }}}}}}} }
} n|\ }}}}}}} }
} d} d}
d}g }|}| jjj|}|dk r|j }t|d| } ||d d }| jjj|}|dk r|j }t|d| }
t||d d }n t|j }
| |
|g}|||d}| dkr| jjndddg}xRt dd D ]D}|| }|| }|dkr|||< |j
t j t j
t jd| qW |dkr||d ks||d kr||d kr|d | jj }n|d }|d }|d }|| jjk r|d
7 }n|d k r|d 7 }| jj||}totjd
|||| | j X}|dkrd|dkrd|dkrd||krd||||||| |
| f }|j| nt j }W dQ R X |S )a
Parse short-form date strings::
'05/28/2006' or '04.21'
@type dateString: string
@param dateString: text to convert to a C{datetime}
@type sourceTime: struct_time
@param sourceTime: C{struct_time} value to use as the base
@rtype: struct_time
@return: calculated C{struct_time} value of dateString
Nr )r' dyr r r' r r rI i r il zparseDate: %s %s %s %s rM rM rM rM )r$ rs rY CRE_DATE2searchr r" rt dp_orderrangerQ r ACU_MONTHACU_DAYACU_YEARYearParseStyle
BirthdayEpoch daysInMonthrq rr rd r3 )r r@
sourceTimer r rl r r r wdydisdstZv1Zv2Zv3accuracyrU r' indexvr r incZdaysInCurrentMonthr7 r
r
r parseDate sb
4
zCalendar.parseDatec C s |dkr$t j \ }}}}}}} }
} n|\ }}}}}}} }
} |} |}
g }toVtjd|| |j }| jjj|}|jd}| jj | }|j
d |jddk rt |jd}|j
d nd}|jddk r t |jd}|j
d || jj k r|d7 }n|d k r6|d
7 }n*|| k s*|| kr6||
k r6|| jj
7 }| j N}|d kr|| jj||kr||||||| |
| f }|j| nt j }W dQ R X totjd |||| |S )
a
Parse long-form date strings::
'May 31st, 2006'
'Jan 1st'
'July 2006'
@type dateString: string
@param dateString: text to convert to a datetime
@type sourceTime: struct_time
@param sourceTime: C{struct_time} value to use as the base
@rtype: struct_time
@return: calculated C{struct_time} value of dateString
Nz(parseDateText currentMth %s currentDy %smthnamer r r r i r il r z7parseDateText returned mth %d dy %d yr %d sourceTime %s)r$ rs rq rr rN rY CRE_DATE3r r# MonthOffsetsrQ r" r r rd r r3 )r r@ r r r rl r r r r r r Z
currentMthZ currentDyr rU r' r7 r
r
r
parseDateText sD
zCalendar.parseDateTextc C s d }}d }}|j j }| jj|krL|j| jjd| jj }|jdd}xn| jjdf| jjdf| jjdf| jjd f| jj d
f| jj
d f| jj d fgD ] \}} |j |}
|
d
k r| }P qW t
otj
d|| |
d
k r>|
j |kr:|
j } |d
|
j } ||
j d
}
d| |
f }| j||t\}}|js>d
}n|} |dkrtj | jj| }
| d
|
j }| |
j d d
}d}n|dkr.tj | jj| }
| jjrtj | jjd | }|d
k r| d
|
j | jjd }n | d
|
j | jjd }n| d
|
j }| |
j d d
}d}n\|d
krttj | jj| }
| d
|
j }| |
j d d
}d}n|d kr tj | jj| }
| |
j d d
}| jjj |}|jd}|d
k r| d
|
j j }| jjj |}|jd}|d
kr|d | }n| d
|
j }d}nl|d kr~tj | jj| }
| d
|
j }| jjj |}|jd}|| |
j d d
}d}n tj }}|r| j||t\}}| j||t\}}|j s|j rd}|||fS )a
Evaluate the C{datetimeString} text and determine if
it represents a date or time range.
@type datetimeString: string
@param datetimeString: datetime text to evaluate
@type sourceTime: struct_time
@param sourceTime: C{struct_time} value to use as the base
@rtype: tuple
@return: tuple of: start datetime, end datetime and the invalid flag
r rJ z %s z rK r r rI rH rL Nz evalRanges: rangeFlag = %s [%s]z%s %sr z, r )r r )rI r ) rt rN rY rangeSepr0 CRE_TIMERNG1 CRE_TIMERNG2 CRE_TIMERNG4 CRE_TIMERNG3 CRE_DATERNG1 CRE_DATERNG2 CRE_DATERNG3r rq rr r# r endparseVERSION_CONTEXT_STYLE
hasDateOrTimerC Z usesMeridianammeridianr r$ rs )r datetimeStringr Z rangeFlagZretFlagZstartStrZendStrrU ZcreZrflagr' parseStrchunk1chunk2r7 ZampmdateZendYearZ startYearr ZstartDTZendDTZsctxZectxr
r
r
evalRanges' s
zCalendar.evalRangesc C s || }|}|dkrH|| || ks0|r6||kr6d}n|dkrD|}nd}|d| }|dkrn|dk rn|d7 }n|d kr|dkr|d8 }t otj d||||| |S )
aO
Based on the C{style} and C{currentDayStyle} determine what
day-of-week value is to be returned.
@type wd: integer
@param wd: day-of-week value for the current day
@type wkdy: integer
@param wkdy: day-of-week value for the parsed day
@type offset: integer
@param offset: offset direction for any modifiers (-1, 0, 1)
@type style: integer
@param style: normally the value
set in C{Constants.DOWParseStyle}
@type currentDayStyle: integer
@param currentDayStyle: normally the value
set in C{Constants.CurrentDOWParseStyle}
@rtype: integer
@return: calculated day-of-week
r r r r z7wd %s, wkdy %s, offset %d, style %d, currentDayStyle %drM )rM r irM )rq rr ) r r wkdyr= ZstyleZcurrentDayStyleZdiffBaseZ
origOffsetr) r
r
r _CalculateDOWDelta s"
zCalendar._CalculateDOWDeltac C sX |sdS yt |jddS tk
r, Y nX yt | jj| S tk
rR Y nX dS )z
Convert a quantity, either spelled-out or numeric, to a float
@type quantity: string
@param quantity: quantity to parse to float
@rtype: int
@return: the quantity as an float, defaulting to 0.0
g ?r. r/ g )floatr0
ValueErrorrY numbersKeyError)r r r
r
r ru s zCalendar._quantityToRealc $ C s~ | j }| jj| }|dk r2|\ }}} }
} } }
}}ntj \ }}} }
} } }
}}| jjrb|
}| }| }n| jj}d}d}| jjj|}|dk r|j d }|d|j }||d }n|}d}t
ot j
d|||| || jj d kr| jj
||}|dkr|} ||| ||||
||f }n||dkrh| |kr<| jj
|d |} tj||| |||}| j|dd}|j }n*tj||d|||}| j||d}|j }|j|j n|| jj d krh|dkrtj||| d
dd}|tjd |
d }|j }nh|dkr(tj||| |||}|tjd
d }|j }n0tj||| |||}||tjdd }|j }|j|j n|| jj d kr |dkr||| d
dd|
||f }|j|j nd|dkrtj||| |
| | }|tjdd }|j }n,tj||| |||}|tj|d }|j }|j|j n<|| jj d kr|dkrP||| |
dd|
||f }n,tj||| |
dd}|tj|d }|j }|j|j n|| jj d kr|dkr|dd|
| | |
||f }n@|dkr|d || |
| | |
||f }n|| dd||||
||f }|j|j nH|dkrN| jj
||} ||| ||||
||f }|j|j n
|dkrd}| jj
||} ||| ||||
||f }|j|j n| jjj|r| jjj|}t
ot j
d |j }|dkr|j|j | j ||t \}}| jj ||}|dk r|}|j|j n|} |d(k} | r.d} | jj | }| j |
|| | jj!| jj"} tj||| |||}|tj| d }|dkr| r| j ||t \} }|j#rtj$| tj$| } |tj| d tj| | d }d}|j }|j|j nf|dkr|dkr| jj%j|r| jj%j|}t
o2t j
d | j |dt \\ }}} }
} } }
}}}tj||| |
| | }|tj|d }|j }nt
ot j
d || |j& }|r`d!||f }!| j |!|t \} }|j'rP|j( }"|"| jj)ks|"| jj*kr2| \ }}} }
} } }
}}tj||| |
| | }| j||d"j } n |"| jj+krP| tj|d } |j#r`| }d}|j& }|ryt,| jj-j.|d) }W n t/k
r Y nNX d}#t
ot j
d# | j0|j | }#d$|d|j |#||j1 d f }| j ||t \} }d}|j#r| }t
o t j
d%| | jj ||}|dk rXt
oFt j
d& |}|j|j t
olt j
d'||| d!||f |fS )*a
Evaluate the C{modifier} string and following text (passed in
as C{chunk1} and C{chunk2}) and if they match any known modifiers
calculate the delta and apply it to C{sourceTime}.
@type modifier: string
@param modifier: modifier text to apply to sourceTime
@type chunk1: string
@param chunk1: text chunk that preceded modifier (if any)
@type chunk2: string
@param chunk2: text chunk that followed modifier (if any)
@type sourceTime: struct_time
@param sourceTime: C{struct_time} value to use as the base
@rtype: tuple
@return: tuple of: remaining text and the modified sourceTime
Nr r rJ z/modifier [%s] chunk1 [%s] chunk2 [%s] unit [%s]rn r )r rp rH )ro r )rp ro r+ )r+ rm r r ZeomZeoyzCRE_WEEKDAY matchedZeodthisnextre priorprevious)r- zCRE_TIME matchedz0check for modifications to source time [%s] [%s]z%s %s)r zCRE_NUMBER matchedz%s%s%szlooking for modifier %szmodifier found in sourcesz-returning chunk = "%s %s" and sourceTime = %s)r r re r r rM )2rb rY rv r$ rs StartTimeFromSourceTime StartHour
CRE_REMAININGr r rq rr rx r rw rz r} r3 r r{ ZACU_WEEK ACU_HALFDAYr r4 r CRE_WEEKDAYr? r# r r getSourceWeekdayOffsetsr
DOWParseStyleCurrentDOWParseStyler r% CRE_TIMErt hasDaterN Months shortMonthsWeekdayslist
CRE_NUMBERfinditer
IndexErrorru r )$r r r r r r7 r= r r rl r r r r r r startHour startMinute startSecondr' r unitZcurrentDaysInMonthr r r ZsubctxsTimeZ dowOffsetZrelativeModifierr) r( r rU ur r
r
r
_evalModifier s^
$$
zCalendar._evalModifierc
C s | j }|j }|dkrt|}to0tjdt| |dk r|\
}}}}} }
} } }
}|j|j|j|j |dkr| dkr|
dkr|j|j
|j |j ||||| |
| | |
f }|dkrt
|}|dk r|j|j|j|j |j
|j |j |dkrtj }|S )a}
Calculate the datetime from known format like RFC822 or W3CDTF
Examples handled::
RFC822, W3CDTF formatted dates
HH:MM[:SS][ am/pm]
MM/DD/YYYY
DD MMMM YYYY
@type datetimeString: string
@param datetimeString: text to try and parse as more "traditional"
date/time text
@type sourceTime: struct_time
@param sourceTime: C{struct_time} value to use as the base
@rtype: datetime
@return: calculated C{struct_time} value or current C{struct_time}
if not parsed
Nz attempt to parse as rfc822 - %sr )rb rt rV rq rr strr3 r r r r4 r5 r6 rB r$ rs )r r r r7 rU r r rl r r r r r r r r
r
r _evalDT s( zCalendar._evalDTc C s^ |j }| j||}d}| jjj|}|dk rJ|jd}|d|jd }| j||||}|S )zA
Evaluate text passed by L{_partialParseUnits()}
rJ Nrx )rt r rY CRE_UNITSr r# r r )r r r rU r r' rx r r
r
r
_evalUnits+ s
zCalendar._evalUnitsc C s^ |j }| j||}d}| jjj|}|dk rJ|jd}|d|jd }| j||||}|S )zB
Evaluate text passed by L{_partialParseQUnits()}
rJ Nqunits)rt r rY
CRE_QUNITSr r# r r )r r r rU r r' rx r r
r
r _evalQUnits= s
zCalendar._evalQUnitsc C s. |j }| j||}to tjd | j||S )zC
Evaluate text passed by L{_partialParseDateStr()}
zchecking for MMM DD YYYY)rt r rq rr r )r r r rU r
r
r _evalDateStrO s zCalendar._evalDateStrc C s |j }| j||}| j||S )zC
Evaluate text passed by L{_partialParseDateStd()}
)rt r r )r r r rU r
r
r _evalDateStdZ s zCalendar._evalDateStdc C s |j }| j||}|\ }}}}}} }
} } y| jj| }
W n tk
rR d}
Y nX | jjrj|}|}| }n| jj}d}d}| jjt j
t j ||||||}|t j |
d }|j
S )zB
Evaluate text passed by L{_partialParseDaystr()}
r )ro )rt r rY
dayOffsetsr r r rb r3 r r rw r{ r} )r r r rU r r rl r r r r r r r= r r r r r r
r
r _evalDayStrd s&
zCalendar._evalDayStrc C s |j }| j||}|\ }}}}}} }
} } tj|||||| }
| jj| }||
krn| j|
|d| jj| jj}n| j|
|d| jj| jj}| jj t
j |
tj |d }|j
S )zC
Evaluate text passed by L{_partialParseWeekday()}
r )ro )rt r rw rY r r r r rb r3 r r r{ r} )r r r rU r r rl r r r r r r r r r r r
r
r _evalWeekday s
zCalendar._evalWeekdayc C s\ |j }| j||}|| jjd kr4| jjtj n$| jj||}|rJ|}| jjtj |S )zC
Evaluate text passed by L{_partialParseTimeStr()}
now)
rt r rY re_valuesrb r3 r ZACU_NOWr r )r r r rU r r
r
r _evalTimeStr s zCalendar._evalTimeStrc C s |j }| j||}|\ }}}}}} }
} } | jjj|}
|
dk r|d|
jd j }t|dkrtt|}d}d} nt|
\}}} |dkrd}|
j dj
}|| jj kr|dkrd}|| jj kr|dk r|d7 }|dk o|dk o| dk r |||||| |
| | f }t
|
| j |S )zD
Evaluate text passed by L{_partialParseMeridian()}
Nr r r r r; )rt r rY CRE_TIMEHMS2r r rP r" r2 r# rN r pmr8 rb )r r r rU r r rl r r r r r r r' dtr r
r
r
_evalMeridian s, zCalendar._evalMeridianc C s |j }| j||}|\ }}}}}} }
} } | jjj|}
|
dk rNt|
\}}} |dkrZd}|dk r|dk r| dk r|||||| |
| | f }t|
| j |S )zC
Evaluate text passed by L{_partialParseTimeStd()}
Nr r r; )rt r rY CRE_TIMEHMSr r2 r8 rb )r r r rU r r rl r r r r r r r' r
r
r _evalTimeStd s zCalendar._evalTimeStdc C sv | j jj|}|d k rnd|jd|j|f }|j||jdkrh|jd|jdkrh|jd|krhdS dS ndS d S )Nz%s%sr suffixr TF)rY CRE_DAY2r r# r )r rU r' r m2r( r
r
r
_UnitsTrapped s zCalendar._UnitsTrappedc C s d}d }}| j jj|}|dk rd|j |kr`|j }|d|j j }||j d j }n|}|rtoztjd||| | j ||||\}}||t
|fS )a
test if giving C{s} matched CRE_MODIFIER, used by L{parse()}
@type s: string
@param s: date/time text to evaluate
@type sourceTime: struct_time
@param sourceTime: C{struct_time} value to use as the base
@rtype: tuple
@return: tuple of remained date/time text, datetime object and
an boolean value to describ if matched or not
NrJ z found (modifier) [%s][%s][%s]) rY CRE_MODIFIERr r# r rt r rq rr r bool)r rU r r r r r' r
r
r _partialParseModifier s
z Calendar._partialParseModifierc C s d}d }}| j jj|}|dk rto.tjd | j||drNtoJtjd n~|jd|kr|jd}|d|jd j }||j dd j }|d d dkrd | }|dd
}d
||f }n|}d}|rtotjd ||| | j
||}||t |fS )a
test if giving C{s} matched CRE_UNITS, used by L{parse()}
@type s: string
@param s: date/time text to evaluate
@type sourceTime: struct_time
@param sourceTime: C{struct_time} value to use as the base
@rtype: tuple
@return: tuple of remained date/time text, datetime object and
an boolean value to describ if matched or not
NrJ zCRE_UNITS matchedrx z day suffix trapped by unit matchr r -z-%sz%s %szfound (units) [%s][%s][%s]rM rM ) rY r r rq rr r r# r rt r r r )r rU r r r r r' r
r
r _partialParseUnits' s,
zCalendar._partialParseUnitsc C s d}d }}| j jj|}|dk rto.tjd | j||drNtoJtjd n~|jd|kr|jd}|d|jd j }||j dd j }|d d dkrd | }|dd
}d
||f }n|}d}|rtotjd ||| | j
||}||t |fS )a
test if giving C{s} matched CRE_QUNITS, used by L{parse()}
@type s: string
@param s: date/time text to evaluate
@type sourceTime: struct_time
@param sourceTime: C{struct_time} value to use as the base
@rtype: tuple
@return: tuple of remained date/time text, datetime object and
an boolean value to describ if matched or not
NrJ zCRE_QUNITS matchedr z!day suffix trapped by qunit matchr r r z-%sz%s %szfound (qunits) [%s][%s][%s]rM rM ) rY r r rq rr r r# r rt r r r )r rU r r r r r' r
r
r _partialParseQUnitsU s.
z Calendar._partialParseQUnitsc
C s( d}d }}| j jj|}|dk r|jd|kr|jd}|jd}d} | j jj|}
|jd} |
dk rv| dk rvd} n"| j jj|}
|
dk r| dkrd} | r|
jd} | |jdk r| }||| }|d| }||d }d||f }n|}d}|rto t jd ||| | j
||}||t |fS )
a
test if giving C{s} matched CRE_DATE3, used by L{parse()}
@type s: string
@param s: date/time text to evaluate
@type sourceTime: struct_time
@param sourceTime: C{struct_time} value to use as the base
@rtype: tuple
@return: tuple of remained date/time text, datetime object and
an boolean value to describ if matched or not
NrJ r Fr Tr+ z%s %szfound (date3) [%s][%s][%s]) rY r r r# r r r r rq rr r r )
r rU r r r r r' ZmStartZmEndZfTimeZmmZmYearZ
hoursStartr
r
r _partialParseDateStr s<
z Calendar._partialParseDateStrc C s d}d }}| j jj|}|dk rt|jd|krl|jd}|d|jd }||jdd }d||f }n|}d}|rtotjd||| | j||}||t |fS )a
test if giving C{s} matched CRE_DATE, used by L{parse()}
@type s: string
@param s: date/time text to evaluate
@type sourceTime: struct_time
@param sourceTime: C{struct_time} value to use as the base
@rtype: tuple
@return: tuple of remained date/time text, datetime object and
an boolean value to describ if matched or not
NrJ r z%s %szfound (date) [%s][%s][%s])
rY CRE_DATEr r# r r rq rr r r )r rU r r r r r' r
r
r _partialParseDateStd s
z Calendar._partialParseDateStdc C s d}d }}| j jj|}|dk rl|j |krd|j }|d|j }||j d }d||f }n|}d}|rtotjd||| | j||}||t |fS )a
test if giving C{s} matched CRE_DAY, used by L{parse()}
@type s: string
@param s: date/time text to evaluate
@type sourceTime: struct_time
@param sourceTime: C{struct_time} value to use as the base
@rtype: tuple
@return: tuple of remained date/time text, datetime object and
an boolean value to describ if matched or not
NrJ z%s %szfound (day) [%s][%s][%s])
rY CRE_DAYr r# r r rq rr r r )r rU r r r r r' r
r
r _partialParseDayStr s z Calendar._partialParseDayStrc C s d}d }}| j }tjd||j|j | jjj|}|dk r|j }|| jj kr||kr|}|d|j
}||j d }d||f }n|}d}|r|j rtotjd||| | j ||}||t
|fS )a
test if giving C{s} matched CRE_WEEKDAY, used by L{parse()}
@type s: string
@param s: date/time text to evaluate
@type sourceTime: struct_time
@param sourceTime: C{struct_time} value to use as the base
@rtype: tuple
@return: tuple of remained date/time text, datetime object and
an boolean value to describ if matched or not
NrJ z eval %s with context - %s, %sz%s %sz found (weekday) [%s][%s][%s])rb rr rq r hasTimerY r r r# r r r r r ) r rU r r r r r7 r' Zgvr
r
r _partialParseWeekday s( z Calendar._partialParseWeekdayc C s d}d }}| j jj|}|dk s2|| j jd kr|rx|j |krx|j }|d|j }||j d }d||f }n|}d}|rtotjd||| | j ||}||t
|fS )a
test if giving C{s} matched CRE_TIME, used by L{parse()}
@type s: string
@param s: date/time text to evaluate
@type sourceTime: struct_time
@param sourceTime: C{struct_time} value to use as the base
@rtype: tuple
@return: tuple of remained date/time text, datetime object and
an boolean value to describ if matched or not
NrJ r z%s %szfound (time) [%s][%s][%s]) rY r r r r# r r rq rr r r )r rU r r r r r' r
r
r _partialParseTimeStrE s z Calendar._partialParseTimeStrc C s d}d }}| j jj|}|dk r|jddk rz|jddk r`d|jd|jd|jdf }qd|jd|jdf }n
|jd}|d|jd 7 }|d|j }||j d }d
||f }|rtotjd ||| | j||}||t |fS ) a
test if giving C{s} matched CRE_TIMEHMS2, used by L{parse()}
@type s: string
@param s: date/time text to evaluate
@type sourceTime: struct_time
@param sourceTime: C{struct_time} value to use as the base
@rtype: tuple
@return: tuple of remained date/time text, datetime object and
an boolean value to describ if matched or not
NrJ r, r- z%s:%s:%sr+ z%s:%srK r z%s %sz found (meridian) [%s][%s][%s])
rY r r r# r r rq rr r r )r rU r r r r r' r
r
r _partialParseMeridiank s*
z Calendar._partialParseMeridianc C s d}d }}| j jj|}|dk r|jddk rvd|jd|jd|jdf }|d|jd }||jdd }n s z"Calendar.parseDT..localizec s | j dS )N)tzinfo)r0 )r )r r
r r s )r rZ Nr )getattrr rw ) r r r r rZ r Z time_structZret_coder r
)r r r parseDT s zCalendar.parseDTc
C s t o tj d tjdd|}tjdd|}tjdd|}|rt|tjr`t oTtj d |j }qt|tj rt|t rt
dntj }| j }|j
j }t otj d | x|rDx\| j| j| j| j| j| j| j| j| j| jf
D ](}|||\}}} | r|j | }}P qW d
}t o.tj d |j|j t o@tj d | qW |d
krnt odtj dt| tj }W d
Q R X t|tjstj|}|d
kr| j n|}|t kr||fS ||j fS d
S )ag
Splits the given C{datetimeString} into tokens, finds the regex
patterns that match and then calculates a C{struct_time} value from
the chunks.
If C{sourceTime} is given then the C{struct_time} value will be
calculated from that value, otherwise from the current date/time.
If the C{datetimeString} is parsed and date/time value found, then::
If C{version} equals to L{VERSION_FLAG_STYLE}, the second item of
the returned tuple will be a flag to let you know what kind of
C{struct_time} value is being returned::
0 = not parsed at all
1 = parsed as a C{date}
2 = parsed as a C{time}
3 = parsed as a C{datetime}
If C{version} equals to L{VERSION_CONTEXT_STYLE}, the second value
will be an instance of L{pdtContext}
@type datetimeString: string
@param datetimeString: date/time text to evaluate
@type sourceTime: struct_time
@param sourceTime: C{struct_time} value to use as the base
@type version: integer
@param version: style version, default will use L{Calendar}
parameter version value
@rtype: tuple
@return: tuple of: modified C{sourceTime} and the result flag/context
zparse()z
(\w)\.(\s)z\1\2z(\w)[\'"](\s|$)z\1 \2z(\s|^)[\'"](\w)z coercing datetime to timetuplez sourceTime is not a struct_timez%remainedString (before parsing): [%s]rJ z hasDate: [%s], hasTime: [%s]zremainedString: [%s]Nznot parsed [%s]) rq rr rC sub
isinstancerw r} r$ Z struct_timetupler rs rd rN rt r r r r r r r
r r r
r r r rZ r Z dateTimeFlag)
r r r rZ r7 rU Z parseMethZretSZretTimeZmatchedr
r
r r sV "
zCalendar.parsec
C sh |j }|j}|j}y t|}W n ttfk
r: d}Y nX z.y t|}W n ttfk
rf d}Y nX W d||d 7 }d}X d}d}|rt|} || }t| d }
| |
d } || }|dk r|
d8 }
|d7 }n|dkr|
d7 }
|d8 }||
7 }| jj||}||kr|}|t j
ks*|t j k r2t d|j
|||d} |r\| t j|| d 7 } || | S )
a
Takes the given C{source} date, or current date if none is
passed, and increments it according to the values passed in
by month and/or year.
This routine is needed because Python's C{timedelta()} function
does not allow for month or year increments.
@type source: struct_time
@param source: C{struct_time} value to increment
@type month: float or integer
@param month: optional number of months to increment
@type year: float or integer
@param year: optional number of years to increment
@rtype: datetime
@return: C{source} incremented by the number of months and/or years
r Nr g g (@r zyear is out of range)r r r )ro )r r r r TypeErrorr r" rY r rw ZMAXYEARZMINYEARr| r0 r{ )
r r~ r r r r rl ZsubMiZmaxDayZmir r' r r
r
r rz N sJ
z Calendar.incc C s
|}t jdd|j }t jdd|}t jdd|}d}g }x|t|k r:dddddg}| jjj||d }|dk r|d dks|d |j | kr|j | |d< |j | |d< |j |d< d|d < d
|d < | jj
j||d }|dk rt ot j d | j
||d |d
r.t o*t j d n|d dksT|d |jd| kr|jd| |d< |jd| |d< |j d|d< d |d < d
|d < |jddkr||jdd dkr|d d |d< d|d |d< | jjj||d }|dk rt o t j d | j
||d |dr8t o4t j d n|d dks^|d |jd| kr|jd| |d< |jd| |d< |j d|d< d |d < d|d < |jddkr||jdd dkr|d d |d< d|d |d< | jjj||d }|dk rp|d dks.|d |jd| krp|jd| |d< |jd| |d< |j d|d< d|d < d|d < | jjj||d }|dk r|d dks|d |jd| kr|jd| |d< |jd| |d< |j d|d< d|d < d|d < | jjj||d }|dk rx|d dks<|d |j | krx|j | |d< |j | |d< |j |d< d|d < d|d < | jjj||d }|dk r||d | jjkr|d dks|d |j | kr|j | |d< |j | |d< |j |d< d|d < d|d < | jjj||d }|dk r|d dksR|d |j | kr|j | |d< |j | |d< |j |d< d|d < d|d < | jjj||d }|dk r |d dks|d |jd| kr |jd| |d< |jd| |d< ||d |d |d< d|d < d|d < | jjj||d }|dk r|d dksf|d |jd| kr|jd| |d< |j d dk r|jd | |d< n|jd | |d< ||d |d |d< d|d < d |d < t|dkr|d& d dkr| jjj||d }|dk r||||j j d krt oHt j d |j |d dksn|d |j | kr|j | |d< |j | |d< |j |d< d |d < d!|d < |d }|dkrt|}q>|d dkr.| jjj|d|d d" t|d }|dk r.|jd#|d< ||d |d |d< |j| q>W g } t|dk
rTd }
d} |d d dk} |d d dk}
|d d d k}xFt dt|D ]2}||d d }|| d }||| j j d k r| s|
s| rN||| d ||d d }
| j |
||\}}| jt j |dd$ ||| d ||d d |
f |} || d dk} || d dk}
|| d d k}qnB|| d dk rd%} || d dk rd%}
|| d d krd%}qW | s|
s|
r||| d |t|d d }
| j |
||\}}| jt j |dd$ ||| d |t|d d |
f nt|dk
rfdS |d d dk
r|dS ||d d |d d }
| j |d d ||\}}| jt j |dd$ ||d d |d d |
f t | S )'a Utilizes parse() after making judgements about what datetime
information belongs together.
It makes logical groupings based on proximity and returns a parsed
datetime for each matched grouping of datetime text, along with
location info within the given inputString.
@type inputString: string
@param inputString: natural language text to evaluate
@type sourceTime: struct_time
@param sourceTime: C{struct_time} value to use as the base
@type version: integer
@param version: style version, default will use L{Calendar}
parameter version value
@rtype: tuple or None
@return: tuple of tuples in the format (parsed_datetime as
datetime.datetime, flags as int, start_pos as int,
end_pos as int, matched_text as string) or None if there
were no matches
z (\w)(\.)(\s)z\1 \3z(\w)(\'|")(\s|$)z(\s|^)(\'|")(\w)r Nr r rI r rH zCRE_UNITS matchedrx z day suffix trapped by unit matchr r zCRE_QUNITS matchedr z!day suffix trapped by qunit matchr ZdateStrZdateStdZdayStrZweekdyZtimeStrr+ r r- r, ZtimeStdrJ zCRE_UNITS_ONLY matched [%s]Z unitsOnlyrK Z
nlp_prefixr TrM ) rC r rN rP rY r r r r r# r rq rr r r r r r r r r r r CRE_UNITS_ONLYrt CRE_NLP_PREFIXr rQ r r rw r )r Z inputStringr rZ Zorig_inputstringstartposZmatchesZleftmost_matchr' Zproximity_matchesZcombinedZfrom_match_indexr r$ rx r Z
endofpreviousZ begofcurrentZparsed_datetimeflagsr
r
r nlp s
"
z Calendar.nlp)N)N)N)NNN)NN)NN)NN),r r r __doc__r[ r_
contextlibcontextmanagerrd propertyrb rk r r r r r ru r r r r r r r r r r r r r r r r r r r
r r r
r r rz r r
r
r
r rW sR E
Y
E
5 3
($./J&&+&-*
/
\
ErW c C s ddg| _ ddg| _xxt| jjdd D ]`\}}ddg| }t| ||g t| |}|r*|j }|j|d dj | ||d dj | f q*W dS )z<
Initialize symbols and single character constants.
rJ Nr r r r z{0}.{1}.)
r r enumeratelocaler setattrr rN extendformat)rY idxZxmr Zlxmr
r
r _initSymbols s
r& c @ s< e Zd ZdZdddgfddZdd Zd d
Zd
d d ZdS )rX aC
Default set of constants for parsedatetime.
If PyICU is present, then the class will first try to get PyICU
to return a locale specified by C{localeID}. If either C{localeID} is
None or if the locale does not exist within PyICU, then each of the
locales defined in C{fallbackLocales} is tried in order.
If PyICU is not present or none of the specified locales can be used,
then the class will initialize itself to the en_US locale.
if PyICU is not present or not requested, only the locales defined by
C{pdtLocales} will be searched.
NTen_USc C s || _ |d d | _d| jkr*| jjd d | _|| _ttddd| _d| _d| _ d| _
d| _ d | _ d
| _
d | _dM| _d| _d| _d| _d| _d| _d| _d| _| jrt| j | _| jjd krd| _d | _| jd kr&| j tkrx4tdt| jD ] }| j| | _ | j tk rP qW t| j | _| jd k rdd }dd }|| jj}|| jj }|| jj } || jj }
||| jj d< ||| jj d< ||
| jj d< || | jj d< || jj | jj d < || jj!| jj d < t"j#| jj$| jj d < d d | jj%j& D } | j'td!d" || | jj d#< || jj(| jj d$< || jj)| jj d%< || jj*| jj+ | jj d&< d'd( } | | jj,| jj d | | jj,| jj d | | jj-| jjd | | jj-| jj d t.| d)j/f | jj | _0d*j/f | jj | _1d+j/f | jj | _2d,j/f | jj | _3d-j/f | jj | _4d.j/f | jj | _5d/j/f | jj | _6d0j/f | jj | _7d1j/f | jj | _8d2j/f | jj | _9d3j/f | jj | _:d4j/f | jj | _;d5| _ddj/|
| _@d?j/f | jj | _Ad@j/f | jj | _BdAj/f | jj | _CdB| _DdCj/f | jj | _EdDj/f | jj | _Fd6| jj kr| jFdEj/f | jj 7 _FdF|
| _GdGj/f | jj | _HdHj/| jGf| jj | _IdHj/| jHf| jj | _JdIj/| jHf| jj | _KdHj/| jFf| jj | _LdHj/| jEf| jj | _MdJj/| jFf| jj | _NdKj/| jE| jFf| jj | _Ot"jPt"jQ | _R| j5| j4| j7| j6| j8| j9| j:| j;| j?| j@| j1| j0| j2| j3| jA| jB| jC| jD| jE| jF| jG| jH| jL| jM| jN| jO| jI| jJ| jK| j._getLocaleDataAdjustedc S s dj dd | D S )Nr* c s s | ]}t j|V qd S )N)rC escape)r r r
r
r l s z6Constants.__init__..re_join..)rR )gr
r
r re_joink s z#Constants.__init__..re_joinrn Z shortmonthsro Z shortdaysZ
dayoffsetsr decimal_markc S s g | ]}|D ]}|q qS r
r
)r rx r r
r
r r s z&Constants.__init__..T)r reverserx Z modifiersZsourcesZtimecomponentsc S sL |}xB|D ]:}d|kr4x$|j dD ] }|| |< q"W n|| |< |d7 }q
W d S )Nr* r )r1 )Z
offsetDictr+ Z
indexStartor kr
r
r
_buildOffsets s
z)Constants.__init__.._buildOffsetsa (?P
(
(
(?P\d\d?)
(?P{daysuffix})?
(,)?
(\s)*
)
(?P
\b({months}|{shortmonths})\b
)\s*
(?P\d\d
(\d\d)?
)?
)
)aM (?P
(?:
(?:^|\s+)
(?P
{months}|{shortmonths}
)\b
|
(?:^|\s+)
(?P[1-9]|[012]\d|3[01])
(?P{daysuffix}|)\b
(?!\s*(?:{timecomponents}))
|
,?\s+
(?P\d\d(?:\d\d|))\b
(?!\s*(?:{timecomponents}))
){{1,3}}
(?(mthname)|$-^)
)a (\s+|^)
(?P
(
(?P
\b({months}|{shortmonths})\b
)
(\s*
(?P(\d{{4}}))
)?
)
)
(?=\s+|$|[^\w])z\b
(?:
{days}|{shortdays}
)
\bz-(\b(?:{numbers})\b|\d+(?:{decimal_mark}\d+|))z (?P^[{specials}]+)\s+z
\b({units})\bz\b(?P
-?
(?:\d+(?:{decimal_mark}\d+|)|(?:{numbers})\b)\s*
(?P{units})
)\bz\b(?P
-?
(?:\d+(?:{decimal_mark}\d+|)|(?:{numbers})\s+)\s*
(?P{qunits})
)\bzW\b(?:
{modifiers}
)\ba ([\s(\["'-]|^)
(?P\d\d?)
(?P{timeseparator}|)
(?P\d\d)
(?:(?P=tsep)
(?P\d\d
(?:[\.,]\d+)?
)
)?\ba ([\s(\["'-]|^)
(?P\d\d?)
(?:
(?P{timeseparator}|)
(?P\d\d?)
(?:(?P=tsep)
(?P\d\d?
(?:[\.,]\d+)?
)
)?
)?ao \b(?P
(on)
(\s)+1
|
(at|in)
(\s)+2
|
(in)
(\s)+3
)r z \s*(?P{meridian})\bz\brJ c s s | ]}t j|V qd S )N)rC r- )r rU r
r
r r. -
s z%Constants.__init__..r/ a ([\s(\["'-]|^)
(?P
\d\d?[{0}]\d\d?(?:[{0}]\d\d(?:\d\d)?)?
|
\d{{4}}[{0}]\d\d?[{0}]\d\d?
)
\bz[{0}]z\b
(?:
{dayoffsets}
)
\bzZ(?P\d\d?)
(?P{daysuffix})?
z\b
(?:
{sources}
)
\bz\s+z(\s*|^)
(\d\d?){timeseparator}
(\d\d)
({timeseparator}(\d\d))?
(\s*|$)z(\s*|^)
(\d\d?)
({timeseparator}(\d\d?))?
({timeseparator}(\d\d?))?z\s*({meridian})z(\d+([%s]\d+)+)a (
(
(
\b({months})\b
)\s*
(
(\d\d?)
(\s?|{daysuffix}|$)+
)?
(,\s*\d{{4}})?
)
)z {0}\s*{rangeseparator}\s*{0}z1{0}\s*{rangeseparator}\s*(\d\d?)\s*(rd|st|nd|th)?z \d\d?\s*{rangeseparator}\s*{0}z {0}\s*{rangeseparator}\s*{1}) Z CRE_SPECIALr r r r r r r r r r Z CRE_DATE4Z CRE_MONTHr r r r r Z CRE_RTIMEHMSZ
CRE_RTIMEHMS2Z CRE_RDATEZ
CRE_RDATE3r r r r r r r r ) r r r r r r r r r r r r )WlocaleIDfallbackLocalesrQ r! usePyICUr r
_leapYearsZSecondZMinuteZHourZDayZWeekZMonthZYear_DaysInMonthListr r r r r r r r Zicu
pdtLocalesrP r r Z
shortWeekdaysr r r r rC r- r1 rx r sortrv
re_sourcesZtimeSepr r r r& r$ ZRE_DATE4ZRE_DATE3ZRE_MONTHZ
RE_WEEKDAYZ RE_NUMBERZ
RE_SPECIALZ
RE_UNITS_ONLYZRE_UNITSZ RE_QUNITSZ RE_MODIFIERZ
RE_TIMEHMSZ RE_TIMEHMS2Z
RE_NLP_PREFIXrR ZdateSepZRE_DATEZRE_DATE2ZRE_DAYZRE_DAY2ZRE_TIMEZ RE_REMAININGZ RE_RTIMEHMSZ RE_RTIMEHMS2ZRE_RDATEZ RE_RDATE3ZDATERNG1ZDATERNG2ZDATERNG3ZTIMERNG1ZTIMERNG2ZTIMERNG3ZTIMERNG4
IGNORECASEVERBOSE re_option
cre_sourcesetkeyscre_keys)r r6 r8 r7 ZlocaleIdr, r0 ZmthsZsmthsZswdsZwdsrx r5 ZdateSepsr
r
r r_ s(
zConstants.__init__c C sR || j kr.tj| j| | j}t| || |S || jjkrFt| j|S t |d S )N)
rD rC rD rA r@ r" r! Z locale_keysr AttributeError)r namevaluer
r
r __getattr__
s
zConstants.__getattr__c C sr d}t otj d|| |dkrn|dkrn| j|d }|dkrn|| jkrP|d7 }n tj|rn| jj| |d7 }|S )z
Take the given month (1-12) and a given year (4 digit) return
the number of days in the month adjusting for leap year as needed
NzdaysInMonth(%s, %s)r r r r )rq rr r: r9 calendarZisleaprQ )r r r resultr
r
r r
s
zConstants.daysInMonthc C s || j krdS |dkr2tj \ }}}}}}} }
} n|\ }}}}}}} }
} ||||||d} | j | }
i }x$| j D ]\}}|
j||||< qrW |d |d |d |d |d |d | |
| f S ) a>
GetReturn a date/time tuple based on the giving source key
and the corresponding key found in self.re_sources.
The current time is used as the default and any specified
item found in self.re_sources is inserted into the value
and the generated dictionary is returned.
N)r r rl r r r r r rl r r r )r= r$ rs ry rf )r Z sourceKeyr r r rl r r r r r r Zdefaultsr~ r r defaultr
r
r r
s
zConstants.getSource)N)r r r r r_ rH r r r
r
r
r rX s B
rX )9r Z
__future__r r r rC r$ Zloggingr\ rw rI r Z email.utilsrS Z pdt_localesr Z_localesr r rd r r
Zwarnsr
__author__Z __email__Z
__copyright__Z __license__ __version__Z__url__Z__download_url__Z__description__r ImportErrorZHandlerZ getLoggerr rr Z
addHandlerrq dictr; r* r2 r8 rE rB rB Z _monthnamesrO rV r[ r objectrW r& rX r
r
r
r sz
.+
\