def HSV_DnS_calendar():
url = 'http://www.huntsvilledefenseandspacecalendar.com/'
r = urllib.request.urlopen(url).read()
soup = BeautifulSoup(r, 'lxml')
events = []
for event in soup.find_all("b"):
if is_number(event.text[0]):
events.append(event.text)
c = pdt.Constants()
p = pdt.Calendar(c)
event_dict = {}
for i in range(len(events)):
try:
dates, event = events[i].split('–')[0].replace('\n\t', ' '), \
events[i].split('–')[1].replace('\n\t', ' ')
if len(event) > 4:
dates = dates.rstrip()
datesr = dates.split()
datesr.reverse()
datesr = ' '.join(datesr)
event_dict[event.rstrip()] = dateparser.parse(dates), \
dates, url
#TODO: make code to catch the multi-day events... currently this will break
except:
pass
return event_dict
def register_event(bot, update, args, job_queue, chat_data):
print("Start register_event")
try:
init_chat_data(update, chat_data, bot, job_queue)
string = ""
while len(args):
if re.search('http:', args[0]) or re.search('https:', args[0]):
break
else:
string += args[0] + " "
args = args[1:]
rest_string = " ".join(args)
c = pdt.Constants("ru_RU")
p = pdt.Calendar(c)
finish_time, status = p.parseDT(string)
if status > 0 and (re.search('Завтра', string) or re.search(
'завтра', string)) and datetime.now().hour <= 6:
update.message.reply_text(
'Не надо использовать слово "завтра" ночью, пожалуйста')
return
chat_data['message_collection'].add_message(Message(
message=string + " " + rest_string,
finish_time=finish_time,
is_schedulable=(status > 0),
bot=bot),
silent=False)
except:
handle_exception(update)
def testSpanishNums(self):
self.ptc = pdt.Constants('es', usePyICU=False)
self.cal = pdt.Calendar(self.ptc)
(self.yr, self.mth, self.dy, self.hr,
self.mn, self.sec, self.wd, self.yd, self.isdst) = time.localtime()
if self.ptc.localeID != 'es':
raise unittest.SkipTest(
'Locale not set to es - check if PyICU is installed')
self.assertExpectedResult(
self.cal.word_to_num('noventa y ocho'), 98)
self.assertExpectedResult(
self.cal.word_to_num('setenta'), 70)
self.assertExpectedResult(
self.cal.word_to_num('veintisiete'), 27)
self.assertExpectedResult(
self.cal.word_to_num('uno'), 1)
self.assertExpectedResult(
self.cal.word_to_num('ciento veintitres'), 123)
self.assertExpectedResult(
self.cal.word_to_num('doscientos cuarenta y tres'), 243)
self.assertExpectedResult(
self.cal.word_to_num('ciento uno'), 101)
self.assertExpectedResult(
self.cal.word_to_num('doscientos setenta y seis'), 276)
def _extract_date(self, detail, body):
posted_date = datetime.strptime(
detail.find('span', attrs='date').text, '%a, %Y-%m-%d %H:%M')
constants = pdt.Constants()
constants.Year = posted_date.year
# Wrap the year around if the date is past december
if posted_date.month == 12:
constants.Year = (posted_date + timedelta(years=1)).year
constants.YearParseStyle = 0
calendar = pdt.Calendar(constants)
comment_link = body.find(text='Click here to comment')
dates = []
for x in comment_link.find_parent('p').find_all_previous(
text=self.date_regex, limit=2):
if isinstance(x, Tag):
x = x.text
x = calendar.parse(x)
x = to_datetime(*x)
x = x.date()
dates.append(x)
dates.sort()
return dates
def human_date_to_datetime(self,
time_input,
tz=None,
source_datetime=None):
""" Convert human readable date (e.g. 30 days ago) to datetime.datetime using
parsedatetime module.
Examples:
* August 25th, 2008
* 25 Aug 2008
* Aug 25 5pm
* 5pm August 25
* next saturday
* tomorrow
* next thursday at 4pm
* at 4pm
* eod
* tomorrow eod
* eod tuesday
* eoy
* eom
* in 5 minutes
* 5 minutes from now
* 5 hours before now
* 2 hours before noon
* 2 days from tomorrow
Args:
time_input (string): The time input string (see formats above).
tz (string): The time zone for the returned datetime.
source_datetime (datetime.datetime): The reference or source datetime.
Returns:
(datetime.datetime): Python datetime.datetime object.
"""
c = pdt.Constants('en')
cal = pdt.Calendar(c, version=2)
tzinfo = None
src_tzname = None
if source_datetime is not None:
tzinfo = source_datetime.tzinfo
src_tzname = source_datetime.tzname()
try:
dt, status = cal.parseDT(time_input,
sourceTime=source_datetime,
tzinfo=tzinfo)
if tz is not None: # don't add tz if no tz value is passed
if dt.tzinfo is None:
dt = self._replace_timezone(dt)
# don't covert timezone if source timezone already in the correct timezone
if tz != src_tzname:
dt = dt.astimezone(pytz.timezone(tz))
if status.accuracy == 0:
dt = None
except TypeError: # pragma: no cover
dt = None
return dt
def convertToPythonDatetimeObj(aDate):
c = parsedatetime.Constants()
c.BirthdayEpoch = 80
p = parsedatetime.Calendar(c)
time_struct, parse_status = p.parse(aDate)
return datetime(*time_struct[:6])
def testFrenchNums(self):
self.ptc = pdt.Constants('fr_FR', usePyICU=False)
self.cal = pdt.Calendar(self.ptc)
(self.yr, self.mth, self.dy, self.hr, self.mn, self.sec, self.wd,
self.yd, self.isdst) = time.localtime()
if self.ptc.localeID != 'fr_FR':
raise unittest.SkipTest(
'Locale not set to fr_FR - check if PyICU is installed')
start = datetime.datetime(self.yr, self.mth, self.dy, self.hr, self.mn,
self.sec).timetuple()
target = datetime.datetime(self.yr, 9, 25, self.hr, self.mn,
self.sec).timetuple()
self.assertExpectedResult(
self.cal.parse('vingt cinq septembre', start), (target, 1))
target = datetime.datetime(self.yr, self.mth, self.dy, self.hr,
self.mn,
self.sec) + datetime.timedelta(days=5)
target = target.timetuple()
self.assertExpectedResult(self.cal.parse('apres cinq jours', start),
(target, 1))
def remind(self, msg, args):
"""save a new reminder. Usage: !remind <date/time> -> <thing>"""
if "->" not in args:
return "Usage: !remind <date/time> -> <thing>. For example: !remind tomorrow 12:00 -> Lunch with the dudebros to be reminded to eat lunch with the dudebros at noon the next day."
# if (datetime.now()).astimezone(pytz.timezone('US/Pacific')) > reminder['date'] and not reminder['sent']:
pdt = parsedatetime.Calendar(
parsedatetime.Constants(
self.config['LOCALE'] if self.config else DEFAULT_LOCALE))
date_end = args.index('->')
date_list = args[:date_end]
date_struct = pdt.parse(
date_list,
datetime.now().astimezone(pytz.timezone('US/Pacific')).timetuple())
if date_struct[1] == 0:
return "Your date seems malformed: {date}".format(date=date_string)
date = (datetime(*(date_struct[0])[:6]))
message = args[date_end + 1:]
is_user = msg.is_direct
target = msg.frm
self.add_reminder(date, message, target, is_user)
return "Reminder set to \"{message}\" at {date}.".format(
message=message, date=date)
def fuzzy_date_parser(text):
"""Thin wrapper around ``parsedatetime`` module.
Since there's no upstream suppport for multiple locales, this wrapper
exists.
:param str text: Text to parse.
:returns: A parsed date/time object. Raises exception on failure.
:rtype: datetime
"""
locales = parsedatetime._locales[:]
# Loop through all the locales and try to parse successfully our string
for locale in locales:
const = parsedatetime.Constants(locale)
const.re_option += re.UNICODE
parser = parsedatetime.Calendar(const)
try:
parsed, ok = parser.parse(text)
except:
continue
if ok:
return datetime(*parsed[:6])
raise Exception('Failed to parse the string.')
def __init__(self, name, emitter=None):
super(ScheduledSkill, self).__init__(name, emitter)
self.timer = None
self.calendar = pdt.Calendar(
pdt.Constants(localeID=self.lang.replace('-', '_'),
usePyICU=False))
self.time_rules = time_rules.create(self.lang)
self.init_format()
def testYearParseStyle(self):
config = pdt.Constants()
config.YearParseStyle = 0
calendar = pdt.Calendar(config)
start = datetime.datetime(self.yr, self.mth, self.dy, self.hr, self.mn,
self.sec).timetuple()
target = datetime.datetime(self.yr, 7, 28, self.hr, self.mn,
self.sec).timetuple()
self.assertExpectedResult(calendar.parse('7/28', start), (target, 1))
def setUp(self):
self.ptc = pdt.Constants('fr_FR', usePyICU=True)
self.cal = pdt.Calendar(self.ptc)
(self.yr, self.mth, self.dy, self.hr, self.mn, self.sec, self.wd,
self.yd, self.isdst) = time.localtime()
if self.ptc.localeID != 'fr_FR':
raise unittest.SkipTest(
'Locale not set to fr_FR - check if PyICU is installed')
def __init__(self, date_format=None, locale=None, **kwargs):
super(Date, self).__init__(**kwargs)
self.date_format = date_format
self.locale = locale
self._constants = parsedatetime.Constants(localeID=self.locale)
self._parser = parsedatetime.Calendar(
constants=self._constants,
version=parsedatetime.VERSION_CONTEXT_STYLE)
def setUp(self):
self.ptc = pdt.Constants('de_DE', usePyICU=False)
self.cal = pdt.Calendar(self.ptc)
self.yr, self.mth, self.dy, self.hr, self.mn, self.sec, self.wd, self.yd, self.isdst = time.localtime(
)
if self.ptc.localeID != 'de_DE':
raise unittest.SkipTest(
'Locale not set to de_DE - check if PyICU is installed')
def __init__(self, filename, encoding=None, locale=None):
super(FP5File, self).__init__()
self.logging = logging.getLogger('fp5dump.fp5file.fp5file')
self.filename = filename
self.locale = locale
self.encoding = encoding if encoding else 'latin1'
self.ptd_parser = pdt.Calendar(pdt.Constants())
self.basename = os.path.splitext(os.path.basename(filename))[0]
self.dirname = os.path.dirname(
os.path.abspath(os.path.expanduser(filename)))
self.db_name = self.basename
self.export_definition = None
self.error_report_columns = []
self.block_chains = []
self.block_chain_levels = 0
self.fields = {}
self.index = None
self.data = None
self.enums = []
self.file_size = 0
self.records_index = []
self.records_count = 0
self.version_string = ""
self.filename_string = ""
self.server_addr_string = ""
self.block_prev_id_to_block_pos = None
self.block_id_to_block_pos = None
self.logging.info('opening "%s"' % self.basename)
self.file = open(os.path.abspath(os.path.expanduser(self.filename)),
"rb",
buffering=0)
self.largest_block_id = 0x00000000
self.read_header()
self.get_blocks()
self.order_block_indices()
self.get_field_index()
self.get_record_index()
def __setstate__(self, ndict):
"""
Restore state from the unpickled state values. Set _constants to an instance
of the parsedatetime Constants class, and _parser to an instance
of the parsedatetime Calendar class.
"""
self.__dict__.update(ndict)
self._constants = parsedatetime.Constants(localeID=self.locale)
self._parser = parsedatetime.Calendar(
constants=self._constants,
version=parsedatetime.VERSION_CONTEXT_STYLE)
def setUp(self):
locale = 'ru_RU'
self.ptc = pdt.Constants(locale, usePyICU=False)
self.cal = pdt.Calendar(self.ptc)
(self.yr, self.mth, self.dy, self.hr, self.mn, self.sec, self.wd,
self.yd, self.isdst) = time.localtime()
if self.ptc.localeID != locale:
raise unittest.SkipTest(
'Locale not set to %s - check if PyICU is installed' % locale)
def main(event, context):
"""
Main functionality
"""
all_issues = ''
herd_exist = False
cons = pdt.Constants()
cons.YearParseStyle = 0
pdtcal = pdt.Calendar(cons)
now_tm = pdtcal.parse("now")
now_str = strftime('%c', now_tm[0])
team_info = load_definition_file(TEAM_FILEPATH)
for svc in team_info['CowDefs']:
svc_info = load_definition_file(DEFS_PATH + svc)
cows_exist = False
# Ensure API exists for service
try:
svc_client = boto3.client(svc_info['Service'])
except UnknownServiceError:
Logger.critical('Service unknown to AWS API: %s',
svc_info['Service'])
if svc_info['Service'] in SERVICE_LIST:
inst_tags = get_service_instance_tags(svc_client, svc_info)
new_cows = analyze_service_instances(inst_tags, svc_info)
cowfile = svc_info['Service'] + '_' + svc_info['S3Suffix'] + '.json'
old_roundup = load_roundup(team_info['Bucket'], cowfile)
new_roundup = handle_cows(new_cows, old_roundup, svc_client,
svc_info, pdtcal, now_tm, now_str)
http_status = save_roundup(new_roundup, team_info['Bucket'],
cowfile)
if http_status <> 200:
Logger.error('Unable to write roundup file: %s', cowfile)
if new_roundup['cows']:
cows_exist = True
herd_exist = True
report_text = format_report(new_roundup, svc_info)
all_issues += report_text
if svc_info['CreateServiceReport'] and cows_exist:
send_report(report_text, svc_info, now_str)
else:
Logger.warning(
'No permissions for retrieving instances. Service: ')
Logger.warning(svc_info['Service'])
if team_info['CreateTeamReport'] and herd_exist:
send_report(all_issues, svc_info, now_str)
def date_analyzer(line):
c = pdt.Constants()
c.BirthdayEpoch = 60
p = pdt.Calendar(c)
result = p.parse(line)
year, month, day, hour, mins, secs = result[0][:6]
UTS = result[1]
if UTS == 0:
return None
else:
return result
async def reload(self):
await super().reload()
langs = self.cfg["langs"]
if len(langs) == 0:
logging.warning("%s: No languages specified -> using default.", self.name)
self._parsers = [ parsedatetime.Calendar() ]
else:
self._parsers = [ parsedatetime.Calendar(parsedatetime.Constants(i, usePyICU=False)) for i in langs ]
for i in self.cfg["timers"]:
self._reminders.put(Reminder(*i))
self._restart_timer()
def testGermanNums(self):
self.ptc = pdt.Constants('de_DE', usePyICU=False)
self.cal = pdt.Calendar(self.ptc)
(self.yr, self.mth, self.dy, self.hr, self.mn, self.sec, self.wd,
self.yd, self.isdst) = time.localtime()
if self.ptc.localeID != 'de_DE':
raise unittest.SkipTest(
'Locale not set to de_DE - check if PyICU is installed')
self.assertExpectedResult(
self.cal.replaceNumber('funfundzwanzig september 2006'),
('25 september 2006'))
def testSpanishNums(self):
self.ptc = pdt.Constants('es', usePyICU=False)
self.cal = pdt.Calendar(self.ptc)
(self.yr, self.mth, self.dy, self.hr, self.mn, self.sec, self.wd,
self.yd, self.isdst) = time.localtime()
if self.ptc.localeID != 'es':
raise unittest.SkipTest(
'Locale not set to es - check if PyICU is installed')
self.assertExpectedResult(
self.cal.replaceNumber('veinticinco septiembre 2006'),
('25 septiembre 2006'))
def mda_small_business_calendar():
url = 'https://www.mda.mil/business/bus_calendar.html'
r = urllib.request.urlopen(url).read()
soup = BeautifulSoup(r, 'lxml')
events = []
for event in soup.find_all("h3", class_="collapse-me"):
events.append(event.text)
c = pdt.Constants()
p = pdt.Calendar(c)
event_dict = {}
for e in events:
dates, event_name = e.split('- ')[0], e.split('- ')[1]
event_dict[event_name.rstrip()] = dateparser.parse(dates.rstrip()), \
dates, url
return event_dict
def process_due_date(self, due_date_str, duration=15):
'''Parse date string and return start date/time in format used
by Google Calendar (RFC-3889).
'''
c = pdt.Constants()
c.BirthdayEpoch = 80
p = pdt.Calendar(c)
result = p.parse(due_date_str)
# Unpack the tuple and convert to string
start = datetime.datetime(*result[0][0:6])
end = start + datetime.timedelta(minutes=duration)
# Ignore seconds
start_str = start.strftime('%Y-%m-%dT%H:%M:00')
end_str = end.strftime('%Y-%m-%dT%H:%M:00')
return (start_str, end_str, result[1])
def remind_me(self, msg, args):
"""Takes a message of the form of '!remind me [when] -> [what]' and stores the reminder. Usage: !remind me <date/time> -> <thing>"""
if len(args) != 2:
return "Usage: !remind me <date/time> -> <thing>"
pdt = parsedatetime.Calendar(parsedatetime.Constants(
self.config['LOCALE'] if self.config else DEFAULT_LOCALE))
date_struct = pdt.parseDT(args[0])
if date_struct[1] != 0:
date = pytz.utc.localize(date_struct[0])
message = args[1]
nick = msg.frm.nick
target = str(msg.frm) if msg.is_direct else str(msg.to)
self.set_reminder(date, nick, message, target, msg.is_direct)
return self.respond_random()
else:
return "Your date seems malformed: {}".format(args[0])
def testSpanishNums(self):
self.ptc = pdt.Constants('es', usePyICU=False)
self.cal = pdt.Calendar(self.ptc)
(self.yr, self.mth, self.dy, self.hr, self.mn, self.sec, self.wd,
self.yd, self.isdst) = time.localtime()
if self.ptc.localeID != 'es':
raise unittest.SkipTest(
'Locale not set to es - check if PyICU is installed')
start = datetime.datetime(self.yr, self.mth, self.dy, self.hr, self.mn,
self.sec).timetuple()
target = datetime.datetime(self.yr, 9, 25, self.hr, self.mn,
self.sec).timetuple()
self.assertExpectedResult(
self.cal.parse('veinticinco de septiembre', start), (target, 1))
def hsv_chamber_calendar():
url = 'http://www.huntsvillealabamausa.com/index.php?option=com_content&view=article&id=190&Itemid=298'
r = urllib.request.urlopen(url).read()
soup = BeautifulSoup(r, 'lxml')
events = []
for event in soup.find_all("h4"):
events.append(event.text)
c = pdt.Constants()
p = pdt.Calendar(c)
event_dict = {}
for i in range(0, len(events), 2):
dates, event = events[i], events[i + 1]
event = event.replace('\nNEW!\r\n ', '')
event = event.replace('\nNEW! ', '')
event = event.replace('\r\n', '')
event_dict[event.rstrip()] = dateparser.parse(dates.rstrip()), \
dates, url
return event_dict
def __init__(self,
datetime_format=None,
timezone=None,
locale=None,
**kwargs):
super(DateTime, self).__init__(**kwargs)
self.datetime_format = datetime_format
self.timezone = timezone
self.locale = locale
now = datetime.datetime.now()
self._source_time = datetime.datetime(now.year, now.month, now.day, 0,
0, 0, 0, None)
self._constants = parsedatetime.Constants(localeID=self.locale)
self._parser = parsedatetime.Calendar(
constants=self._constants,
version=parsedatetime.VERSION_CONTEXT_STYLE)
def testGermanNums(self):
self.ptc = pdt.Constants('de_DE', usePyICU=False)
self.cal = pdt.Calendar(self.ptc)
(self.yr, self.mth, self.dy, self.hr, self.mn, self.sec, self.wd,
self.yd, self.isdst) = time.localtime()
if self.ptc.localeID != 'de_DE':
raise unittest.SkipTest(
'Locale not set to de_DE - check if PyICU is installed')
start = datetime.datetime(self.yr, self.mth, self.dy, self.hr, self.mn,
self.sec).timetuple()
target = datetime.datetime(self.yr, 9, 25, self.hr, self.mn,
self.sec).timetuple()
self.assertExpectedResult(
self.cal.parse('fünfundzwanzig September', start), (target, 1))
def parse_datetime(s, rel_to=None, use_utc=False):
import parsedatetime as pdt
us_ptc = pdt.Constants("en_US")
us_cal = pdt.Calendar(us_ptc)
native_cal = pdt.Calendar()
import datetime
import time
if s:
if rel_to is not None:
rel_to = datetime.datetime.fromtimestamp(rel_to).timetuple()
else:
rel_to = None
t_struct, parsed_as = us_cal.parse(s, rel_to)
if not parsed_as:
t_struct, parsed_as = us_cal.parse(s, None)
if not parsed_as:
t_struct, parsed_as = native_cal.parse(s, rel_to)
if not parsed_as:
t_struct, parsed_as = native_cal.parse(s, None)
if parsed_as:
t_struct = list(t_struct)
if parsed_as == 1:
# only parsed as date, eliminate time part
t_struct[3:6] = (0, 0, 0)
t_struct[8] = -1 # isdst -- we don't know if that is DST
if use_utc:
from calendar import timegm
return timegm(t_struct)
else:
return time.mktime(t_struct)
else:
raise ValueError("failed to parse date/time '%s'" % s)
else:
return None
