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