def _read_reminder_params(user_input, force=False):
"""
:return: (headers, data), or None (meaning to action required)
"""
dt = None
# Direct input using arguments or asking the user
if user_input:
res = Calendar().nlp(user_input)
if res:
dt, flags, start_pos, end_post, matched_text = res[0]
user_input = user_input[0:start_pos].strip()
else:
user_input = input('What\'s the reminder: ')
if not dt:
date_str = input('When do you want to be reminded (NA to omit date): ')
if date_str != "NA":
dt,r = Calendar().parseDT(date_str)
if r == 0:
print('Unrecognizable time text')
return
date_msg = ""
if dt:
weekday = WEEKDAYS[dt.weekday()]
date_msg = f'on {weekday}, {str(dt.day).zfill(2)}/{str(dt.month).zfill(2)}/{dt.year} at {str(dt.hour).zfill(2)}:{str(dt.minute).zfill(2)}\n'
print(f'"{user_input}" {date_msg}')
if not force:
save = read_yes_no('Do you want to save this?')
if force or save:
return build_request_params(user_input, dt.year, dt.month, dt.day, dt.hour, dt.minute)
def parse_terminal(pstate):
next_tag = pstate.next_tag()
if next_tag is _tag:
return make_tag_query(pstate.next_str_and_advance())
elif next_tag is _negtag:
return NotQuery(make_tag_query(pstate.next_str_and_advance()[1:]))
elif next_tag is _fulltext:
return FulltextQuery(pstate.next_str_and_advance()[1:-1])
elif next_tag is _dated:
pstate.advance()
return DatedQuery()
elif next_tag in _STATELESS_TERMINALS:
pstate.advance()
return _STATELESS_TERMINALS[next_tag]
elif next_tag in [_id]:
result = IdQuery(int(pstate.next_match_obj().group(1)))
pstate.advance()
return result
elif next_tag in [_before, _after]:
from parsedatetime.parsedatetime import Calendar
cal = Calendar()
timetup = cal.parse(pstate.next_match_obj().group(1))
pstate.advance()
import time
return DateQuery(next_tag == _before, time.mktime(timetup[0]))
else:
pstate.expected("terminal")
def date_time_from_str(datetime_str):
# from http://stackoverflow.com/a/5903760, updated with more reasonable
# variable names.
assert datetime, "Unable to parse empty date/time string."
parsed_result, date_type = Calendar().parse(datetime_str)
parsed_datetime = None
# what was returned (based on parsedatetime docs)
# 0 = failed to parse
# 1 = date (with current time, as a struct_time)
# 2 = time (with current date, as a struct_time)
# 3 = datetime
if date_type == 3:
# parsed_result is a datetime
parsed_datetime = parsed_result
elif date_type in (1, 2):
# parsed_result is struct_time
parsed_datetime = datetime.datetime(*parsed_result[:6])
else:
# Failed to parse
raise ValueError("Could not parse date/time string: " + datetime_str)
return parsed_datetime
def parse_time(timestr):
"""Parses a time string and returns the number of seconds from now to wait
"""
c = Calendar()
result, status = c.parse(timestr)
if status == 0:
raise ValueError("I don't understand when you want me to do that")
timestamp = time.mktime(result)
now = time.time()
return max(1, timestamp - now)
def execute(pagename, request, fieldname='value', titlesearch=0, statistic=0):
_ = request.getText
titlesearch = checkTitleSearch(request)
if titlesearch < 0:
check_surge_protect(request, kick=True) # get rid of spammer
return
advancedsearch = isAdvancedSearch(request)
form = request.values
# context is relevant only for full search
if titlesearch:
context = 0
elif advancedsearch:
context = 180 # XXX: hardcoded context count for advancedsearch
else:
context = int(form.get('context', 0))
# Get other form parameters
needle = form.get(fieldname, '')
case = int(form.get('case', 0))
regex = int(form.get('regex', 0)) # no interface currently
hitsFrom = int(form.get('from', 0))
mtime = None
msg = ''
historysearch = 0
# if advanced search is enabled we construct our own search query
if advancedsearch:
and_terms = form.get('and_terms', '').strip()
or_terms = form.get('or_terms', '').strip()
not_terms = form.get('not_terms', '').strip()
#xor_terms = form.get('xor_terms', '').strip()
categories = form.getlist('categories') or ['']
timeframe = form.get('time', '').strip()
language = form.getlist('language') or ['']
mimetype = form.getlist('mimetype') or [0]
excludeunderlay = form.get('excludeunderlay', 0)
nosystemitems = form.get('nosystemitems', 0)
historysearch = form.get('historysearch', 0)
mtime = form.get('mtime', '')
if mtime:
mtime_parsed = None
# get mtime from known date/time formats
for fmt in (request.user.datetime_fmt, request.cfg.datetime_fmt,
request.user.date_fmt, request.cfg.date_fmt):
try:
mtime_parsed = time.strptime(mtime, fmt)
except ValueError:
continue
else:
break
if mtime_parsed:
mtime = time.mktime(mtime_parsed)
else:
# didn't work, let's try parsedatetime
cal = Calendar()
mtime_parsed, parsed_what = cal.parse(mtime)
# XXX it is unclear if usage of localtime here and in parsedatetime module is correct.
# time.localtime is the SERVER's local time and of no relevance to the user (being
# somewhere in the world)
# mktime is reverse function for localtime, so this maybe fixes it again!?
if parsed_what > 0 and mtime_parsed <= time.localtime():
mtime = time.mktime(mtime_parsed)
else:
mtime_parsed = None # we don't use invalid stuff
# show info
if mtime_parsed:
# XXX mtime_msg is not shown in some cases
mtime_msg = _(
"(!) Only pages changed since '''%s''' are being displayed!",
wiki=True) % request.user.getFormattedDateTime(mtime)
else:
mtime_msg = _(
'/!\\ The modification date you entered was not '
'recognized and is therefore not considered for the '
'search results!',
wiki=True)
else:
mtime_msg = None
word_re = re.compile(r'(\"[\w\s]+"|\w+)')
needle = ''
if categories[0]:
needle += 'category:%s ' % ','.join(categories)
if language[0]:
needle += 'language:%s ' % ','.join(language)
if mimetype[0]:
needle += 'mimetype:%s ' % ','.join(mimetype)
if excludeunderlay:
needle += '-domain:underlay '
if nosystemitems:
needle += '-domain:system '
if and_terms:
needle += '(%s) ' % and_terms
if not_terms:
needle += '(%s) ' % ' '.join(
['-%s' % t for t in word_re.findall(not_terms)])
if or_terms:
needle += '(%s) ' % ' or '.join(word_re.findall(or_terms))
# check for sensible search term
stripped = needle.strip()
if len(stripped) == 0:
request.theme.add_msg(
_(
'Please use a more selective search term instead '
'of {{{"%s"}}}',
wiki=True) % wikiutil.escape(needle), "error")
Page(request, pagename).send_page()
return
needle = stripped
# Setup for type of search
if titlesearch:
title = _('Title Search: "%s"')
sort = 'page_name'
else:
if advancedsearch:
title = _('Advanced Search: "%s"')
else:
title = _('Full Text Search: "%s"')
sort = 'weight'
# search the pages
from MoinMoin.search import searchPages, QueryParser, QueryError
try:
query = QueryParser(case=case, regex=regex,
titlesearch=titlesearch).parse_query(needle)
except QueryError: # catch errors in the search query
request.theme.add_msg(
_(
'Your search query {{{"%s"}}} is invalid. Please refer to '
'HelpOnSearching for more information.',
wiki=True,
percent=True) % wikiutil.escape(needle), "error")
Page(request, pagename).send_page()
return
results = searchPages(request, query, sort, mtime, historysearch)
# directly show a single hit for title searches
# this is the "quick jump" functionality if you don't remember
# the pagename exactly, but just some parts of it
if titlesearch and len(results.hits) == 1:
page = results.hits[0]
if not page.attachment: # we did not find an attachment
page = Page(request, page.page_name)
highlight = query.highlight_re()
if highlight:
querydict = {'highlight': highlight}
else:
querydict = {}
url = page.url(request, querystr=querydict)
request.http_redirect(url)
return
if not results.hits: # no hits?
f = request.formatter
querydict = dict(wikiutil.parseQueryString(request.query_string))
querydict.update({'titlesearch': 0})
request.theme.add_msg(
_(
'Your search query {{{"%s"}}} didn\'t return any results. '
'Please change some terms and refer to HelpOnSearching for '
'more information.%s',
wiki=True,
percent=True) %
(wikiutil.escape(needle), titlesearch and ''.join([
'<br>',
_('(!) Consider performing a', wiki=True),
' ',
f.url(1, href=request.page.url(request, querydict, escape=0)),
_('full-text search with your search terms'),
f.url(0),
'.',
]) or ''), "error")
Page(request, pagename).send_page()
return
# This action generates data using the user language
request.setContentLanguage(request.lang)
request.theme.send_title(title % needle, pagename=pagename)
# Start content (important for RTL support)
request.write(request.formatter.startContent("content"))
# Hints
f = request.formatter
hints = []
if titlesearch:
querydict = dict(wikiutil.parseQueryString(request.query_string))
querydict.update({'titlesearch': 0})
hints.append(''.join([
_(
"(!) You're performing a title search that might not include"
' all related results of your search query in this wiki. <<BR>>',
wiki=True),
' ',
f.url(1, href=request.page.url(request, querydict, escape=0)),
f.text(
_('Click here to perform a full-text search with your '
'search terms!')),
f.url(0),
]))
if advancedsearch and mtime_msg:
hints.append(mtime_msg)
if hints:
request.write(searchHints(f, hints))
# Search stats
request.write(results.stats(request, request.formatter, hitsFrom))
# Then search results
info = not titlesearch
if context:
output = results.pageListWithContext(request,
request.formatter,
info=info,
context=context,
hitsFrom=hitsFrom,
hitsInfo=1)
else:
output = results.pageList(request,
request.formatter,
info=info,
hitsFrom=hitsFrom,
hitsInfo=1)
request.write(output)
request.write(request.formatter.endContent())
request.theme.send_footer(pagename)
request.theme.send_closing_html()
import calendar
import time
import locale
import six
import re
from dateutil.tz import tzlocal
from dateutil.parser import parse as dateutil_parse
from datetime import datetime, timedelta
from parsedatetime.parsedatetime import Calendar
locale.setlocale(locale.LC_ALL, '')
fuzzy_date_parse = Calendar().parse
REMINDER_REGEX = r'^(\d+)([wdhm]?)(?:\s+(popup|email|sms))?$'
def parse_reminder(rem):
match = re.match(REMINDER_REGEX, rem)
if not match:
# Allow argparse to generate a message when parsing options
return None
n = int(match.group(1))
t = match.group(2)
m = match.group(3)
if t == 'w':
n = n * 7 * 24 * 60
elif t == 'd':
n = n * 24 * 60
elif t == 'h':
n = n * 60
import calendar
import time
import locale
import six
import re
from dateutil.tz import tzlocal
from dateutil.parser import parse as dateutil_parse
from datetime import datetime, timedelta
from parsedatetime.parsedatetime import Calendar
locale.setlocale(locale.LC_ALL, '')
fuzzy_date_parse = Calendar().parse
fuzzy_datetime_parse = Calendar().parseDT
REMINDER_REGEX = r'^(\d+)([wdhm]?)(?:\s+(popup|email|sms))?$'
DURATION_REGEX = re.compile(
r'^((?P<days>[\.\d]+?)(?:d|day|days))?[ :]*'
r'((?P<hours>[\.\d]+?)(?:h|hour|hours))?[ :]*'
r'((?P<minutes>[\.\d]+?)(?:m|min|mins|minute|minutes))?[ :]*'
r'((?P<seconds>[\.\d]+?)(?:s|sec|secs|second|seconds))?$'
)
def parse_reminder(rem):
match = re.match(REMINDER_REGEX, rem)
if not match:
# Allow argparse to generate a message when parsing options
return None
