Пример #1
0
    def __get_start_time(self, generation):
        import pytz
        import math
        from dateutil.parser import parse as timeparse
        #  TODO: NEED TO CHECK ALL DATABASES TO ENSURE THAT THE TIME RANGE ARE GOOD
        start_datetime = self.configs['study']['start_datetime']
        start_timezone = self.configs['study']['timezone']

        # If start_datetime is a single time, set that as start time
        if isinstance(start_datetime, str):
            start_time = pytz.timezone(start_timezone).localize(
                timeparse(start_datetime))
            return int(start_time.timestamp())

        # If start_datetime is formatted as a time step with beginning and end, choose either of these as a start time
        # If sequential is set then the startime will
        if isinstance(start_datetime, (list, tuple)):
            if len(start_datetime) == 2:
                start_time_s = int(
                    pytz.timezone(start_timezone).localize(
                        timeparse(start_datetime[0])).timestamp())
                start_time_e = int(
                    pytz.timezone(start_timezone).localize(
                        timeparse(start_datetime[1])).timestamp())
                # This is the sequential startime code
                if 'start_datetime_sequence' in self.configs['study']:
                    if self.configs['study'][
                            'start_datetime_sequence'] == 'sequential':
                        interval = int(
                            (start_time_e - start_time_s) /
                            self.configs['study']['generations'] / 60) * 60
                        start_time = range(start_time_s, start_time_e,
                                           interval)[generation]
                        return start_time
                start_time = random.choice(
                    range(start_time_s, start_time_e, 60))
                return start_time
            else:
                if 'start_datetime_sequence' in self.configs['study']:
                    if self.configs['study'][
                            'start_datetime_sequence'] == 'sequential':
                        multiplier = math.ceil(
                            self.configs['study']['generations'] /
                            len(start_datetime))
                        start_time_readable = start_datetime * multiplier[
                            generation]
                        start_time = pytz.timezone(start_timezone).localize(
                            timeparse(start_time_readable))
                        return start_time
                start_time = pytz.timezone(start_timezone).localize(
                    timeparse(random.choice(start_datetime)))
                return int(start_time.timestamp())
Пример #2
0
    async def schedule_message(self, ctx, *args):
        args = bot_command_args(args)
        msg = args[1]

        if args[0].lower() == 'now':
            time = datetime.datetime.now() + datetime.timedelta(seconds=3)
        else:
            time = timeparse(args[0])
        if time < datetime.datetime.now():
            await ctx.send(config['error_messages']['schedule_past'])
            return False

        try:
            channel = try_get_channel_named(ctx.guild, args[2].lstrip('#'))
        except ValueError as e:
            await ctx.send(str(e))
            return False
        except UserWarning as e:
            await ctx.send(str(e))

        await store_scheduled_message(str(time), msg, ctx.guild.id, channel.id)
        await ctx.message.add_reaction('👍')
        await send_scheduled_message({
            'time': time,
            'msg': msg,
            'channel': channel
        })
        return True
Пример #3
0
	def meta(self):
		meta = yaml.safe_load(self._meta_yaml)
		if not meta:
			return {}
		assert isinstance(meta, dict)
		try:
			self.date = timeparse(meta['date'])
		except KeyError:
			self.date = datetime.fromtimestamp(os.path.getmtime(self.full_path))
		meta['date'] = self.date.strftime(gen.config['DATETIME'])
		try:
			meta['slug']
		except KeyError:
			rules = [
				('%title%', meta['title']),
				("%path%", self.path),
				("%year%", str(self.date.year)),
				("%month%", str(self.date.month)),
				("%day%", str(self.date.day)),
				("%hour%", str(self.date.hour)),
				("%minute%", str(self.date.minute)),
				(" ", "-")
			]
			slug = self._slug
			for (expression, replacement) in rules:
				slug = replace(slug, expression, replacement)
			meta['slug'] = lower(slug)
		try:
			meta['author']
		except KeyError:
			meta['author'] = gen.config['AUTHOR']
			
		return meta
def makeWeekinfo(schedules,starting_time,totalweeks):
    info_ls = []
    for i in range(0,totalweeks):
        restsched = []
        weekscheds = []
        week_ls = []
        cnt = 0
        cutpoint_back = starting_time+timedelta(days=7*(i+1))
        cutpoint_front = starting_time+timedelta(days=7*(i))
        print('cutpoint :',cutpoint_front,cutpoint_back)
        for sched in schedules: # 스케줄을 1주단위로 쪼개기
            if sched.period_start < cutpoint_back:
                weekscheds.append(sched)
                if sched.period_end >= cutpoint_back:
                    restsched.append(sched)
            else:
                restsched.append(sched)
        totalcnt = len(weekscheds)
        # print(totalcnt, weekscheds)
        while 1: # 스케줄을 row 배치순서로 넣기
            row_ls = []
            rests = []
            latest = timeparse("1970-01-01")
            recog = 0
            print('latest : ',latest)
            if totalcnt <= cnt : # 모든 스케줄을 다 소화했으면 break
                break
            for sched in weekscheds: # 1줄당 들어갈 스캐줄 비교
                temp = timeparse(sched.period_start.strftime('%Y-%m-%d'))
                if (temp >= latest):
                    if recog==0:
                        recog=1
                        nullsize = (timeparse(sched.period_start.strftime("%Y-%m-%d"))-cutpoint_front).days
                    else:
                        nullsize = (timeparse(sched.period_start.strftime("%Y-%m-%d"))-latest).days

                    row_ls.append([nullsize,sched])# 전 공백사이즈 삽입, #스케줄정보 삽입
                    latest = timeparse(sched.period_end.strftime('%Y-%m-%d')) + timedelta(days=1)
                    cnt += 1
                    print(cnt, end="")
                else :
                    rests.append(sched)# 남은 내용물 다시 배치
            week_ls.append(row_ls)
            weekscheds = rests
        info_ls.append(week_ls)
        schedules = restsched
    return info_ls
Пример #5
0
def interpret(json):
    if type(json) != dict:
        raise TypeError(
            'Expecting a dictionary representing a valid JSON object.')
    else:
        # let's do it
        form_internals = json['Form']
        form_entry = json['Entry']
        formId = form_internals['Id']
        # formID has ID 17 for RCRs
        formTimeStamp = form_entry['DateSubmitted']
        today = date.today()
        formDate = timeparse(formTimeStamp)
        # FD object holds a queryset of the formData objects on the date of the form, of that form id
        FD = FormData.objects.filter(date=formDate).filter(formID=formId)
        # RCR processing first
        if formId == '17':  # RCRs will also filter by staff name
            #send_to_server(json)
            # Uncomment the next line if you want a copy of the RCR data sent to dev accounts. NOT RECOMMENDED FOR PRODUCTION
            #notify_devs('info', 'RCR Form data recorded. Type is: "{}" and its data is: "{}".'.format(form_internals['Name'], str(json)))
            fname = json['StaffName']['First']
            lname = json['StaffName']['Last']
            try:
                staff = Employee.objects.filter(user__first_name=fname).get(
                    user__last_name=lname)
            except Employee.DoesNotExist:
                staff = Employee.objects.get(
                    user__username='******'
                )  # anonymous RCR, assign it to the django admin superuser account
            try:
                FD = FD.get(staff=staff)
                FD.qty += 1
                FD.save()
            except FormData.DoesNotExist:
                new = FormData.objects.create(formID=int(formId),
                                              formName=form_internals['Name'],
                                              date=date.today(),
                                              qty=1)
                new.staff = staff
                new.save()
        else:
            notify_devs(
                'warning',
                'Form data recorded: Type is: "{}" and its data is: "{}".'.
                format(form_internals['Name'], str(json)))
            try:
                data = FD[0]
                data.qty = data.qty + 1
                data.save()
            except IndexError:
                new = FormData.objects.create(formID=int(formId),
                                              formName=form_internals['Name'],
                                              date=date.today(),
                                              qty=1)
                new.save()
Пример #6
0
    def markLog(self, msg_content):
        """
        The !markLog command

        Give a section of the log a name so that it can be sent and manipulated
        later.
        """
        splits = msg_content.split()

        if len(splits) >= 3:
            max_time_row = self.log.execute(
                "SELECT MAX(date) FROM log;").fetchone()
            if not max_time_row:
                self.send("Nothing logged. Cannot mark.")
                return
            default = datetime.fromtimestamp(max_time_row[0])

            try:
                start_time = time.mktime(
                    timeparse(splits[1], default=default).timetuple())
            except ValueError:
                self.send("Incorrect date format. Cannot mark.")
                return
            try:
                end_time = time.mktime(
                    timeparse(splits[2], default=default).timetuple())
                subject = " ".join(splits[3:])
                self.set_mark(subject, start_time, end_time)
            except ValueError:
                #the end time we tried to parse was actually part of the subject
                end_time = max_time_row[0]
                subject = " ".join(splits[2:])
                self.set_mark(subject, start_time, end_time)
            except IndexError:
                #the subject we tried to get doesn't actually exist
                self.send("No subject specified. Cannot mark.")
        else:
            #give usage help
            self.send("usage: !markLog start_time [end_time] subject")
            self.send("end time defaults to last logged message")
            self.send("specify time like this: DD-MM-YYYY_HH:MM:SS")
            self.send("date defaults to date of last logged message")
Пример #7
0
    def _update_status_full(self):
        headers = {"X-Api-Token": self._token}
        url = urljoin(self._url, "table/%d" % self._table_id)
        r = requests.get(url, headers=headers)

        self._status = json.loads(r.content)
        self._name = self._status['Name']
        self._dataset = self._status['Dataset']
        self._last_ok_run = timeparse(self._status["LastOkRunEndAt"])

        return self._status
def cal_week(start_date, how_many):
    # user = User.query.filter_by(username=username).first_or_404()
    # print(type(start_date))
    # schedules = current_user.schedules.order_by(Schedule.period_start.desc())
    if int(how_many) > 0:
        start_datetime = timeparse(start_date)+timedelta(days=1)
        how_many = int(how_many)
    else :
        start_datetime = timeparse(start_date)-timedelta(days=14)
        how_many = -int(how_many)
    starting_time = timeparse(start_datetime.strftime('%Y-%m-%d'))
    ending_time = (starting_time+timedelta(days=how_many*7))
    schedules = current_user.schedules.filter(and_(Schedule.period_end >= starting_time,
                                                    Schedule.period_start <= ending_time)).order_by(Schedule.period_start.asc())
    cal_print = [[starting_time+timedelta(days=date+wk*7) for date in range(0,7)]for wk in range(0,how_many)]
    time_now = datetime.utcnow()+timedelta(hours=9) #한국시간 기준(UTC보다 9시간 빠름)
    weekschedule_info = makeWeekinfo(schedules,starting_time,how_many)

    return render_template('cal_schedule.html', schedules = weekschedule_info, # schedules,
                                cal_print=cal_print, time_now = time_now)
Пример #9
0
def stored_strings_to_objects(stored):
    future_messages = []
    for message in stored:
        parsed = timeparse(message['iso_time'])
        channel = bot.get_guild(message['guild_id']).get_channel(
            message['channel_id'])
        future_messages.append({
            'time': parsed,
            'msg': message['msg'],
            'channel': channel
        })
    return future_messages
Пример #10
0
    def _update_status_short(self):
        headers = {"X-Api-Token": self._token}
        url = urljoin(self._url, "table/%d/status" % self._table_id)
        r = requests.get(url, headers=headers)

        status = json.loads(r.content)
        if status["Error"]:
            raise Exception(status["Error"])
        self._last_ok_run = timeparse(status["LastOkRunEndAt"])
        self._status["Running"] = status["Status"] == "running"

        return self._status
Пример #11
0
    def get_start_time(self):
        metadata = self.__get_metadata(self.__generation)
        if metadata:
            return metadata['start_timestamp']

        import pytz
        from dateutil.parser import parse as timeparse
        tz_str = self.__config['study']['timezone']
        dt_str = self.__config['study']['start_datetime']

        start_time = pytz.timezone(tz_str).localize(timeparse(dt_str))
        return int(start_time.timestamp())
Пример #12
0
def schedule_rawtext_parser(text):
    temp = text.split("\n",2)
    if temp[0].find('~')!=-1:
        due = 1
        dates = temp[0].split('~')
        ndates = []
        for date in dates:
            try:#                 parse라는 말이 다용도라서.. timeparse로 변경하여 사용
                ndates.append(timeparse(date.strip()).strftime("%Y-%m-%d %H:%M"))
            except:
                ndates.append(ndates[0])
        confirm_time_reverse = (timeparse(ndates[1])-timeparse(ndates[0])).days
        if confirm_time_reverse < 0:
            ndates[1] = (timeparse(ndates[1]) + timedelta(days=-confirm_time_reverse)).strftime("%Y-%m-%d %H:%M")
    else:
        due = 0
        ndates = []
        # 일부러 두번넣는다.
        ndates.append(timeparse(temp[0].strip()).strftime("%Y-%m-%d %H:%M"))
        ndates.append(str(ndates[0]))

    return ndates, temp
Пример #13
0
    def markLog(self, msg_content):
        """
        The !markLog command

        Give a section of the log a name so that it can be sent and manipulated
        later.
        """
        splits = msg_content.split()

        if len(splits) >= 3:
            max_time_row = self.log.execute("SELECT MAX(date) FROM log;").fetchone()
            if not max_time_row:
                self.send("Nothing logged. Cannot mark.")
                return
            default = datetime.fromtimestamp(max_time_row[0])

            try:
                start_time = time.mktime(timeparse(splits[1], default=default).timetuple())
            except ValueError:
                self.send("Incorrect date format. Cannot mark.")
                return
            try:
                end_time = time.mktime(timeparse(splits[2], default=default).timetuple())
                subject = " ".join(splits[3:])
                self.set_mark(subject, start_time, end_time)
            except ValueError:
                #the end time we tried to parse was actually part of the subject
                end_time = max_time_row[0]
                subject = " ".join(splits[2:])
                self.set_mark(subject, start_time, end_time)
            except IndexError:
                #the subject we tried to get doesn't actually exist
                self.send("No subject specified. Cannot mark.")
        else:
            #give usage help
            self.send("usage: !markLog start_time [end_time] subject")
            self.send("end time defaults to last logged message")
            self.send("specify time like this: DD-MM-YYYY_HH:MM:SS")
            self.send("date defaults to date of last logged message")
Пример #14
0
def req_meta(url, **kwargs):
    html = req_html(url, **kwargs)
    if not html:
        return html
    try:
        htmld = pq(html)
        meta = {}

        meta['url'] = url

        meta['title'] = htmld('.postTitle2').text()
        meta['content'] = htmld('#cnblogs_post_body').text()

        date = htmld('#post-date').text().strip()

        if date == '':
            sk = html.find('cb_entryCreatedDate=\'')
            if sk > -1:
                sk = sk + 21
                ek = html.find('\'', sk)
                date = html[sk:ek]
        meta['posttime'] = timeparse(date)

        title = htmld('title').text().strip()
        if title == '':
            title = htmld.xhtml_to_html()('title').text().strip()
        meta['nick'] = title.split('-')[-2].strip()

        parts = url[:-5].split('/')
        u = parts[3]
        postid = parts[-1]

        meta['username'] = u

        view = req_html(
            'http://www.cnblogs.com/mvc/blog/ViewCountCommentCout.aspx?postId='
            + postid)
        meta['view'] = int(view or 0)
        comment = req_html('http://www.cnblogs.com/mvc/blog/GetComments.aspx?postId='+postid+\
                            '&blogApp='+u+\
                            '&pageIndex=0&anchorCommentId=0&_=1471419238926')

        #meta['comment'] = json.loads(comment)['commentCount'] if comment else 0
        meta['comment'] = int(comment[16:comment.find(',')]) if comment else 0

        return meta
    except Exception as e:
        print(e, url)
        return False
Пример #15
0
 async def show_until(self, ctx, until):
     until_time = timeparse(until)
     now_time = datetime.datetime.now()
     with open(config['scheduled_message_store'], 'r') as f:
         stored = stored_strings_to_objects(json.load(f)['messages'])
     to_show = sorted(list_group(filter(
         lambda x: now_time < x['time'] <= until_time, stored),
                                 key=lambda x: x['time']),
                      key=lambda x: x[0])
     for time, messages in to_show:
         text = ['at {}\n'.format(time)]
         for message in messages:
             text.append('{0[channel].mention}: {0[msg]}\n'.format(message))
         await ctx.send(''.join(text),
                        allowed_mentions=discord.AllowedMentions.none())
Пример #16
0
def calendar():
    form = ScheduleForm()
    time_now = timeparse((datetime.utcnow()+timedelta(hours=9)).strftime('%Y-%m-%d')) #한국시간 기준(UTC보다 9시간 빠름)
    monday_delta = time_now.isocalendar()[2] % 7 # 일요일 기준으로 다시 맞춤
    cal_print = [[time_now + timedelta(days=date+wk*7-monday_delta) for date in range(0,7)]for wk in range(-1,3)]
    starting_time = time_now + timedelta(days=-1*7-monday_delta)
    ending_time = time_now + timedelta(days=3*7-monday_delta)
    schedules = current_user.schedules.filter(and_(Schedule.period_end >= starting_time,
                                                    Schedule.period_start <= ending_time)).order_by(Schedule.period_start.asc())
    # print(starting_time,monday_delta)
    # 함수화된 일정순서 전처리 함수
    weekschedule_info = makeWeekinfo(schedules,starting_time,4)


    return render_template('calendar.html', title="bright`s home", schedules = weekschedule_info,#schedules, weekschedule=weekschedule_info,
                            cal_print=cal_print, time_now=time_now , form=form)
Пример #17
0
def _parse_feature(gml: Any) -> Dict[str, Any]:
    coords = _gml_find(gml, "gml:pos")
    lat, lon = coords.strip().split(" ")

    prop = _gml_find(gml, "BsWfs:ParameterName")
    value = _gml_find(gml, "BsWfs:ParameterValue")
    time_prop = _gml_find(gml, "BsWfs:Time")

    unix_timestamp = int(timeparse(time_prop).timestamp())

    return {
        "property": prop,
        "value": value,
        "timestamp": unix_timestamp,
        "lat": lat,
        "lon": lon,
    }
Пример #18
0
def timestr_to_timestamp(time_string: str, timezone: str):
    timestamp = pytz.timezone(timezone).localize(timeparse(time_string))
    return int(timestamp.timestamp())