Example #1
0
def admin_login_model(email, password):
    result = {}
    conn = ToMongo()
    admin = conn.get_col('admin').find_one({'email': email, 'is_effective': 1})
    if admin:
        # 用户名正确
        if admin['sign_count'] >= 5 and get_now() - admin['last_signIn_time'] < FROZEN_TIME:
            result['error'] = '请 {}秒 后再重试'.format(FROZEN_TIME - (get_now() - admin['last_signIn_time']))
            conn.close_conn()
            return result
        else:
            if check_password_hash(admin['password'], password):  # 成功
                conn.update('admin',
                            {'email': admin.get('email')},
                            {'$set': {'sign_count': 0, 'last_signIn_time': get_now()}})
                result['admin'] = admin
                conn.close_conn()
                return result
            else:  # 失败
                conn.update('admin',
                            {'email': admin.get('email')},
                            {'$inc': {'sign_count': 1}})
                conn.update('admin',
                            {'email': admin.get('email')},
                            {'$set': {'last_signIn_time': get_now()}})
                error = '邮箱地址或密码错误!剩余 {} 次'.format(5 - (admin['sign_count'] + 1))
                result['error'] = error
                conn.close_conn()
                return result
    else:  # 用户名错误
        result['error'] = '邮箱地址或密码错误!'
        conn.close_conn()
        return result
Example #2
0
 def reset(self):
     self.ship = Spaceship(scale=.3, speed=0.06, rotationspeed=10)
     self.asteroids = []
     self.bullets = []
     self.frame = np.zeros((config.SCREEN_HEIGHT, config.SCREEN_WIDTH, 3), dtype="uint8")
     self.last_astroid = utils.get_now()
     self.now = utils.get_now()
     self.score = 0
     self.stars = []
     self.add_stars()
Example #3
0
def create_next_lesson_message(
    current_schedule: DAY_SCHEDULE,
    current_timedelta: datetime.timedelta,
    current_lesson: Optional[LESSON],
    all_schedule: WEEK_SCHEDULE,
    days: DAYS,
):
    schedule_date_str = days[all_schedule.index(current_schedule)].split(".")
    schedule_day = int(schedule_date_str[0])
    schedule_month = int(schedule_date_str[1])
    schedule_year = int(schedule_date_str[2].split("-")[0])
    now = get_now()
    for lesson in current_schedule:
        start_datetime, end_datetime = get_start_end_datetime(
            lesson,
            schedule_month=schedule_month,
            schedule_day=schedule_day,
            schedule_year=schedule_year,
        )
        start_timedelta, end_timedelta = get_start_end_timedelta(lesson)
        if (current_lesson is not None and current_schedule.index(lesson) <=
                current_schedule.index(current_lesson)) or (
                    end_timedelta < current_timedelta
                    and schedule_day == now.day):
            continue

        # TODO: start_datetime почему то +2:30

        next_lesson_time = (start_datetime - now -
                            datetime.timedelta(minutes=30))  # 1 day, 15:53:00
        print(start_datetime)
        print(now)
        days_left = re.findall(r"[-]?(\d+) day[s]?,", str(next_lesson_time))

        next_lesson_time_list = list(
            map(int,
                str(next_lesson_time).split()[-1].split(".")[0].split(":")))
        hour_word = create_word_for_hour(next_lesson_time_list[0])
        minute_word = create_word_for_minute(next_lesson_time_list[1])
        next_lesson_text = create_text_schedule_for_one_lesson(lesson)

        day = 0
        if days_left:
            day = int(days_left[0])

        if day >= 1:
            day_word = create_word_for_day(day)
            message = (
                f"Следующая пара через {day} {day_word} {next_lesson_time_list[0]}"
                f" {hour_word} {next_lesson_time_list[1]} {minute_word}:\n\n{next_lesson_text}"
            )
        elif next_lesson_time_list[0] > 0:
            message = (
                f"Следующая пара через {next_lesson_time_list[0]}"
                f" {hour_word} {next_lesson_time_list[1]} {minute_word}:\n\n{next_lesson_text}"
            )
        else:
            message = f"Следующая пара через {next_lesson_time_list[1]} {minute_word}:\n\n{next_lesson_text}"
        return message
    return None
Example #4
0
def to_collection_model(user_id, book_id, is_clear=False):
    """添加、取消收藏"""
    conn = ToMongo()
    if is_clear:
        result = False
        query = {'_id': str(user_id), 'book_ids.book_id': {'$in': [book_id]}}
        ret = conn.update('favorites', query,
                          {'$pull': {
                              'book_ids': {
                                  'book_id': book_id
                              }
                          }})
        if ret.modified_count:
            result = True
    else:
        result = False
        query = {'_id': str(user_id), 'book_ids.book_id': {'$nin': [book_id]}}
        ret = conn.update('favorites', query, {
            '$push': {
                'book_ids': {
                    'book_id': book_id,
                    'create_time': get_now()
                }
            }
        })
        if ret.modified_count:
            result = True
    conn.close_conn()
    return result
Example #5
0
 def unsubscribe(self, user, conn=None, needs_auth=True, force_auth=False):
     if user not in self.subscribers:
         return
     if needs_auth and (self.moderated or self.moderated_unsubscribe):
         form = { 'channel_name': self.name, "user": user.get_name() }
         try:
             success, options = self.server.http_request('unsubscribe', user.get_cookie(conn), form, conn=conn)
         except ExpectedException:
             if not force_auth:
                 raise
             success, options = False, {}
         if not (success or force_auth):
             raise ExpectedException(options.get('error', 'Unauthorized'))
         self.server.maybe_auto_subscribe(user, options, conn=conn)
     frame = {"channel_name": self.name, "user": user.get_name(), 'datetime': get_now()}
     self.server.admin.channel_event('unsubscribe', self.name, frame)
     if self.presenceful:
         for subscriber in self.subscribers:
             if subscriber == user: continue
             subscriber.send_frame('UNSUBSCRIBE', frame)
     user.send_frame('UNSUBSCRIBE', frame)
     self.subscribers.remove(user)
     user.channel_unsubscribed(self)
     if self.history_size:
         del frame['channel_name']
         self.history.append(('UNSUBSCRIBE', frame))
         self.prune_history()
     
     if not self.subscribers:
         self.server.destroy_channel(self.name)
Example #6
0
async def get_current_schedule_for_which_and_next() -> Optional[DAY_SCHEDULE]:
    schedule, days = await get_schedule_and_days()
    now = get_now()

    current_schedule = correct_schedule(days=days,
                                        schedule=schedule,
                                        today=now.day)

    # типа если сейчас уже все пары прошли то будет сегодняшние показывать без этого ужаса

    if (current_schedule is not None
            and int(current_schedule[-1]["time"].split(":")[0]) < now.hour):
        # хз нужно ли это, в воскр все падает в штуку ниже и сюда не попадает тк в current_schedule None
        if now.isoweekday() + 1 == 6:
            current_schedule = correct_schedule(days=days,
                                                schedule=schedule,
                                                today=now.day + 3)
        elif now.isoweekday() + 1 == 7:
            current_schedule = correct_schedule(days=days,
                                                schedule=schedule,
                                                today=now.day + 2)
        else:
            current_schedule = correct_schedule(days=days,
                                                schedule=schedule,
                                                today=now.day + 1)

    # вдруг там нет пар или еще что, короче на всякий
    i = 1
    while current_schedule is None:
        current_schedule = correct_schedule(days=days,
                                            schedule=schedule,
                                            today=now.day + i)
        i += 1

    return current_schedule
Example #7
0
    def publish(self, user, payload, needs_auth=True, conn=None, **kwargs):
        try:
            encoded_payload = json.loads(payload)
        except:
            raise ExpectedException("Invalid json for payload")
        payload = encoded_payload
        if needs_auth and (self.moderated or self.moderated_publish):
            form = { 'channel_name': self.name, 'payload': json.dumps(encoded_payload) }
            success, options = self.server.http_request('publish', user.get_cookie(conn), form, conn=conn)
            self.server.maybe_auto_subscribe(user, options, conn=conn)
            if not success:
                raise ExpectedException(options.get('error', 'Unauthorized'))
            payload = options.get('override_payload', payload)

        frame = {"channel_name": self.name, "payload":payload, "datetime": get_now()}

        if not self.anonymous:
            if 'originator' in kwargs:
                frame['user'] = kwargs['originator']
            else:
                frame['user'] = user.get_name()

        omit = None
        if not self.reflective:
            omit = conn
        for subscriber in self.subscribers:
            subscriber.send_frame('PUBLISH', frame, omit=omit)
        self.server.admin.channel_event('publish', self.name, frame)
        if self.history_size:
            del frame['channel_name']
            self.history.append(('PUBLISH', frame))
            self.prune_history()
 def __init__(self, x, y, angle, vx, vy):
     vx += config.bullet_speed * math.cos(math.radians(angle))
     vy += config.bullet_speed * math.sin(math.radians(angle))
     self.creation = utils.get_now()
     super().__init__(x,
                      y,
                      vx,
                      vy,
                      img=255 * np.ones((3, 3, 3), dtype="uint8"))
Example #9
0
async def send_go(event: SimpleBotEvent):
    now = get_now()
    if is_weekend(now):
        return "В выходные поучиться захотелось?"

    percent = create_percent(user_id=event.object.object.message.from_id,
                             now=now)

    await event.answer(f"Идти на пары стоит с вероятностью {percent}%")
Example #10
0
def evaluate_model(user_id, user_name, request, book_ids):
    """用户评论模型"""
    rlt = {}
    order_no = request.get('order_no')
    star = int(request.get('star'))
    context = request.get('context')
    anonymous = request.get('anonymous')
    if not star:
        rlt['error'] = '评分不能为空'
        return rlt
    img_path = ''
    create_time = get_now()
    if anonymous:
        user_name = user_name[0] + '**'
    else:
        user_name = user_name[0] + '*' + user_name[-1]
    id_list = []
    mydb = ToMongo()
    for book_id in book_ids:
        value = {'$addToSet':
                     {'comment':
                          {'order_no': order_no,
                           'star': star,
                           'context': context,
                           'user_id': user_id,
                           'user_name': user_name,
                           'img_path': img_path,
                           'create_time': create_time
                           }
                      }
                 }
        result = mydb.update('evaluate', {'_id': ObjectId(book_id)}, value)
        if result.modified_count:
            id_list.append(result.modified_count)
        else:
            # 无评论时,直接插入
            rel = mydb.insert('evaluate',
                              {'_id': ObjectId(book_id),
                               'comment':
                                   [
                                       {'order_no': order_no,
                                        'star': star,
                                        'context': context,
                                        'user_id': user_id,
                                        'user_name': user_name,
                                        'img_path': img_path,
                                        'create_time': create_time
                                        }
                                   ]
                               })
            id_list.append(rel.inserted_id)
        # print(id_list)
    if len(id_list) != len(book_ids):
        # print(id_list)
        rlt['error'] = '评论失败,请重试!'
    mydb.close_conn()
    return rlt
Example #11
0
    def get_all_operations(self, broker_account_started_at: datetime) \
                -> List[tinvest.schemas.Operation]:
        """Возвращает все операции в портфеле с указанной даты"""
        from_ = localize(broker_account_started_at)
        now = get_now()

        operations = (self._client.\
            get_operations(broker_account_id=self._broker_account_id, from_=from_, to=now)\
            .payload.operations)
        return operations
Example #12
0
def docs_python_jp(request):
    mak_lookup = TemplateLookup(directories=["templates/"])
    template = mak_lookup.get_template('docs_python_jp.mak')
    word = get_request_value(request, 'word')
    now=get_now()
    result = template.render_unicode(
            now=now,
            word=urllib.quote(word)
        )
    return Response(result)
Example #13
0
async def tomorrow(event: SimpleBotEvent):
    now = get_now()
    tomorrow_date = now + datetime.timedelta(days=1)
    if is_weekend(tomorrow_date):
        return "завтра выходной, хд"

    await event.answer(
        await create_one_day_schedule(tomorrow_date, tomorrow=True),
        dont_parse_links=True,
    )
    def get_all_operations(self, from_in: datetime = OPERATIONS_FROM) \
                -> List[tinvest.schemas.Operation]:
        """Возвращает все операции в портфеле 'с' и 'по' указанные даты"""
        #from_ = localize(from_in)
        from_ = from_in
        now = get_now()

        operations = self._client.get_operations(broker_account_id=self._account_id, from_=from_, to=now)\
            .payload.operations
        return operations
Example #15
0
def edit_reporte():
    form = request.form
    reporte = db.session.merge(models.get_reporte_by_id(int(form['id'])))
    reporte.area = form['area']
    reporte.state = form['estado']
    reporte.problema = form['problema']
    reporte.localizacion_breve = form['localizacion']
    reporte.details = form['details']
    reporte.date_changed = utils.get_now()
    db.session.commit()
    return redirect(url_for('show_reportes'))
Example #16
0
    def __init__(self, args):
        self.log_cmd = args.log_cmd
        log_name = get_dirname_from_args(args)
        log_name += '_{}'.format(get_now())
        self.log_path = args.log_path / log_name
        # os.makedirs(self.log_path, exist_ok=True)
        self.log_path.mkdir(parents=True, exist_ok=True)
        self.tfboard = SummaryWriter(self.log_path)

        self.url = run_tensorboard(self.log_path)
        print("Running Tensorboard at {}".format(self.url))
Example #17
0
    def create(self, user_id, token, platform=0):
        now = get_now()
        expire_time = get_delay_time(now, self.EXPIRE_TIME)

        self.db.execute('INSERT INTO %s (token, createtime, user_id, platform, \
                        expiretime) values(%s, "%s", %s, %s, %s)' % (token, 
                                                                     datetime_to_str(now),
                                                                     user_id,
                                                                     platform,
                                                                     datetime_to_str(expire_time)
                                                                     ))
Example #18
0
 def parse_content(self, response):  # 爬取每一章节的内容
     url_cahracter = response.request.url.split("/")[-1].replace(
         ".html", "")
     content_file = "files/archives/content/daomubiji_content_{ct}_{dt}.html".format(
         ct=url_cahracter, dt=get_now(tab=False))
     print >> open(content_file, "w"), content_file
     selector = Selector(response)
     chapter_content = selector.xpath(
         '//article[@class="article-content"]/p/text()').extract()
     item = response.meta['item']
     item['content'] = '\n'.join(chapter_content)
     yield item
    def generate_csv(self):
        outputfilename = [
            "/Fund_Prices_", "/Returns_", "/PerformanceMetrics_",
            "/Target_Weights_", "/Effective_Weights_", "/Portfolio_Drawdown_",
            "/Asset_Prices_", "/Assets_drawdown_"
        ]

        # Output into CSV
        for i in range(0,
                       len(self.InputList) -
                       1):  # -1 is to exclude the parameters output
            self.InputList[i].to_csv(self.outputdir + outputfilename[i] +
                                     get_now().replace(':', '') + '.csv')
Example #20
0
def admin_register(email, password, auth_list):
    user = {
        'email': email,
        'password': generate_password_hash(password),
        'is_effective': 1,
        'last_signIn_time': 0,
        'create_time': get_now(),
        'sign_count': 0,
        'auth': auth_list
    }
    my_db = ToMongo()
    result = my_db.insert('admin', user)
    return result.inserted_id
Example #21
0
    def __init__(self, args):
        # also show log in commandline?
        self.log_cmd = args.log_cmd

        log_name = get_dirname_from_args(args)
        log_name += '_{}'.format(get_now())

        self.log_path = args.log_path / log_name
        self.log_path.mkdir(parents=True, exist_ok=True)

        # also show tensorboard
        self.tfboard = SummaryWriter(self.log_path)
        self.url = run_tensorboard(self.log_path)
        print("Running Tensorboard at {}".format(self.url))
Example #22
0
def execute(request):
    mak_lookup = TemplateLookup(directories=["templates/"])
    template = mak_lookup.get_template('execute.mak')
    command = get_request_value(request, 'command')
    if is_allowed_ip(request.remote_addr) == False:
        command = "echo 'not allowed at your IP address(%s).'" % request.remote_addr
    now=get_now()
    print now,
    command_result = run(command)
    result = template.render_unicode(
            now=now,
            command_result=command_result
        )
    return Response(result)
Example #23
0
 def get_header_data(self):
     """ Return dict with data for report header
     """
     header = {
         'strategy_name': self.get_strategy_name(),
         'params': self.get_strategy_params(),
         'file_name': self.infilename,
         'start_date': self.get_start_date(),
         'end_date': self.get_end_date(),
         'name_user': self.user,
         'processing_date': get_now(),
         'memo_field': self.memo
     }
     return header
Example #24
0
def format_query(user_id, status):
    """格式化获取订单查询语句"""
    query = {
        'user_id': user_id,
        'is_effective': 1,
        'orders_status': {
            '$in': status
        },
    }
    if len(status) < 2 and status[0] == 0:
        query.update(
            {'create_time': {
                '$gt': get_now() - ORDER_EFFECTIVE_TIME
            }})
    return query
Example #25
0
class ShortURL(Model):
    """
    A DynamoDB VideoWatch
    """
    class Meta:
        """
        set meta of table
        """
        table_name = create_table_name("el-chapo-short-url-store")
        region = AWS_REGION

    url = UnicodeAttribute(hash_key=True, null=False)
    redirection_url = UnicodeAttribute(null=False)
    webhook = UnicodeAttribute(null=True)
    created_at = UTCDateTimeAttribute(default=get_now())
    def get_header_data(self):
        """ Return dict with data for report header
        """
        header = {
            'strategy_names': self.get_strategy_names(),
            'params': self.get_strategy_params(),
            'start_date': self.get_start_date(),
            'end_date': self.get_end_date(),
            'name_user': self.user,
            'processing_date': get_now(),
            'memo_field': self.memo,
            'leverage': self.leverage,
            'report_params': self.get_report_params()
        }

        return header
Example #27
0
    def published_articles(cls, queryset=None):
        """Return a queryset will all published articles.

        Parameters
        ----------
        queryset : QuerySet | None
            If provided, this queryset will be filtered to include only
            published articles.
            If None, all Article will be filtered.
        """
        now = get_now()
        filter_future = Q(publication_date__lte=now)
        filter_expired = (Q(expiration_date__isnull=True)
                          | Q(expiration_date__gt=now))
        if queryset is None:
            queryset = cls.objects
        return queryset.filter(filter_future, filter_expired)
Example #28
0
    def parse_title(self, response):  # 提取子网页信息
        # Save raw data to Archive
        url_cahracter = response.request.url.split("/")[-1]
        chapter_file = "files/archives/chapter_index/daomuji_chapter_index_{ct}_{dt}.html".format(
            ct=url_cahracter, dt=get_now(tab=False))
        print >> open(chapter_file, "w"), response.body

        selector = Selector(response)

        book_order_name = selector.xpath('//h1/text()').extract()[0]
        pos = book_order_name.find(u':')
        book_order = book_order_name[:pos]  # 获取书编号
        book_name = book_order_name[pos + 1:]  # 获取书名

        chapter_list = selector.xpath(
            '//article[@class="excerpt excerpt-c3"]//text()').extract()
        chapter_link = selector.xpath(
            '//article[@class="excerpt excerpt-c3"]/a/@href').extract()
        chapter_link_flag = 0  # 链接序号
        for each in chapter_list:
            pos_first = each.find(' ')
            pos_last = each.rfind(' ')
            # chapter_first = ''
            chapter_mid = ''
            # chapter_last = ''
            if pos_first != pos_last:
                chapter_first = each[:pos_first]
                chapter_mid = each[(pos_first + 1):pos_last]
                chapter_last = each[pos_last + 1:]
            else:
                chapter_first = each[:pos_first]
                chapter_last = each[pos_last + 1:]

            # 存储信息
            item = DaomubijiItem()
            item['bookOrder'] = book_order
            item['bookName'] = book_name
            item['chapterFirst'] = chapter_first
            item['chapterMid'] = chapter_mid
            item['chapterLast'] = chapter_last
            yield Request(chapter_link[chapter_link_flag],
                          callback='parse_content',
                          meta={'item': item})
            chapter_link_flag += 1
Example #29
0
def update_status_to_5():
    """将过期订单,状态更新为失效"""
    mydb = ToMongo()
    query = {
        'orders_status': 0,
        'create_time': {
            '$lt': get_now() - ORDER_EFFECTIVE_TIME
        },
    }
    # 恢复库存
    orders = mydb.get_col('order').find(query)
    for order in orders:
        order_no = order.get('order_no')
        query = {'order_no': order_no}
        restore_stock(query, mydb)
    # 更新订单状态
    new = {'$set': {'orders_status': 5}}
    result = mydb.update('order', query, new, is_one=False)
    mydb.close_conn()
    return result.modified_count
Example #30
0
    def parse(self, response):  # 程序从这个函数开始执行
        book_file = "files/archives/daomubiji_book_index_{dt}.html".format(
            dt=get_now(tab=False))
        print >> open(book_file, "w"), response.body
        selector = Selector(response)
        book_filed = selector.xpath('//article/div')
        # 抓取书标题: <div class="homebook">
        book_link = selector.xpath('//article/p/a/@href').extract()
        # 抓取盗墓笔记每本书的链接: <p><a href="http://www.daomubiji.com/dao-mu-bi-ji-1"></p>
        # '//article/p/a/@href'也可以写成('//article//@href')

        link_flag = 0
        for each in book_filed:
            book_name_title = each.xpath('h2/text()').extract()[0]
            pos = book_name_title.find(u':')  # like 盗墓笔记1:七星鲁王宫
            if pos == -1:  # 只抓取符合我们格式规定的书
                continue
            yield Request(book_link[link_flag],
                          callback='parse_title')  # 调用parse_title函数
            link_flag += 1  # next page
Example #31
0
def handle_sms(text):
    now = get_now()

    try:
        try:
            minutes = parse_minutes(text)

            add_auto_buzz_time(now, now + timedelta(minutes=minutes))
            set_auto_buzz_config(minutes)
            message = f'Door will be open for the next {minutes} minutes'

        except NotANumberException:
            start, end = parse_start_end_times(text, now)

            add_auto_buzz_time(start, end)
            message = f'Door will be open between {format_time(start)} and {format_time(end)}'

    except BuzzerException as ex:
        message = str(ex)

    return message
async def next_lesson(event: SimpleBotEvent):
    schedule, days = await get_schedule_and_days()
    now = get_now()
    current_schedule = await get_current_schedule_for_which_and_next()

    if current_schedule is None:
        return "некст пара не обнаружена))"
    current_timedelta = get_current_timedelta()
    current_lesson = get_current_lesson(current_schedule)

    message = create_next_lesson_message(
        current_schedule=current_schedule,
        current_timedelta=current_timedelta,
        current_lesson=current_lesson,
        days=days,
        all_schedule=schedule,
    )
    if message is None:
        # сейчас последняя пара, делаем на день вперед
        current_schedule = correct_schedule(
            days=days, schedule=schedule, today=now.day + 1
        )
        i = 1
        while current_schedule is None:
            current_schedule = correct_schedule(
                days=days, schedule=schedule, today=now.day + i
            )
            i += 1
        message = create_next_lesson_message(
            current_schedule=current_schedule,
            current_timedelta=current_timedelta,
            current_lesson=current_lesson,
            days=days,
            all_schedule=schedule,
        )

    return await event.answer(
        message=message,
        dont_parse_links=True,
    )
Example #33
0
    def subscribe(self, user, conn=None, needs_auth=True):

        if user in self.subscribers:
            return

        has_initial_data = False
        initial_data = None
        
        if needs_auth and (self.moderated or self.moderated_subscribe):
            form = { 'channel_name': self.name, "user": user.get_name() }
            success, options = self.server.http_request('subscribe', user.get_cookie(conn), form, conn=conn)
            if not success:
                raise ExpectedException(options.get('error', 'Unauthorized'))
            if 'initial_data' in options:
                has_initial_data = True
                initial_data = options['initial_data']
            self.server.maybe_auto_subscribe(user, options, conn=conn)
            
        if has_initial_data or self.history:
            frame = dict(channel_name=self.name, history=self.history, initial_data=initial_data)
            user.send_frame('CHANNEL_INIT', frame)

        self.subscribers.append(user)
        user.channel_subscribed(self)
        _now = get_now()
        frame = {"channel_name": self.name, "user": user.get_name(), "datetime": _now}
        self.server.admin.channel_event('subscribe', self.name, frame)
        if self.presenceful:
            for subscriber in self.subscribers:
                if subscriber == user: continue
                subscriber.send_frame('SUBSCRIBE', frame)
                
        frame = self._build_subscribe_frame(user, initial_data)
        
        user.send_frame('SUBSCRIBE', frame)
            
        if self.history_size:
            self.history.append(('SUBSCRIBE', {"user": user.get_name(), "datetime": _now }))
            self.prune_history()
Example #34
0
def vote():
    if request.method == 'GET':
        return render_template('index.html')
    elif request.method == 'POST':
        render = partial(render_template, 'index.html')

        uvc = request.form.get('uvc')

        if not uvc:
            return render(error='You didn\'t enter a UVC')

        if len(uvc) < 16:
            return render(error='Your UVC should be 16 characters long')

        uvc = uvc.upper()

        pcv = PollCollectionVote.query.filter(
            PollCollectionVote.uvc == uvc).first()

        if not pcv:
            return render(error='The UVC you entered does not exist')

        if pcv.cast:
            return render(error='You have already cast your vote')

        pc = PollCollection.query.get(pcv.collection_id)

        # Check that the poll is currently open
        now = get_now()
        if now < pc.start:
            return render(error='Voting for this poll has not started yet')
        elif pc.end < now:
            return render(error='Voting for this poll has closed')

        ps = pc.polls
        for p in ps:
            p.shuffle_candidates()

        return render_template('vote.html', uvc=uvc, pc=pc)
Example #35
0
    def step(self, action):
        reward = 0.0
        done = False
        if action == 32:
            self.bullets += self.ship.shoot()
        if config.DRAW:
            self.frame.fill(0)
            self.draw_stars()
        self.ship.tick(action, self.frame)
        for asteroid in self.asteroids:
            self.frame = asteroid.tick(self.frame)
            if self.ship.check_crash(asteroid):
                done = True
            for bullet in self.bullets:
                if bullet.check_crash(asteroid):
                    self.score += 1
                    reward += 1.
                    self.bullets.remove(bullet)
                    self.asteroids.remove(asteroid)
                    new_asteroids = asteroid.split()
                    self.asteroids += new_asteroids
        for bullet in self.bullets:
            self.frame = bullet.tick(self.frame)
            if bullet.remove():
                self.bullets.remove(bullet)
        if config.RENDER:
            cv2.imshow("space", self.frame)
            cv2.waitKey(1)

        if utils.it_is_time(self.last_astroid, config.asteroid_interval):
            ast = Asteroid(random.random() * 0.3 + 0.1, random.random() * config.SCREEN_WIDTH,
                           random.random() * config.SCREEN_HEIGHT,
                           (1 - random.random()) * 1.6,
                           (1 - random.random()) * 1.6)
            self.asteroids.append(ast)
            self.last_astroid = utils.get_now()
        self.now = utils.tick_time(self.now)
        return self.frame, reward, done, {}
Example #36
0
    def get_next_stream(cls, hoursMargin=3):
        """Return the next scheduled stream.

        Parameters
        ----------
        hoursMargin : int
            Number of hours after which a stream is still considered "next".


        Returns
        -------
        Stream
            A Stream instance, or None if no such stream is presnet in the DB.
        """
        right_now = get_now()
        hours_offset = timedelta(hours=-hoursMargin)
        right_before = right_now + hours_offset
        try:
            return (cls.objects
                    .filter(scheduled_date__gte=right_before)
                    .order_by('-scheduled_date')[0])
        except IndexError:
            return None
Example #37
0
def get_orders(user_id, status):
    """获取用户订单信息"""
    query = format_query(user_id, status)
    db_conn = ToMongo()
    result = db_conn.get_col('order').find(query).sort('order_no', -1)
    orders = []
    result = list(result)
    for order in result:
        status = order['orders_status']
        amount = order['amount']
        order_no = order['order_no']
        create_time = order['create_time']
        effective_time = order['create_time'] + ORDER_EFFECTIVE_TIME
        books = order['books']
        book_info = []
        # 15天自动确认收货
        if status == 2 and create_time + AUTO_RECEIVE < get_now():
            rel = update_status_user_id(order_no, user_id)
            if rel.modified_count:
                status = 3
        for book in books:
            book_num = book['book_num']
            # 图书下架后get_book查询不到信息,会抛出错误
            book_info.append({
                'book_num': book_num,
                'books': get_book_for_id(book['book_id'])
            })
        orders.append({
            'status': status,
            'amount': amount,
            'order_no': order_no,
            'create_time': format_time_second(create_time),
            'book_info': book_info,
            'effective_time': format_time_second(effective_time),
        })
    db_conn.close_conn()
    return orders
Example #38
0
    def send_message(self, recipient_name, payload, conn=None, needs_auth=True):
        try:
            encoded_payload = json.loads(payload)
        except:
            raise ExpectedException("Invalid json for payload")
        payload = encoded_payload
        if needs_auth and self.moderated_message:
            form = { 'sender': self.get_name(), 'recipient': recipient_name, 'recipient_exists': self.server.exists_user(recipient_name), 'payload': json.dumps(payload) }
            success, options = self.server.http_request('message', self.get_cookie(conn), form, conn=conn)
            self.server.maybe_auto_subscribe(self, options, conn=conn)
            if not success:
                raise ExpectedException(options.get('error', 'Unauthorized'))
            payload = options.get('override_payload', payload)
            recipient_name = options.get('override_recipient_name', recipient_name)
        elif not self.server.exists_user(recipient_name):
            raise ExpectedException('Invalid user name')

        recipient = self.server.get_user(recipient_name) if self.server.exists_user(recipient_name) else None
        
        frame = {"sender": self.get_name(), "recipient": recipient.get_name() if recipient else "null", "payload": payload, "datetime": get_now()}
        if recipient:
            recipient.send_frame('MESSAGE', frame)
        if self.reflective and (not recipient or recipient.name != self.name):
            self.send_frame('MESSAGE', frame)
Example #39
0
 def past_streams(cls):
     right_now = get_now()
     return cls.objects.filter(scheduled_date__lt=right_now)
Example #40
0
def agent(args):
    """Run a long running polling agent.

    Periodically updates the database with timeseries active stat data.

    :param args: argparse args
    """
    conf = config.load(args.config_file)
    nova = get_nova(conf)
    database.get_engine(conf.get('db', {}))

    detailed = True

    # Special all tenant.
    all_tenant_id = '0' * 32

    # Init last poll time to 0 to trigger first poll
    last_polled = 0

    while True:
        if time.time() - last_polled > conf.get('polling_interval', 120):
            with database.session_scope() as session:
                start, end = utils.get_date_interval()

                # Grab usage results
                usages = nova.usage.list(start, end, detailed=detailed)
                r = UsageReport(usages)

                # Get datetime for time value
                now = utils.get_now()

                # Iterate over all tenants
                for tenant_usage in usages:

                    # Ensure tenant is in tenant table
                    tenant_id = tenant_usage.tenant_id
                    tenant = Tenant.get_or_create(session, tenant_id)
                    session.commit()

                    # Get tenant stats and add to session
                    v, m, s = r.active_stats(tenant_id=tenant_id)
                    session.add(ActiveVCPUS(
                        value=v, time=now, tenant_id=tenant.id
                    ))
                    session.add(ActiveMemoryMB(
                        value=m, time=now, tenant_id=tenant.id
                    ))
                    session.add(ActiveLocalStorageGB(
                        value=s, time=now, tenant_id=tenant.id
                    ))

                # Save all tenant stats
                v, m, s = r.active_stats()
                print ("Active vcpus", v)
                print ("Active memory MB", m)
                print ("Active storage GB", s)
                all_tenant = Tenant.get_or_create(session, all_tenant_id)
                session.commit()
                session.add(ActiveVCPUS(
                    value=v, time=now, tenant_id=all_tenant.id
                ))
                session.add(ActiveMemoryMB(
                    value=m, time=now, tenant_id=all_tenant.id
                ))
                session.add(ActiveLocalStorageGB(
                    value=s, time=now, tenant_id=all_tenant.id
                ))

            last_polled = time.time()
            print ("Updating polling interval")
        time.sleep(1)
    exit()