Esempio n. 1
0
    async def get_events(self, num=10, page=0, more=False, weekend=False):
        logger.debug("cogs/f1/get_events: Fetching",
                     num=num,
                     more=more,
                     weekend=weekend)
        lines = []
        calendar = await self.calendar()
        timeline = list(calendar.timeline.start_after(Arrow.now()))
        start = min(page * num, len(timeline) - num)

        logger.info("cogs/f1/get_events",
                    start=start,
                    len_timeline=len(timeline))

        for event in list(calendar.timeline.now()):
            lines.append(
                f"**{event.name}** ongoing, ending " +
                human(event.end.to(SUPER_TIMEZONE).timestamp, precision=2))

        for event in list(timeline)[start:]:
            local_time = event.begin.to(SUPER_TIMEZONE)
            lines.append("**{0}** {1}, {2}".format(
                event.name,
                human(local_time.timestamp, precision=2),
                local_time.strftime("%d %b @ %H:%M"),
            ))
            if len(lines) >= num or weekend and local_time.isoweekday() in (7,
                                                                            1):
                break
        if more and len(timeline) - start - num:
            lines.append(f"...and {len(timeline) - start - num} more")
        logger.info("cogs/f1/get_events: Fetched", result=lines)
        return lines
Esempio n. 2
0
def status():
    data = {}

    with open(os.path.join(app.config["DATA_DIR"], b"library", b"lock"),
              "w") as f:
        try:
            fcntl.flock(f, fcntl.LOCK_EX | fcntl.LOCK_NB)
            fcntl.flock(f, fcntl.LOCK_UN)
            data["updating"] = False
        except IOError as e:
            if e.errno in (errno.EACCES, errno.EAGAIN):
                data["updating"] = True
            else:
                raise
    if data["updating"]:
        data["update_started"] = human(
            datetime.now().replace(microsecond=0) -
            datetime.fromtimestamp(float(redis.get(
                "library_update:start"))).replace(microsecond=0))
        data["updater"] = {
            "cmdline": redis.get("library_update:updater:cmdline"),
            "pid": int(redis.get("library_update:updater:pid"))
        }
        data["updating"] = (redis.get("library_update:current")
                            or b"").decode("utf-8", "ignore")
    else:
        finish = redis.get("library_update:finish")
        if finish:
            data["last_update"] = human(
                datetime.now().replace(microsecond=0) -
                datetime.fromtimestamp(float(finish)).replace(microsecond=0))

    return render_template("status.html", **data)
Esempio n. 3
0
def get_task_status(key, section=None):
    result = []

    status = SyncManager.get_status(key, section)

    if status.previous_timestamp:
        since = datetime.utcnow() - status.previous_timestamp

        if since.seconds < 1:
            result.append('Last run just a moment ago')
        else:
            result.append('Last run %s' % human(since, precision=1))

    if status.previous_elapsed:
        if status.previous_elapsed.seconds < 1:
            result.append('taking less than a second')
        else:
            result.append(
                'taking %s' %
                human(status.previous_elapsed, precision=1, past_tense='%s'))

    if status.previous_success is True:
        result.append('was successful')
    elif status.previous_timestamp:
        # Only add 'failed' fragment if there was actually a previous run
        result.append('failed')

    if len(result):
        return ', '.join(result) + '.'

    return 'Not run yet.'
Esempio n. 4
0
def get_task_status(key, section=None):
    result = []

    status = SyncManager.get_status(key, section)

    if status.previous_timestamp:
        since = datetime.utcnow() - status.previous_timestamp

        if since.seconds < 1:
            result.append('Last run just a moment ago')
        else:
            result.append('Last run %s' % human(since, precision=1))

    if status.previous_elapsed:
        if status.previous_elapsed.seconds < 1:
            result.append('taking less than a second')
        else:
            result.append('taking %s' % human(
                status.previous_elapsed,
                precision=1,
                past_tense='%s'
            ))

    if status.previous_success is True:
        result.append('was successful')
    elif status.previous_timestamp:
        # Only add 'failed' fragment if there was actually a previous run
        result.append('failed')

    if len(result):
        return ', '.join(result) + '.'

    return 'Not run yet.'
Esempio n. 5
0
def main(args):
    dt_delta = datetime.timedelta(days=args.days)
    max_pipelines = args.pipelines

    projects = get("/projects/")
    if args.project:
        projects = [
            p for p in projects if args.project in p["path_with_namespace"]
        ]

    now = datetime.datetime.now()

    for project in sorted(projects,
                          key=lambda p: p["last_activity_at"],
                          reverse=True):
        mrs = get("/projects/{}/merge_requests".format(project["id"]),
                  reverse=True,
                  state="opened")
        pipelines = [
            p for p in project_pipelines(project["id"], 2 * max_pipelines)
            if (now - p["created_at"] < dt_delta)
        ][:max_pipelines]
        if not (pipelines or mrs):
            continue

        print(project["path_with_namespace"], project["web_url"])
        for mr in mrs:
            build_status = ""
            pipeline_by_sha = {
                p["sha"]: p
                for p in project_pipelines(mr["source_project_id"])
            }
            for commit in get("/projects/{}/merge_requests/{}/commits".format(
                    project["id"], mr["id"])):
                try:
                    build_status = pipeline_by_sha[commit["id"]]["status"]
                    break
                except KeyError:
                    pass
            try:
                assignee = mr["assignee"]["name"]
                assignee_color = termstyle.magenta
            except (TypeError, KeyError):
                assignee = "nobody :-("
                assignee_color = termstyle.red
            print("{:>10}".format(mr["id"]),
                  status_color("{:>10}".format(build_status)),
                  "{:>20}".format(human(mr["created_at"], 1)),
                  assignee_color("{:>20}".format(assignee)), mr["title"])
        for p in pipelines:
            print("{:>10}".format(p["id"]),
                  status_color("{:>10}".format(p["status"])),
                  "{:>20}".format(human(p["created_at"],
                                        1)), "{:>20}".format(""), p["ref"])
Esempio n. 6
0
def worker_matlab(hashtags, taskid):
    conn1 = sqlite3.connect(DB2)
    conn2 = create_tables('hashtag_counts_matlab.db')

    L = len(hashtags)
    percentJump = 0.01
    step = int(L * percentJump)
    print "Step size:", step

    timediffs = []
    start = time.time()
    rows = []
    for i, hashtag in enumerate(hashtags):
        with conn1:
            row, _ = fetch(hashtag, dense=False, conn=conn1)
        row = list(row)
        row[-1] = to_matlab(row[-1])
        row = tuple(row)
        rows.append(row)

        percent, remainder = divmod(i, step)

        if remainder == 0:
            with conn2:
                conn2.executemany(insert, rows)
            rows = []

            curr = time.time()
            if i >= 3:
                interval = curr - start
                timediffs.append(interval)
                interval_delta = datetime.timedelta(seconds=interval)
                print "{0}:\tInterval: {1}".format(taskid, ago.human(interval_delta))
            start = curr
            msg = "{0}:\t{1}% complete.".format(taskid, percent * percentJump * 100)

            if i >= 3:
                # The mean number of seconds per percent
                avgtime = np.mean(timediffs)
                timeleft = (1 - percent * percentJump) / percentJump * avgtime
                if timeleft < 0:
                    timeleft = 0
                delta = datetime.timedelta(seconds=timeleft)
                future = datetime.datetime.now() + delta
                msg2 = " Estimated completion {0}".format(ago.human(future))
                msg += msg2
            print(msg)
    else:
        with conn2:
            conn2.executemany(insert, rows)

    print "{0}:\tFinished.".format(taskid)
Esempio n. 7
0
 async def player(self,
                  ctx: commands.Context,
                  player: str,
                  server_name: str = 'ScrollsGuide'):
     async with ctx.typing():
         async with self.bot.db_engine.acquire() as conn:
             server = await self.__get_server_check_api(
                 ctx, conn, server_name)
             if server is None:
                 return
             else:
                 api = CBSAPI(server.cbsapi)
                 try:
                     player_data = await api.player(player,
                                                    collection=True,
                                                    games=True,
                                                    unlocks=True)
                 except PlayerNotFound:
                     await ctx.send(f"Player `{player}` not found")
                 else:
                     if player_data['last_login']:
                         last_login = human(player_data['last_login'],
                                            precision=1)
                     else:
                         last_login = '******'
                     embed = Embed(title=player_data['name'])
                     embed.add_field(name='Rating',
                                     value=str(int(player_data['rating'])))
                     embed.add_field(name='Last login', value=last_login)
                     embed.add_field(name='Gold', value=player_data['gold'])
                     embed.add_field(
                         name='Commons',
                         value=player_data['collection']['commons'])
                     embed.add_field(
                         name='Uncommons',
                         value=player_data['collection']['uncommons'])
                     embed.add_field(
                         name='Rares',
                         value=player_data['collection']['rares'])
                     embed.add_field(name='Games won',
                                     value=player_data['games']['won'] or 0)
                     embed.add_field(name='Games lost',
                                     value=player_data['games']['lost']
                                     or 0)
                     embed.add_field(
                         name='Achievements',
                         value=player_data['unlocks']['achievements'])
                     embed.add_field(name='Created',
                                     value=human(player_data['created'],
                                                 precision=1))
                     await ctx.send(embed=embed)
Esempio n. 8
0
def descriptive_timedelta(target: datetime,
                          abbreviate: bool = False,
                          precision: Optional[int] = None) -> str:
    """Return a descriptive string for how long ago a datetime was.

    The returned string will be of a format like "4 hours ago" or "3 hours, 21 minutes
    ago". The second "precision level" is only added if it will be at least minutes, and
    only one "level" below the first unit.  That is, you'd never see anything like "4
    hours, 5 seconds ago" or "2 years, 3 hours ago".

    If `abbreviate` is true, the units will be shortened to return a string like
    "12h 28m ago" instead of "12 hours, 28 minutes ago".

    A time of less than a second returns "a moment ago".
    """
    # the ago library doesn't deal with timezones properly, so we need to calculate the
    # timedelta ourselves and only ever call human() using a timedelta
    delta = utc_now() - target

    seconds_ago = delta.total_seconds()
    if seconds_ago < 1:
        return "a moment ago"

    if not precision:
        # determine whether one or two precision levels is appropriate
        if seconds_ago < 3600:
            # if it's less than an hour, we always want only one precision level
            precision = 1
        else:
            # try a precision=2 version, and check the units it ends up with
            result = human(delta, precision=2)

            units = ("year", "day", "hour", "minute", "second")
            unit_indices = [
                i for (i, unit) in enumerate(units) if unit in result
            ]

            # if there was only one unit in it, or they're adjacent, this is fine
            if len(unit_indices) < 2 or unit_indices[1] - unit_indices[0] == 1:
                precision = 2
            else:
                # otherwise, drop back down to precision=1
                precision = 1

    result = human(delta, precision, abbreviate=abbreviate)

    # remove commas if abbreviating ("3d 2h ago", not "3d, 2h ago")
    if abbreviate:
        result = result.replace(",", "")

    return result
Esempio n. 9
0
def example_usage():
    """Test and example usage"""

    print('\nTest past tense:\n')
    print(delta2dict( PAST_DELTA ))
    print('Commented ' + human( PAST_DELTA, 1 ))
    print(human( PAST, past_tense = "Commented {} ago" ))

    print(human( ONE_YEAR_FOUR_HOURS_DELTA, past_tense = "Posted {} ago" ))

    print('\nTest future tense:\n')
    print(delta2dict( FUTURE_DELTA ))
    print('Shutdown ' + human( FUTURE_DELTA, 5 ))
    print(human( FUTURE, future_tense = 'Shutdown in {} from now' ))
    print('')
Esempio n. 10
0
def timedelta_to_human(td):
    '''
    Returns a vaguely readable string for a `timedelta` instance.

    '''
    s = ago.human(td, precision=2, past_tense='{}')
    return ','.join(s.split(',', 3)[0:2])
Esempio n. 11
0
    def unpack_move_rar_file(self, release_unpacker_rar_file,
                             rarfile_file_name, unpack_file_path):
        """Extract an individual file from release_unpacker_rar_file to
        unpack_file_path
        """

        # Extract file to tmp_dir
        log.debug('Extracting {} to {}'.format(rarfile_file_name,
                                               self.tmp_dir))

        log.info('{} unpack started'.format(unpack_file_path.name))
        unpack_start = datetime.now().replace(microsecond=0)

        extracted_file_path = release_unpacker_rar_file.extract_file(
            rarfile_file_name, self.tmp_dir)

        unpack_end = datetime.now().replace(microsecond=0)
        unpack_time = human(unpack_end - unpack_start, past_tense='{}')

        if not unpack_time:
            log.info('{} unpack done'.format(unpack_file_path.name))
        else:
            log.info('{} unpack done, {}'.format(unpack_file_path.name,
                                                 unpack_time))

        # Move file and rename to unpack_dir
        log.debug('Moving {} to {}'.format(extracted_file_path,
                                           unpack_file_path))

        extracted_file_path.move(unpack_file_path)
Esempio n. 12
0
def main(wf):
    user_input = ''.join(wf.args)

    if wf.update_available:
        wf.add_item("An update is available!",
                    autocomplete='workflow:update', valid=False)

    refresh(wf)
    top_stories = wf.cached_data('hackernews_top_10', max_age=60)
    while top_stories is None:
        top_stories = wf.cached_data('hackernews_top_10', max_age=60)
        time.sleep(1)

    for i in range(2,11):
        if wf.cached_data_fresh('hackernews_top_%s0' % i, 60):
            top_stories += wf.cached_data('hackernews_top_%s0' % i, max_age=0)
        else:
            break
    
    for item_id, item in top_stories:
        title = item['title']
        date = human(datetime.fromtimestamp(int(item['time'])))
        subtitle = '%s points by %s %s' % (item['score'], item['by'], date)
        url = item['url'] if 'url' in item else 'https://news.ycombinator.com/item?id=%s' % item_id
        if user_input.lower() in title.lower() or user_input.lower() in subtitle.lower():
            wf.add_item(title, subtitle, arg=url, valid=True)

    wf.send_feedback()
Esempio n. 13
0
 def __init__(self, master, oneDir):
     self.oneDir = oneDir
     self.master = master
     self.frame = tk.Toplevel(self.master)
     if self.oneDir.user == 'admin':
         self.list = self.oneDir.admin_list()
     else:
         self.list = self.oneDir.list()
     self.entries = {}
     counter = 1
     tk.Label(self.frame, text="User").grid(row = 1, column=1)
     tk.Label(self.frame, text="File").grid(row = 1, column=2)
     tk.Label(self.frame, text="Path").grid(row = 1, column=3)
     tk.Label(self.frame, text="Modified").grid(row = 1, column=4)
     tk.Label(self.frame, text="Delete").grid(row = 1, column=5)
     tk.Label(self.frame, text="Share").grid(row = 1, column=6)
     count = 2
     for f in self.list:
         tk.Label(self.frame, text=f['username']).grid(row = count, column=1)
         tk.Label(self.frame, text=f['name']).grid(row = count, column=2)
         tk.Label(self.frame, text='/' + f['path']).grid(row = count, column=3)
         modified = human(datetime.datetime.strptime(f['modified'], '%Y-%m-%d %H:%M:%S.%f'), precision=2, past_tense='{}', future_tense='{}')
         tk.Label(self.frame, text=modified).grid(row = count, column=4)
         tk.Button(self.frame, borderwidth=4, text="Delete", width=10, pady=8, command=lambda count=count: self.delete(count)).grid(row=count, column=5)
         tk.Button(self.frame, borderwidth=4, text="Share", width=10, pady=8, command=lambda count=count: self.share(count)).grid(row=count, column=6)
         count += 1
Esempio n. 14
0
 async def uptime(self, ctx):
     """**.uptime** - show Super's uptime"""
     diff = time() - self.start
     this_long = human(self.start, precision=3).replace("ago", "").strip()
     async with ctx.message.channel.typing():
         return await ctx.message.channel.send(
             f"i've been awake for {this_long}...")
Esempio n. 15
0
    def build_elapsed(status):
        elapsed = status.latest.ended_at - status.latest.started_at

        if elapsed.seconds < 1:
            return _('taking less than a second')

        return _('taking %s') % human(elapsed, precision=1, past_tense='%s')
Esempio n. 16
0
    def unpack_move_rar_file(self, release_unpacker_rar_file,
                             rarfile_file_name, unpack_file_path):
        """Unpack and move RAR file.

        Extract an individual file from release_unpacker_rar_file to
        unpack_file_path.
        """
        # Extract file to tmp_dir
        log.debug("Extracting %s to %s", rarfile_file_name, self.tmp_dir)

        log.info("%s unpack started", unpack_file_path.name)
        unpack_start = datetime.now().replace(microsecond=0)

        extracted_file_path = release_unpacker_rar_file.extract_file(
            rarfile_file_name, self.tmp_dir)

        unpack_end = datetime.now().replace(microsecond=0)
        unpack_time = human(unpack_end - unpack_start, past_tense="{}")

        if not unpack_time:
            log.info("%s unpack done", unpack_file_path.name)
        else:
            log.info("%s unpack done, %s", unpack_file_path.name, unpack_time)

        # Move file and rename to unpack_dir
        log.debug("Moving %s to %s", extracted_file_path, unpack_file_path)

        extracted_file_path.move(unpack_file_path)
Esempio n. 17
0
 def ago(self):
     if self.access_set.all().count() == 0:
         return "Never seen"
     most_recent = self.access_set.all().order_by('-start_time')[0]        
     end = most_recent.end_time
     end = end.replace(tzinfo=None)
     return ago.human(end, 1)
Esempio n. 18
0
def format_delta(date):
    return ago.human(
        (datetime.now(timezone.utc)) - (dateutil.parser.parse(date)),
        future_tense="{} from now",  # No-one should ever see this
        past_tense="{} ago",
        precision=1,
    )
Esempio n. 19
0
def getSystemInfo():
    """Return the last time pacman -Syu was run."""
    out = run_from_shell('cat', '/var/log/pacman.log')
    lastdate = re.findall('\[([\d\-: ]+)\].*-Syu.*', out)[-1]
    time = datetime.strptime(lastdate, '%Y-%m-%d %H:%M')
    return jsonify({
        "last_update" : human(time, precision=1) })
Esempio n. 20
0
def create_pump_browser(pump_list):
    table = []
    #header
    table.append(
        html.Tr([
            html.Th('Pump identifier'),
            html.Th('Frequency (sec)'),
            html.Th('Last status'),
            html.Th('Computed')
        ]))
    #rows
    table += [
        html.Tr([
            html.Td(dcc.Link(p['id'], href='/pump/' + str(p['id']))),
            html.Td(p['freq']),
            html.Td(p['lp']['label'],
                    className='table-warning'
                    if p['lp']['label'] != 'normal' else 'table-success'),
            html.Td(
                human(
                    datetime.datetime.strptime(p['lp']['ts'],
                                               "%Y-%m-%dT%H:%M:%S.%f"), 1))
        ]) for p in pump_list
    ]
    return table
Esempio n. 21
0
    def get(self, request, id):
        post = get_object_or_404(Post, id=id)
        post.views += 1
        post.save()

        menu_items = []
        body_pre = [
            post.description, 'Author: {}'.format(post.user.username),
            'Expires in: {}'.format(human(post.expires_at)),
            'Code: {}'.format(post.code), 'Views: {}'.format(post.views)
        ]

        # check to see if we have notifications set in cache for this post
        if cache.get('new_post'):
            body_pre.insert(0, 'Post successfuly created!')
            cache.delete('new_post')
        elif cache.get('post_private'):
            body_pre.insert(0, 'Post marked as private!')
            cache.delete('post_private')
        elif cache.get('post_renewed'):
            body_pre.insert(0, 'Post successfuly renewed!')
            cache.delete('post_renewed')
        elif cache.get('msg_sent'):
            body_pre.insert(0, 'Your message successfuly sent!')
            cache.delete('msg_sent')
        elif cache.get('msg_not_sent'):
            body_pre.insert(0, 'Message was not sent, please try again later!')
            cache.delete('msg_sent')

        menu_items.extend([MenuItem(description=u'\n'.join(body_pre))])

        if post.user == self.get_user():
            # viewing user is the post owner
            menu_items.extend([
                MenuItem(description='Renew',
                         method='PUT',
                         path=reverse('post_detail', args=[post.id]) +
                         '?attr=renew'),
                MenuItem(description='Delete',
                         method='DELETE',
                         path=reverse('post_detail', args=[post.id]))
            ])
            if not post.is_private:
                menu_items.extend([
                    MenuItem(description='Make private',
                             method='PUT',
                             path=reverse('post_detail', args=[post.id]) +
                             '&attr=is_private')
                ])

        else:
            menu_items.extend([
                MenuItem(description='Send message',
                         method='GET',
                         path=reverse('send_msg', args=[post.id])),
            ])

        content = Menu(body=menu_items, header=post.title, footer='Reply MENU')

        return self.to_response(content)
Esempio n. 22
0
    def build_since(status):
        since = datetime.utcnow() - status.latest.ended_at

        if since.seconds < 1:
            return _('Last run just a moment ago')

        return _('Last run %s') % human(since, precision=1)
Esempio n. 23
0
def human_date_utc(*args, **kwargs):
    if isinstance(args[0], (int, float, str)):
        args = [datetime.datetime.utcfromtimestamp(float(args[0]))] + list(
            args[1:])
    delta = (datetime.datetime.utcnow() - args[0])
    delta = delta - datetime.timedelta(microseconds=delta.microseconds)
    return ago.human(delta, *args[1:], **kwargs)
Esempio n. 24
0
async def last_seen(opsdroid, config, message):
    name = message.regex.group('name')
    seen = await opsdroid.memory.get("seen")
    if seen == None or name not in seen:
        await message.respond("I've never seen {} before".format(name))
    else:
        await message.respond("I last saw {} {}".format(name, human(seen[name], precision=1)))
Esempio n. 25
0
def get_expiries():
    now = datetime.now()
    default = app.config.get('EXPIRY')

    default_hours = default.days * 24
    if hasattr(default, 'hours'):
        default_hours += default.hours

    default_times = [
        1,  # an hour
        24,  # a day
        24 * 7,  # a week
        24 * 7 * 30,  # a month
        27 * 7 * 365,  # a year
        27 * 7 * 365 * 100,  # when the server dies (100 years)
    ]

    try:
        default_times.remove(default_hours)
    except ValueError:
        pass
    default_times.append(default_hours)

    expiries = [{
        'name':
        human(now + timedelta(hours=span, seconds=1), precision=1),
        'value':
        from_datetime(now + timedelta(hours=span)),
    } for span in default_times]
    expiries[-1]['name'] += ' (default)'
    return expiries
Esempio n. 26
0
def check_posted(phenny, input, url):
    if url:
        conn = sqlite3.connect(phenny.posted_db,
                               detect_types=sqlite3.PARSE_DECLTYPES)
        c = conn.cursor()
        c.execute("SELECT nick, time FROM posted WHERE channel=? AND url=?",
                  (input.sender, url))
        res = c.fetchone()

        posted = None

        if res:
            nickname = res[0]
            time = human(res[1])

            posted = "{0} by {1}".format(time, nickname)

        else:
            c.execute(
                "INSERT INTO posted (channel, nick, url) VALUES (?, ?, ?)",
                (input.sender, input.nick, url))
            conn.commit()

        conn.close()

        return posted
Esempio n. 27
0
    def build_since(status):
        since = datetime.utcnow() - status.latest.ended_at

        if since.seconds < 1:
            return _('Last run just a moment ago')

        return _('Last run %s') % human(since, precision=1)
 def sw_dict(sw):
     last_update = sw.get('lastCommit',
                          sw.get('updatedAt')) or '2015-01-01T12:00:00Z'
     return {
         'numCommits':
         sw.get('totalCommits'),
         'numMentions':
         len(sw.get('related').get('mentions')),
         'lastUpdate':
         last_update,
         'lastUpdateAgo':
         ago.human(str_to_datetime(last_update), precision=1),
         'tags':
         sw.get('tags'),
         'primaryKey':
         sw.get('primaryKey'),
         'brandName':
         sw.get('brandName'),
         'shortStatement':
         sw.get('shortStatement'),
         'isFeatured':
         sw.get('isPublished'),
         'relatedOrganizations': [{
             'foreignKey': {
                 key: org['foreignKey'][key]
                 for key in ['primaryKey', 'name']
             }
         } for org in sw.get('related').get('organizations')],
         'slug':
         sw.get('slug'),
     }
Esempio n. 29
0
def get_time_left(created_at):
    return ago.human(
        (datetime.now(timezone.utc).replace(hour=23, minute=59, second=59)) -
        (dateutil.parser.parse(created_at) + timedelta(days=8)),
        future_tense='Data available for {}',
        past_tense='Data no longer available',  # No-one should ever see this
        precision=1)
Esempio n. 30
0
 def get_humanize_local_datetime_from_utc_datetime(utc_target_datetime):
     local_now = datetime.datetime.now(tz.tzlocal())
     if utc_target_datetime:
         local_target_datetime = utc_target_datetime.replace(
             tzinfo=tz.gettz("UTC")).astimezone(tz=tz.tzlocal())
         return ago.human(local_now - local_target_datetime, precision=1)
     return ""
Esempio n. 31
0
def project_index_template():
    url = api_url + "/project_cache"
    project_data = requests.get(url).json()
    projects = []
    for project in project_data:
        status = project_status(project["dateStart"], project["dateEnd"])["status"]
        projects.append({"id": project["primaryKey"]["id"],
                         "title": project["title"],
                         "subtitle": project["subtitle"],
                         "image": project["image"],
                         "yearStart": get_year_from_date_string(project["dateStart"]),
                         "yearEnd": get_year_from_date_string(project["dateEnd"]),
                         "status": status,
                         "numMentions": len(project["output"]) + len(project["impact"]),
                         "lastUpdate": project["updatedAt"],
                         "lastUpdateAgo": ago.human(str_to_datetime(project["updatedAt"]), precision=1),
                         "topics": project["topics"],
                         "technologies": project["technologies"],                         
                         })
    mentions = get_project_mentions(project_data)
    status_choices = ['Starting','Running', 'Finished']

    schema = get_schema()
    topic_choices = schema["project"]["properties"]["topics"]["items"]["enum"]
    technology_choices = schema["project"]["properties"]["technologies"]["items"]["enum"]

    return flask.render_template('project_index/template.html',
                                 data_json=flask.Markup(json.dumps(projects)),
                                 projects=projects,
                                 status_choices_json=flask.Markup(json.dumps(status_choices)),
                                 topic_choices_json=flask.Markup(json.dumps(topic_choices)),
                                 technology_choices_json=flask.Markup(json.dumps(technology_choices)),                                                                  
                                 mentions=mentions)
Esempio n. 32
0
def stalk(username, password):
	print(time.strftime('%H:%M:%S Initiating stalking', time.localtime()))
	try:
		login(username, password)
		for dev in devs:
			time.sleep(10)
			hdr = { 'User-Agent' : 'Mojang stalker bot for /r/scrolls' }
			req = urllib2.Request("http://www.reddit.com/user/%s/comments.json?limit=10"%dev, headers=hdr)
			h = urllib2.urlopen(req)
			d = json.loads(h.read())
			for p in d["data"]["children"]:
				# Filter only a specific subreddit
				if p["data"]["subreddit_id"] == subreddit_id:
					posts.append(p)
		 
		# Sort by the time the post was created
		posts.sort(key=lambda p: p["data"]["created"],reverse=True)
		
		newcontent = ""
		for post in posts[0:20]:
			timestamp = human(datetime.datetime.fromtimestamp(post["data"]["created"]) - datetime.timedelta(hours=8))
			thread_id = post["data"]["link_id"][3:]
			comment_id = post["data"]["id"]
			url = "http://www.reddit.com/r/%s/comments/%s//%s?context=3" % (subreddit_name,thread_id,comment_id)
			newcontent += "[](/mojang) /u/%s (%s) [%s](%s) by /u/%s \n\n>%s\n\n****\n\n" % (post["data"]["author"], timestamp, post["data"]["link_title"], url, post["data"]["link_author"], post["data"]["body"].replace("\n","\n> "))
		del posts[:]
		reddit.edit_wiki_page(subreddit=subreddit_name, page=page, content=newcontent, reason='')
		print(time.strftime('%H:%M:%S Stalking complete', time.localtime()))
	except Exception as e:
		print("Error stalking: " + str(e))
Esempio n. 33
0
def burn():
    # calories = met * weight * hours
    stuff = map(json.loads, request.args.getlist('stuff'))
    amounts = ['{} of {}'.format(x['count'], x['name']) for x in stuff]
    query = ' and '.join(amounts)
    calories = float(get_calories_from_wa(query))
    weight_kg = float(request.args['weight']) * 0.453592

    data = {'calories': calories, 'activities': {}}
    for (name, met) in ACTIVITY_MET_VALUES.items():
        hours = float(calories / (met * weight_kg))
        delta = timedelta(hours=hours)
        humanized = human(delta, past_tense='{}')
        humanized = (humanized.replace(' hours',
                                       'h').replace(' hour', 'h').replace(
                                           ' minutes',
                                           'm').replace(' minute',
                                                        'm').replace(',', ''))

        data['activities'][name] = {
            'time': humanized,
            'distance': '{:.1f} km'.format(hours * SPEED[name])
        }

    resp = jsonify({'activities': data})
    resp.status_code = 200
    resp.headers = {
        'Access-Control-Allow-Headers':
        request.headers.get('Access-Control-Request-Headers'),
        'Access-Control-Allow-Methods':
        request.headers.get('Access-Control-Request-Method'),
        'Access-Control-Allow-Origin':
        '*'
    }
    return resp
def getdata():
    try:
        soup = Soup(requests.get("http://steamcommunity.com/id/{id}/games?tab=all".format(id=request.args.get('id', ''))).text)
    except KeyError:
        return "No user ID provided"

    try:
        script = soup.findAll('script')[11].text
    except IndexError:
        resp = make_response(json.dumps({"name": "Couldn't get Steam information", "appid": "0", "logo": "http://puushbrowse.blha303.com.au/broken.png"}))
        resp.headers["Access-Control-Allow-Origin"] = "http://steamroulette.blha303.com.au";
        return resp
    data = json.loads(script.strip().split("\r\n")[0][14:-1])

    options = []

    for a in data:
        if "last_played" in a:
            if a["last_played"] < time()-604800:
                a["since"] = ago.human(datetime.fromtimestamp(a["last_played"]))
                options.append(a)
        else:
            a["name"] += " <i>(never played)</i>"
            options.append(a)

    resp = make_response(json.dumps(choice(options)))
#    resp = make_response("Play {name}: <a href=\"steam://play/{appid}\">Click here</a><br><a href=\"steam://play/{appid}\"><img src=\"{logo}\" alt=\"{name}\">".format(**choice(options)))
    resp.headers["Access-Control-Allow-Origin"] = "http://steamroulette.blha303.com.au";
    return resp
Esempio n. 35
0
def check_posted(phenny, input, url):
    if url:
        conn = sqlite3.connect(phenny.posted_db, 
            detect_types=sqlite3.PARSE_DECLTYPES)
        c = conn.cursor()
        c.execute("SELECT nick, time FROM posted WHERE channel=? AND url=?", 
            (input.sender, url))
        res = c.fetchone()

        posted = None

        if res:
            nickname = res[0]
            time = human(res[1])

            posted = "{0} by {1}".format(time, nickname)


        else:
            c.execute("INSERT INTO posted (channel, nick, url) VALUES (?, ?, ?)", 
                (input.sender, input.nick, url))
            conn.commit()

        conn.close()

        return posted
Esempio n. 36
0
def burn():
    # calories = met * weight * hours
    stuff = map(json.loads, request.args.getlist('stuff'))
    amounts = ['{} of {}'.format(x['count'], x['name']) for x in stuff]
    query = ' and '.join(amounts)
    calories = float(get_calories_from_wa(query))
    weight_kg = float(request.args['weight']) * 0.453592

    data = {'calories': calories, 'activities': {}}
    for (name, met) in ACTIVITY_MET_VALUES.items():
        hours = float(calories / (met * weight_kg))
        delta = timedelta(hours=hours)
        humanized = human(delta, past_tense='{}')
        humanized = (humanized
                     .replace(' hours', 'h')
                     .replace(' hour', 'h')
                     .replace(' minutes', 'm')
                     .replace(' minute', 'm')
                     .replace(',', '')
                     )

        data['activities'][name] = {
            'time': humanized,
            'distance': '{:.1f} km'.format(hours * SPEED[name])
        }

    resp = jsonify({'activities': data})
    resp.status_code = 200
    resp.headers = {
        'Access-Control-Allow-Headers': request.headers.get('Access-Control-Request-Headers'),
        'Access-Control-Allow-Methods': request.headers.get('Access-Control-Request-Method'),
        'Access-Control-Allow-Origin': '*'
    }
    return resp
Esempio n. 37
0
    async def on_member_remove(self, member):
        webhook = await self._get_webhook(member.guild, 'join_leave_log')
        if not webhook:
            return

        roles = ', '.join([role.mention for role in member.roles][1:])

        embed = log_embed_danger(
            'Member left',
            self.bot
        )
        embed.add_field(name='Name:', value=member.name, inline=True)
        embed.add_field(name='Mention:', value=member.mention, inline=True)
        embed.add_field(name='Joined Discord:', value=ago.human(
            member.created_at), inline=True)
        embed.add_field(name='Roles:', value=roles or 'No roles', inline=False)

        embed.set_footer(
            text=f'Member ID: {member.id}', icon_url=member.avatar_url)
        embed.set_thumbnail(url=member.avatar_url)

        await send_webhook(
            webhook.url,
            self.bot.aio_session,
            embed=embed
        )
Esempio n. 38
0
def redditor_info(bot, trigger, match=None):
    """Show information about the given Redditor"""
    commanded = re.match(bot.config.prefix + 'redditor', trigger)
    r = praw.Reddit(user_agent=USER_AGENT)
    match = match or trigger
    try:
        u = r.get_redditor(match.group(2))
    except:
        if commanded:
            bot.say('No such Redditor.')
            return NOLIMIT
        else:
            return
        #Fail silently if it wasn't an explicit command.

    message = '[REDDITOR] ' + u.name
    if commanded:
        message = message + ' | http://reddit.com/u/' + u.name
    if u.is_gold:
        message = message + ' | 08Gold'
    if u.is_mod:
        message = message + ' | 05Mod'
    message = message + ' | Link: ' + str(u.link_karma) + ' | Comment: ' + str(u.comment_karma)

    # age
    message = message + ' | Redditor for ' + human(datetime.datetime.utcnow() - datetime.datetime.utcfromtimestamp(int(u.created_utc)), past_tense='{}')

    bot.say(message)
Esempio n. 39
0
    async def on_member_join(self, member):
        webhook_join = await self._get_webhook(member.guild, 'join_leave_log')
        if not webhook_join:
            return

        join_embed = log_embed_info(
            'Member joined',
            self.bot
        )
        join_embed.add_field(name='Name:', value=member.name, inline=True)
        join_embed.add_field(
            name='Mention:', value=member.mention, inline=True)
        join_embed.add_field(name='Joined Discord:', value=ago.human(
            member.created_at), inline=True)

        join_embed.set_footer(
            text=f'Member ID: {member.id}', icon_url=member.avatar_url)
        join_embed.set_thumbnail(url=member.avatar_url)

        await send_webhook(
            webhook_join.url,
            self.bot.aio_session,
            embed=join_embed
        )

        webhook_invites = await self._get_webhook(member.guild, 'invite_log')
        if not webhook_invites:
            return

        invite = await self._get_invite(member.guild)

        invite_embed = log_embed_info(
            'Member joined using invite link',
            self.bot,
        )

        if not invite:
            invite_embed.description = 'Sorry, I couldn\'t figure out how this person joined.'

        else:
            invite_embed.add_field(
                name='Name:', value=member.name, inline=True)
            invite_embed.add_field(name='ID:', value=invite.id, inline=True)
            invite_embed.add_field(
                name='Guild:', value=invite.guild.name, inline=True)
            invite_embed.add_field(
                name='Inviter:', value=invite.inviter.name, inline=True)

            invite_embed.add_field(name='URL', value=invite.url, inline=True)

        invite_embed.set_thumbnail(url=member.avatar_url)
        invite_embed.set_footer(
            text=f'User ID: {member.id}', icon_url=member.avatar_url)

        await send_webhook(
            webhook_invites.url,
            self.bot.aio_session,
            embed=invite_embed
        )
Esempio n. 40
0
def get_time_left(created_at, service_data_retention_days=7):
    return ago.human(
        (datetime.now(timezone.utc)) -
        (dateutil.parser.parse(created_at).replace(hour=0, minute=0, second=0)
         + timedelta(days=service_data_retention_days + 1)),
        future_tense='Data available for {}',
        past_tense='Data no longer available',  # No-one should ever see this
        precision=1)
Esempio n. 41
0
def get_time_left(job_created_at):
    return ago.human(
        (datetime.now(timezone.utc).replace(hour=23, minute=59, second=59))
        - (dateutil.parser.parse(job_created_at) + timedelta(days=8)),
        future_tense="Data available for {}",
        past_tense="Data no longer available",  # No-one should ever see this
        precision=1,
    )
Esempio n. 42
0
 def kill_list(self, mess, args):
     """Show everyone who is on the watch list."""
     now = datetime.utcnow()
     members = self["users"].values()
     members = sorted(members, key=lambda member: member['character_name'].lower())
     for member in members:            
         member['time_ago'] = ago.human(now - member['time'])
     return {'members': members}
Esempio n. 43
0
    def _friendly_built_on(self):
        timestamp = math.floor(self.timestamp_millis / 1000)

        if datetime.now().timestamp() - timestamp < 60:
            return 'less than a minute ago'

        date = datetime.fromtimestamp(timestamp)

        return human(date, precision=1)
Esempio n. 44
0
 def time_since(self):
     try:
         delta = datetime.utcnow() - datetime.strptime(
             self.created_at, "%a, %d %b %Y %H:%M:%S +0000")
         return ago.human(delta, precision=2)
     except AttributeError as e:
         return ""
     except:
         raise
Esempio n. 45
0
    def _friendly_duration(self):
        if self.duration_millis < 1000:
            return 'negligible'

        time_delta = timedelta(milliseconds=self.duration_millis)
        return human(time_delta,
                     precision=1,
                     past_tense='{}',
                     future_tense='{}')
Esempio n. 46
0
def human_date_utc(*args, **kwargs):
    if isinstance(args[0], type(None)):
        return "never"
    if isinstance(args[0], (int, float, str)):
        args = [datetime.datetime.utcfromtimestamp(float(args[0]))] + list(args[1:])
    delta = (datetime.datetime.utcnow() - args[0])
    delta = delta - datetime.timedelta(microseconds=delta.microseconds)
    result = ago.human(delta, *args[1:], **kwargs)
    return "just now" if result == " ago" else result
Esempio n. 47
0
    def kill_list(self, mess, args):
        """Show everyone who is on the watch list."""
        now = datetime.datetime.utcnow()
        members = self["users"].values()
        members = sorted(members, key=lambda member: member["character_name"])
        for member in members:
            member["time_ago"] = ago.human(now - member["time"])

        return {"members": members, "value": humanize.intword(self["value"])}
Esempio n. 48
0
def descriptive_timedelta(target: datetime, abbreviate: bool = False) -> str:
    """Return a descriptive string for how long ago a datetime was.

    The returned string will be of a format like "4 hours ago" or
    "3 hours, 21 minutes ago". The second "precision level" is only added if
    it will be at least minutes, and only one "level" below the first unit.
    That is, you'd never see anything like "4 hours, 5 seconds ago" or
    "2 years, 3 hours ago".

    If `abbreviate` is true, the units will be shortened to return a string
    like "12h 28m ago" instead of "12 hours, 28 minutes ago".

    A time of less than a second returns "a moment ago".
    """
    seconds_ago = (utc_now() - target).total_seconds()
    if seconds_ago < 1:
        return 'a moment ago'

    # determine whether one or two precision levels is appropriate
    if seconds_ago < 3600:
        # if it's less than an hour, we always want only one precision level
        precision = 1
    else:
        # try a precision=2 version, and check the units it ends up with
        result = human(target, precision=2)

        units = ('year', 'day', 'hour', 'minute', 'second')
        unit_indices = [i for (i, unit) in enumerate(units) if unit in result]

        # if there was only one unit in it, or they're adjacent, this is fine
        if len(unit_indices) < 2 or unit_indices[1] - unit_indices[0] == 1:
            precision = 2
        else:
            # otherwise, drop back down to precision=1
            precision = 1

    result = human(target, precision, abbreviate=abbreviate)

    # remove commas if abbreviating ("3d 2h ago", not "3d, 2h ago")
    if abbreviate:
        result = result.replace(',', '')

    return result
Esempio n. 49
0
def str_date_to_age(str_date):
    try:
        parsed_date = datetime.datetime.strptime(str_date[:-len('+00:00')], "%Y-%m-%dT%H:%M:%S")
        res = ago.human(parsed_date, precision=1)
        if not res:
            return str_date
        return res
    except BaseException:
        pass
    return str_date
Esempio n. 50
0
def worker(hashtags, taskid):
    conn_new = create_tables(DB2)
    L = len(hashtags)
    percentJump = 0.01
    step = int(L * percentJump)
    print "Step size:", step
    timediffs = []
    start = time.time()
    rows = []
    for i, hashtag in enumerate(hashtags):
        rows.append(stats(hashtag, row=True))

        percent, remainder = divmod(i, step)

        if remainder == 0:
            with conn_new:
                conn_new.executemany(insert, rows)
            rows = []

            curr = time.time()
            if i >= 3:
                interval = curr - start
                timediffs.append(interval)
                interval_delta = datetime.timedelta(seconds=interval)
                print "{0}:\tInterval: {1}".format(taskid, ago.human(interval_delta))
            start = curr
            msg = "{0}:\t{1}% complete.".format(taskid, percent * percentJump * 100)

            if i >= 3:
                # The mean number of seconds per percent
                avgtime = np.mean(timediffs)
                timeleft = (1 - percent * percentJump) / percentJump * avgtime
                delta = datetime.timedelta(seconds=timeleft)
                future = datetime.datetime.now() + delta
                msg2 = " Estimated completion {0}".format(ago.human(future))
                msg += msg2
            print(msg)
    else:
        with conn_new:
            conn_new.executemany(insert, rows)

    print "{0}:\tFinished.".format(taskid)
Esempio n. 51
0
    def build_elapsed(status):
        elapsed = status.latest.ended_at - status.latest.started_at

        if elapsed.seconds < 1:
            return _('taking less than a second')

        return _('taking %s') % human(
            elapsed,
            precision=1,
            past_tense='%s'
        )
Esempio n. 52
0
 def highlights(self, cat = 'DISCUSSION', count = 10):
     resp = self.rs.get(host +
         'communities-api/v1/discussion/highlights/' + self.id + '?type=' + cat + '&sort=RECENT&count=' + str(count) + '&start=0',
         headers = {'csrf-token': self.csrfToken })
     #print('resp.content', resp.content)
     #pprint(json.loads(resp.content))
     print('\nHighlights\n')
     for d in json.loads(resp.content)['data']:
         #print(time.strftime('%y-%m-%d %H:%M', time.localtime(int(d['datePosted'])/1000)), d['title'])
         print(ago.human(datetime.fromtimestamp(int(d['discussion']['datePosted'])/1000), precision=1, abbreviate=True), '\t',
                 d['community']['name'] + ':',
                 d['discussion']['title'])
Esempio n. 53
0
def startupnews():
    ts = models.LastUpdated.get('startupnews')
    return render_template('index.html',
            title='Startup News Digest',
            news_list=models.StartupNews.query.order_by('rank').all(),
            navs=[
                ('Startup News', 'http://news.dbanotes.net/news'),
                ('New', 'http://news.dbanotes.net/newest'),
                ('Comments', 'http://news.dbanotes.net/newcomments'),
                ('Leaders', 'http://news.dbanotes.net/leaders'),
                ('Submit', 'http://news.dbanotes.net/submit')],
            last_updated = ts and human(ts, 1)
        )
Esempio n. 54
0
    def xup_list(self, mess, args):
        """Show everyone who is on the ready list."""
        now = datetime.utcnow()

        members = self['users'].values()

        members = sorted(members, key=lambda member: member['time'])

        for member in members:
            if ((now - member['time']).seconds//3600) < 2:
                member['message'] = " ".join(member['args'])
                member['time_ago'] = ago.human(now - member['time'], 1)

        return {'members': members}
Esempio n. 55
0
def hackernews():
    ts = models.LastUpdated.get('hackernews')
    return render_template('index.html',
            title='Hacker News Digest',
            news_list=models.HackerNews.query.order_by('rank').all(),
            navs=[
                ('Hacker News', 'https://news.ycombinator.com/news'),
                ('New', 'https://news.ycombinator.com/newest'),
                ('Comments', 'https://news.ycombinator.com/newcomments'),
                ('Show', 'https://news.ycombinator.com/show'),
                ('Ask', 'https://news.ycombinator.com/ask'),
                ('Jobs', 'https://news.ycombinator.com/jobs'),
                ('Submit', 'https://news.ycombinator.com/submit')],
            last_updated = ts and human(ts, 1)
        )
Esempio n. 56
0
def agolookup():
    if request.args.get('ts') and request.args.get('strf'):
        try:
            if request.args.get('strf') == "%epoch":
                dt = datetime.fromtimestamp(float(request.args.get('ts')))
            else:
                dt = datetime.strptime(request.args.get('ts'), request.args.get('strf'))
            dt = dt - timedelta(hours=4) # gotta get get UTC
            resp = {'ago': human(dt), '_agoreq': request.args.get('ts'), '_agostrf': request.args.get('strf')}
            if request.args.get('strf_to'):
                resp['strf_to'] = dt.strftime(request.args.get('strf_to'))
            return jsonify(resp)
        except Exception as e:
            return jsonify({'error': "{}: {}".format(type(e).__name__, e.message)})
    return jsonify({'error': 'Needs ts and strf as get variables'})
Esempio n. 57
0
    def finish(self):
        self.ended = utils.now()

        verb = 'finished successfully in'
        if not self.success:
            verb = 'failed after'

        ts = ago.human(
            self.ended - self.started,
            precision=5,
            past_tense='%s {0}' % verb  # hee hee
        )
        self.log.info('{0} {1}'.format(self.version, ts))

        self.log_handler.pop_application()
Esempio n. 58
0
def ViewMessage(error_id):
    # Retrieve message from database
    message = MessageManager.get.by_id(error_id)

    # Update `last_viewed_at` field
    message.last_viewed_at = datetime.utcnow()
    message.save()

    # Parse request headers
    web_client = Request.Headers.get('X-Plex-Product', '').lower() == 'plex web'

    # Build objects
    oc = ObjectContainer(
        title2='[%s] %s' % (Message.Type.title(message.type), Trim(message.summary))
    )

    if message.type == Message.Type.Exception:
        # Display exception samples
        for e in message.exceptions.order_by(Exception.timestamp.desc()).limit(50):
            since = datetime.utcnow() - e.timestamp

            callback = Callback(ViewMessage, error_id=error_id)

            if web_client:
                # Display exception traceback in Plex/Web
                callback = Callback(ViewException, exception_id=e.id)

            oc.add(DirectoryObject(
                key=callback,
                title=pad_title('[%s] %s: %s' % (human(since, precision=1), e.type, e.message)),
                thumb=R("icon-exception.png")
            ))
    elif message.type in [Message.Type.Info, Message.Type.Warning, Message.Type.Error, Message.Type.Critical]:
        # Display message code
        oc.add(DirectoryObject(
            key='',
            title=pad_title('Code: %s' % hex(message.code))
        ))

        # Display message description
        if message.description:
            oc.add(DirectoryObject(
                key='',
                title=pad_title('Description: %s' % message.description)
            ))

    return oc