Esempio n. 1
0
    def get_task_list(self):
        def get_time_from_interval(td_object):
            seconds = int(td_object.total_seconds())
            periods = [('year', 60 * 60 * 24 * 365),
                       ('month', 60 * 60 * 24 * 30), ('day', 60 * 60 * 24),
                       ('hour', 60 * 60), ('minute', 60), ('second', 1)]

            strings = []
            for period_name, period_seconds in periods:
                if seconds > period_seconds:
                    period_value, seconds = divmod(seconds, period_seconds)
                    has_s = 's' if period_value > 1 else ''
                    strings.append("%s %s%s" %
                                   (period_value, period_name, has_s))

            return ", ".join(strings)

        def get_time_from_cron(cron):
            year = str(cron[0])
            if year == "2100":
                return "Never"

            day = str(cron[4])
            hour = str(cron[5])

            if day == "*":
                text = "everyday"
            else:
                text = "every " + day_name[int(day)]

            if hour != "*":
                text += " at " + hour + ":00"

            return text

        task_list = []
        for job in self.aps_scheduler.get_jobs():
            if isinstance(job.trigger, CronTrigger):
                if str(job.trigger.__getstate__()['fields'][0]) == "2100":
                    next_run = 'Never'
                else:
                    next_run = pretty.date(
                        job.next_run_time.replace(tzinfo=None))
            else:
                next_run = pretty.date(job.next_run_time.replace(tzinfo=None))

            if isinstance(job.trigger, IntervalTrigger):
                interval = "every " + get_time_from_interval(
                    job.trigger.__getstate__()['interval'])
                task_list.append([job.name, interval, next_run, job.id])
            elif isinstance(job.trigger, CronTrigger):
                task_list.append([
                    job.name,
                    get_time_from_cron(job.trigger.fields), next_run, job.id
                ])

        return task_list
Esempio n. 2
0
	def toString( self ):
		who = [ "@%s" % i for i in self.who.split( " " ) ]
		who = ",".join( who )
		when = self.when.replace(tzinfo=None)
		s = "#who %s #what %s #where %s #when %s"  % ( who, self.what, self.where, pretty.date( when ) )

		return s
Esempio n. 3
0
        def convert_image_dict(a):
            """
            Drop some keys and change some values to pretty-print image dict.
            """
            b = {}
            for k, v in a.items():
                if k not in ['RepoTags', 'RepoDigests', 'Labels', 'Size']:
                    b[k] = v
                if k == 'Created' and v and re_digits.search(str(v)):
                    b[k] = pretty.date(v)
                if k == 'VirtualSize':
                    b[k] = filesize(v)

            # If we have more than one repo tag, return as many dicts

            if a.get('RepoTags', None) is None:
                a['RepoTags'] = ['<none>:<none>']

            for rt in a['RepoTags']:
                repo, tag = rt.rsplit(':', 1)
                c = {}
                c.update(b)
                c['Repository'] = repo
                c['Tag'] = tag
                yield c
Esempio n. 4
0
def search(text,limit,off):
    url='https://www.devrant.io/api/devrant/search?app=3&term='+str(text)+'&limit'+str(limit)
    response = requests.get(url)
    print response
    tags = []
    data = response.json()
    search_dic = {}
    search_list = []
    for rant in range(len(data['results']))[off:limit]:
        search_dic = {}
        search_dic['name'] = data['results'][rant]['user_username']
        search_dic['img'] = data['results'][rant]['attached_image'] or {"url":"#"}

        search_dic['image'] = str(search_dic['img']['url'] or '#')
        tags = data['results'][rant]['tags']
        search_dic['tags'] = tags
        search_dic['comments'] = str(data['results'][rant]['num_comments'] or 0)
        search_dic['text'] = str(data['results'][rant]['text'] or None)
        search_dic['score'] = data['results'][rant]['score']   
        search_dic['time'] = pretty.date(data['results'][rant]['created_time'])
        search_dic['id'] = data['results'][rant]['id']        
        search_dic['user_id'] = data['results'][rant]['user_id']
        search_dic['user_score'] = data['results'][rant]['user_score']
        search_list.insert(rant,search_dic)

    return search_list,limit
Esempio n. 5
0
    def get(self):
        start = request.args.get('start') or 0
        length = request.args.get('length') or -1

        data = TableBlacklist.select(TableShows.title.alias('seriesTitle'),
                                     TableEpisodes.season.concat('x').concat(TableEpisodes.episode).alias('episode_number'),
                                     TableEpisodes.title.alias('episodeTitle'),
                                     TableEpisodes.sonarrSeriesId,
                                     TableBlacklist.provider,
                                     TableBlacklist.subs_id,
                                     TableBlacklist.language,
                                     TableBlacklist.timestamp)\
            .join(TableEpisodes, on=(TableBlacklist.sonarr_episode_id == TableEpisodes.sonarrEpisodeId))\
            .join(TableShows, on=(TableBlacklist.sonarr_series_id == TableShows.sonarrSeriesId))\
            .order_by(TableBlacklist.timestamp.desc())\
            .limit(length)\
            .offset(start)\
            .dicts()
        data = list(data)

        for item in data:
            # Make timestamp pretty
            item["parsed_timestamp"] = datetime.datetime.fromtimestamp(
                int(item['timestamp'])).strftime('%x %X')
            item.update({
                'timestamp':
                pretty.date(datetime.datetime.fromtimestamp(item['timestamp']))
            })

            postprocessEpisode(item)

        return jsonify(data=data)
Esempio n. 6
0
def _dateInWords(d):
    import pretty
    from datetime import datetime

    return pretty.date(
      datetime.strptime(d, '%Y-%m-%d %H:%M:%S')
    )
Esempio n. 7
0
    def unban(self, event, match):
        groupdict = match.groupdict()
        target = groupdict['nick']
        delay = groupdict['timestr']
        channel = event.channel

        if delay:
            try:
                delay = parse_time(delay)
            except ValueError as e:
                event.reply(str(e))
                return

        try:
            hostmask = (yield self._nick_to_hostmask(target))
        except ircutil.NoSuchNick:
            event.reply(
                "There is no user by that nick on the network. "
                "Try specifying a full hostmask. Use “/mode +b” to see the channel ban list"
                .format(target, ))
            return
        except ValueError:
            event.reply(
                "Malformed hostmask. Hostmask syntax is <nick>!<username>@<host>",
                direct=True,
                notice=True)
            return

        try:
            yield self._do_modederequest(channel, 'b', hostmask, delay)
        except ircop.OpFailed as e:
            event.reply(str(e))
        if delay:
            event.reply("Unbanning {}".format(
                pretty.date(int(time.time() + delay))))
Esempio n. 8
0
    def unban(self, event, match):
        groupdict = match.groupdict()
        target = groupdict["nick"]
        delay = groupdict["timestr"]
        channel = event.channel

        if delay:
            try:
                delay = parse_time(delay)
            except ValueError as e:
                event.reply(str(e))
                return

        try:
            hostmask = (yield self._nick_to_hostmask(target))
        except ircutil.NoSuchNick:
            event.reply(
                "There is no user by that nick on the network. "
                "Try specifying a full hostmask. Use “/mode +b” to see the channel ban list".format(target)
            )
            return
        except ValueError:
            event.reply("Malformed hostmask. Hostmask syntax is <nick>!<username>@<host>", direct=True, notice=True)
            return

        try:
            yield self._do_modederequest(channel, "b", hostmask, delay)
        except ircop.OpFailed as e:
            event.reply(str(e))
        if delay:
            event.reply("Unbanning {}".format(pretty.date(int(time.time() + delay))))
Esempio n. 9
0
File: utils.py Progetto: gage/proto
def get_pretty_datetime_format(datetime_or_utc_sec):
    
    if isinstance(datetime_or_utc_sec, datetime.datetime):
        ts = datetime_or_utc_sec
    else:
        ts = datetime.datetime.fromtimestamp(float(datetime_or_utc_sec))
    
    now = datetime.datetime.now()
    delta = now - ts
    if delta.days > 1:
        month = ts.strftime('%h')
        day = str(ts.day).lstrip('0')
        year = str(ts.year)
        
        since = "%s %s, %s" % (month, day, year)
    else:
        since = pretty.date(now-delta) 
        
        if delta.days > 0:
            hour = ts.strftime("%I").lstrip('0')
            minute = ts.strftime("%M")
            locale = ts.strftime("%p").lower()
            
            time_str = "%s:%s%s" % (hour, minute, locale) 
            since = since.title() + " at " + time_str    
Esempio n. 10
0
def rants(text,limit,skip):
    #'weekly':
    #    url = 'https://www.devrant.io/api/devrant/weekly-rants?app=3'

    url='https://www.devrant.io/api/devrant/rants?app=3&limit='+str(limit)+'&skip='+str(skip)+'&sort='+text
    response = requests.get(url)
    print response
    tags = []
    rant_list = []
    data = response.json()

    for rant in range(len(data['rants'])):
        rant_dic = {}
        rant_dic['name'] = data['rants'][rant]['user_username']
        rant_dic['img'] = data['rants'][rant]['attached_image'] or {"url":"#"}
        rant_dic['image'] = str(rant_dic['img']['url'] or '#')
        tags = data['rants'][rant]['tags']
        rant_dic['tags'] = tags
        rant_dic['comments'] = str(data['rants'][rant]['num_comments'] or 0)
        rant_dic['text'] = str(data['rants'][rant]['text'] or None)
        rant_dic['score'] = data['rants'][rant]['score']   
        rant_dic['time'] = pretty.date(data['rants'][rant]['created_time'])
        rant_dic['id'] = data['rants'][rant]['id']        
        rant_dic['user_id'] = data['rants'][rant]['user_id']
        rant_dic['user_score'] = data['rants'][rant]['user_score']
        rant_list.insert(rant,rant_dic)  
    return rant_list,skip
Esempio n. 11
0
    def containers(self, *_, **kwargs):
        """
        Return the list of containers. Equivalent of docker ps.
        :return: list of dicts
        """

        # Truncate by default.
        if 'trunc' in kwargs and kwargs['trunc'] is None:
            kwargs['trunc'] = True

        csdict = self.instance.containers(**kwargs)
        if len(csdict) > 0:

            if 'quiet' not in kwargs or not kwargs['quiet']:
                # Container names start with /.
                # Let's strip this for readability.
                for i in range(len(csdict)):
                    csdict[i]['Names'] = list(map(
                        lambda x: x.lstrip('/'), csdict[i]['Names']))
                    csdict[i]['Created'] = pretty.date(csdict[i]['Created'])
                    if 'Labels' in csdict[i]:
                        del csdict[i]['Labels']

            return csdict
        else:
            return ['There are no containers to list.']
Esempio n. 12
0
    def containers(self, *_, **kwargs):
        """
        Return the list of containers. Equivalent of docker ps.
        :return: list of dicts
        """

        # Truncate by default.
        if 'trunc' in kwargs and kwargs['trunc'] is None:
            kwargs['trunc'] = True

        csdict = self.instance.containers(**kwargs)
        if len(csdict) > 0:

            if 'quiet' not in kwargs or not kwargs['quiet']:
                # Container names start with /.
                # Let's strip this for readability.
                for i in range(len(csdict)):
                    csdict[i]['Names'] = list(map(
                        lambda x: x.lstrip('/'), csdict[i]['Names']))
                    csdict[i]['Created'] = pretty.date(csdict[i]['Created'])
                    if 'Labels' in csdict[i]:
                        del csdict[i]['Labels']

            return csdict
        else:
            return ['There are no containers to list.']
Esempio n. 13
0
    def get(self):
        start = request.args.get('start') or 0
        length = request.args.get('length') or -1

        data = TableBlacklistMovie.select(TableMovies.title,
                                          TableMovies.radarrId,
                                          TableBlacklistMovie.provider,
                                          TableBlacklistMovie.subs_id,
                                          TableBlacklistMovie.language,
                                          TableBlacklistMovie.timestamp)\
            .join(TableMovies, on=(TableBlacklistMovie.radarr_id == TableMovies.radarrId))\
            .order_by(TableBlacklistMovie.timestamp.desc())\
            .limit(length)\
            .offset(start)\
            .dicts()
        data = list(data)

        for item in data:
            postprocessMovie(item)

            # Make timestamp pretty
            item["parsed_timestamp"] = datetime.datetime.fromtimestamp(int(item['timestamp'])).strftime('%x %X')
            item.update({'timestamp': pretty.date(datetime.datetime.fromtimestamp(item['timestamp']))})

        return jsonify(data=data)
Esempio n. 14
0
def list_throttled_providers():
    update_throttled_provider()
    throttled_providers = []
    providers = get_array_from(settings.general.enabled_providers)
    for provider in providers:
        reason, until, throttle_desc = tp.get(provider, (None, None, None))
        throttled_providers.append([provider, reason, pretty.date(until)])
    return throttled_providers
Esempio n. 15
0
def list_throttled_providers():
    update_throttled_provider()
    throttled_providers = []
    if settings.general.enabled_providers:
        for provider in settings.general.enabled_providers.lower().split(','):
            reason, until, throttle_desc = tp.get(provider, (None, None, None))
            throttled_providers.append([provider, reason, pretty.date(until)])
    return throttled_providers
Esempio n. 16
0
def list_throttled_providers():
    update_throttled_provider()
    throttled_providers = []
    existing_providers = provider_registry.names()
    providers = [x for x in get_array_from(settings.general.enabled_providers) if x in existing_providers]
    for provider in providers:
        reason, until, throttle_desc = tp.get(provider, (None, None, None))
        throttled_providers.append([provider, reason, pretty.date(until)])
    return throttled_providers
Esempio n. 17
0
def pretty_ents(inp):
    import pretty, datetime
    outa = []
    for ent in inp.entries:
        username = ent.author[ent.author.find('(')+1:ent.author.find(')')]
        thistime = datetime.datetime.fromtimestamp(time.mktime(ent.updated_parsed))
        prettytime = pretty.date(thistime)
        form = 'Leaky Bukkit: %s (%s) - %s - %s' % (ent.title, username, prettytime, ent.links[0].url)
        outa.append(form)
    return outa
Esempio n. 18
0
def format_datetime(value, format='medium'):
    if format == 'full':
        format = "EEEE, d. MMMM y 'at' HH:mm"
    elif format == 'medium':
        format = "EE dd.MM.y HH:mm"
    elif format == 'pretty':
        now = datetime.now()
        delta = now - value
        return pretty.date(now - delta)
    return babel_format_datetime(value, format)
Esempio n. 19
0
    def mode(self, event, match):
        channel = event.channel
        gd = match.groupdict()
        mode = gd["mode"]
        param = gd["param"]
        timespec = gd["timespec"]

        if timespec:
            try:
                time_to_wait = parse_time(timespec)
            except ValueError as e:
                event.reply(e)
                return

            if timespec.startswith("in") or timespec.startswith("at"):
                # 'in' or 'at' indicate this is when we want to do the mode. as
                # opposed to 'do the mode until/for <time> and then revert it'
                self._set_timer(time_to_wait, param, channel, mode)
                event.reply(
                    "Doing a {0}{1} {2}".format(
                        mode, " " + param if param else "", pretty.date(int(time.time() + time_to_wait))
                    )
                )
                return

        try:
            yield self.transport.issue_request("ircop.mode", channel, mode, param)
        except (ircop.OpFailed, ValueError) as e:
            event.reply(str(e))
            return

        if timespec:
            reversemode = {"-": "+", "+": "-"}[mode[0]] + mode[1]
            self._set_timer(time_to_wait, param, channel, reversemode)
            event.reply(
                "Doing a {0}{1} {2}".format(
                    reversemode, " " + param if param else "", pretty.date(int(time.time() + time_to_wait))
                ),
                direct=True,
                notice=True,
            )
Esempio n. 20
0
    def mode(self, event, match):
        channel = event.channel
        gd = match.groupdict()
        mode = gd['mode']
        param = gd['param']
        timespec = gd['timespec']

        if timespec:
            try:
                time_to_wait = parse_time(timespec)
            except ValueError as e:
                event.reply(e)
                return

            if timespec.startswith("in") or timespec.startswith("at"):
                # 'in' or 'at' indicate this is when we want to do the mode. as
                # opposed to 'do the mode until/for <time> and then revert it'
                self._set_timer(time_to_wait, param, channel, mode)
                event.reply(u"Doing a {0}{1} {2}".format(
                    mode, u" " + param if param else "",
                    pretty.date(int(time.time() + time_to_wait))))
                return

        try:
            yield self.transport.issue_request("ircop.mode", channel, mode,
                                               param)
        except (ircop.OpFailed, ValueError) as e:
            event.reply(str(e))
            return

        if timespec:
            reversemode = {"-": "+", "+": "-"}[mode[0]] + mode[1]
            self._set_timer(time_to_wait, param, channel, reversemode)
            event.reply(u"Doing a {0}{1} {2}".format(
                reversemode, u" " + param if param else "",
                pretty.date(int(time.time() + time_to_wait))),
                        direct=True,
                        notice=True)
Esempio n. 21
0
 def objectify(self, currentUid):
     response = {
         'postId' : self.page.id,
         'commentId' : self.id,
         'uid' : self.user.id,
         'username' : self.user.username,
         'userImage' : 'path/image.png',
         'body' : self.body,
         'date' : pretty.date( localtime( self.created ).replace(tzinfo=None) ),
     }
     if self.user.id == currentUid:
         response['editable'] = True
     else:
         response['editable'] = False
     return response
Esempio n. 22
0
    def quiet(self, event, match):
        groupdict = match.groupdict()
        target = groupdict['nick']
        duration = groupdict['timestr']
        channel = event.channel

        if duration:
            try:
                duration = parse_time(duration)
            except ValueError as e:
                # use the default (set below)
                duration = None

        if not duration and self.config['defaulttime']:
            duration = self.config['defaulttime']

        try:
            hostmask = (yield self._nick_to_hostmask(target))
        except ircutil.NoSuchNick:
            event.reply(
                "There is no user by that nick on the network. "
                "Try {0}!*@* to quiet anyone with that nick, or specify a full hostmask."
                .format(target, ))
            return
        except ValueError:
            event.reply(
                "Malformed hostmask. Hostmask syntax is <nick>!<username>@<host>",
                direct=True,
                notice=True)
            return

        try:
            yield self._do_moderequest(channel, 'q', hostmask, duration)
        except ircop.OpFailed as e:
            event.reply(str(e))

        if duration:
            event.reply(
                "Will unquiet {} {}".format(
                    hostmask,
                    # bug: pretty.date doesn't accept floats as timestamps
                    pretty.date(int(time.time() + duration))),
                direct=True,
                notice=True)
        else:
            event.reply("Warning: no duration given. Quiet will be permanent",
                        direct=True,
                        notice=True)
Esempio n. 23
0
def get_status():
    """Returns a dictionary containing site status information"""
    notice = get_notice()
    guests = models.Guest.count()
    subscribers = models.Subscriber.count()
    full_path_to_file = path.join(module_directory, "updated.txt")
    updated_file = open(full_path_to_file, "r")
    timestamp = datetime.fromtimestamp(float(updated_file.readline()))
    updated_file.close()
    updated = date(timestamp)

    return dict(notice=notice,
                version=__version__,
                updated=updated,
                guests=guests,
                subscribers=subscribers)
Esempio n. 24
0
File: hrf.py Progetto: Tubbz-alt/hrf
def _timestamp(message, user_timezone):
    '''Return a dict containing the timestamp in a bunch of formats.'''
    ts = message['timestamp']
    ts_obj = datetime.datetime.fromtimestamp(ts)
    utc = timezone('UTC')
    utc_obj = utc.normalize(utc.localize(ts_obj))
    localized = utc_obj.astimezone(timezone(user_timezone))

    return {
        'ago': pretty.date(ts_obj),
        'iso': localized.isoformat(),
        'usadate': localized.strftime("%m/%d/%Y"),
        'fulldate': localized.strftime("%A, %B %d, %Y"),
        'time': localized.strftime("%H:%M"),
        'epoch': str(ts),
    }
Esempio n. 25
0
File: hrf.py Progetto: awilfox/hrf
def _timestamp(message, user_timezone):
    '''Return a dict containing the timestamp in a bunch of formats.'''
    ts = message['timestamp']
    ts_obj = datetime.datetime.fromtimestamp(ts)
    utc = timezone('UTC')
    utc_obj = utc.normalize(utc.localize(ts_obj))
    localized = utc_obj.astimezone(timezone(user_timezone))

    return {
        'ago': pretty.date(ts_obj),
        'iso': localized.isoformat(),
        'usadate': localized.strftime("%m/%d/%Y"),
        'fulldate': localized.strftime("%A, %B %d, %Y"),
        'time': localized.strftime("%H:%M"),
        'epoch': str(ts),
    }
Esempio n. 26
0
    def _get_activities_(self):
        session = DBSession()
        base_query = session.query(Activity)\
                            .filter_by(user_id=self.session['user_id'])
        count_unseen = base_query.filter_by(seen_at=None).count()
        activities = base_query.order_by(Activity.created_at.desc()).limit(5)

        response = []
        for activity in activities:
            response.append({'message': activity.message,
                             'unseen': activity.unseen,
                             'absolute_path': activity.absolute_path,
                             'created_by': activity.created_by,
                             'created_at': pretty.date(activity.created_at)})

        transaction.commit()
        return count_unseen, response
Esempio n. 27
0
    def quiet(self, event, match):
        groupdict = match.groupdict()
        target = groupdict["nick"]
        duration = groupdict["timestr"]
        channel = event.channel

        if duration:
            try:
                duration = parse_time(duration)
            except ValueError as e:
                # use the default (set below)
                duration = None

        if not duration and self.config["defaulttime"]:
            duration = self.config["defaulttime"]

        try:
            hostmask = (yield self._nick_to_hostmask(target))
        except ircutil.NoSuchNick:
            event.reply(
                "There is no user by that nick on the network. "
                "Try {0}!*@* to quiet anyone with that nick, or specify a full hostmask.".format(target)
            )
            return
        except ValueError:
            event.reply("Malformed hostmask. Hostmask syntax is <nick>!<username>@<host>", direct=True, notice=True)
            return

        try:
            yield self._do_moderequest(channel, "q", hostmask, duration)
        except ircop.OpFailed as e:
            event.reply(str(e))

        if duration:
            event.reply(
                "Will unquiet {} {}".format(
                    hostmask,
                    # bug: pretty.date doesn't accept floats as timestamps
                    pretty.date(int(time.time() + duration)),
                ),
                direct=True,
                notice=True,
            )
        else:
            event.reply("Warning: no duration given. Quiet will be permanent", direct=True, notice=True)
Esempio n. 28
0
def list_containers(client: docker.Client, args, state: dict):
    containers = client.containers(all=args.all, quiet=args.quiet)

    if args.pprint:
        pprint(containers)
        return

    if args.json:
        print(json.dumps(containers, indent=4, sort_keys=True))
        return

    table = []
    if args.quiet:
        headers = ()
    else:
        headers = ["ID", "NAME", "IMAGE", "CMD", "CREATED", "STATUS", "PORTS"]

    for container in containers:
        row = []
        table.append(row)

        if args.quiet:
            row.append(container['Id'])
            continue

        row.append(container['Id'][:12])
        row.append(container['Names'][0][1:])
        row.append(container['Image'])
        row.append(container['Command'])

        created_seconds = container['Created']
        created_date = datetime.fromtimestamp(created_seconds)
        row.append(re.sub(r"\.[0-9]+", '', pretty.date(created_date, short=True)))

        row.append(container['Status'])

        ports = ""
        if 'Ports' in container:
            ports = ', '.join([_port_string(p) for p in container['Ports']])
        row.append(ports)

    print(tabulate(table, headers=headers, tablefmt="plain"))
Esempio n. 29
0
def surprise():  
    url='https://www.devrant.io/api/devrant/rants/surprise?app=3'
    response = requests.get(url)
    print response
    tags = []
    data = response.json()
    surprise_dic = {}
    surprise_dic['name'] = data['rant']['user_username']
    surprise_dic['img'] = data['rant']['attached_image'] or {"url":"#"}
    surprise_dic['image'] = str(surprise_dic['img']['url'] or '#')
    tags = data['rant']['tags']
    surprise_dic['tags'] = tags
    surprise_dic['comments'] = str(data['rant']['num_comments'] or 0)
    surprise_dic['text'] = str(data['rant']['text'] or None)
    surprise_dic['score'] = data['rant']['score']   
    surprise_dic['time'] = pretty.date(data['rant']['created_time'])
    surprise_dic['id'] = data['rant']['id']        
    surprise_dic['user_id'] = data['rant']['user_id']
    surprise_dic['user_score'] = data['rant']['user_score']
    return surprise_dic
Esempio n. 30
0
        def convert_image_dict(a):
            """
            Drop some keys and change some values to pretty-print image dict.
            """
            b = {}
            for k, v in a.items():
                if k not in ['RepoTags', 'RepoDigests', 'Labels', 'Size']:
                    b[k] = v
                if k == 'Created' and v and re_digits.search(str(v)):
                    b[k] = pretty.date(v)
                if k == 'VirtualSize':
                    b[k] = filesize(v)

            # If we have more than one repo tag, return as many dicts
            for rt in a['RepoTags']:
                repo, tag = rt.rsplit(':', 1)
                c = {}
                c.update(b)
                c['Repository'] = repo
                c['Tag'] = tag
                yield c
Esempio n. 31
0
    def __init__(self, name, address):
        self.name = name
        self.address = address

        try:
            addr = REPORT_FILES.format(self.address)
            self.report = json.load(open(addr))
            self.error = self.report.get("error", None)
            dt = datetime.strptime(self.report["date"], '%Y-%m-%d %H:%M')
            self.report_date = self.report["date"] + " ({})".format(
                pretty.date(dt))

            if self.error:
                self.uptime = self.error + ": " + self.report.get(
                    "description")
                self.headers = []
            else:
                self.uptime = self.report["uptime"]["text"]
                self.headers = [r.keys()[0] for r in monitor.short_reports]
        except:
            import sys
            print sys.exc_info()
            self.report = None
            self.uptime = "No report for this server yet"
            self.report_date = "Unknown"
            self.headers = []

        self.short_reports = []

        for header in self.headers:
            try:
                report_json = self.report["short_reports"][header]
                short_report = ShortReport(report_json["value"],
                                           report_json["measure"],
                                           report_json["text"])
                self.short_reports.append(short_report)
            except:
                self.short_reports.append(
                    ShortReport(100, "%",
                                "No report for data [{}]".format(header)))
Esempio n. 32
0
    def read_tweets(self, param):
        nickname = param
        username = self.app.addressbook.get_twitter_username(nickname.lower())
        if not username:
            self.app.say("Sorry, I cannot find the twitter username")
            return
        statuses = self.twitter.get_tweets(username)

        sentences = []
        for status in statuses:
            # Twitter returns GMT time in the format like this:
            # Mon Sep 16 06:57:38 +0000 2013
            # Python 2.x does not support %z, so converting to "GMT"
            tweeted_at = datetime.datetime.strptime(
                    status["created_at"].replace("+0000", "GMT"),
                    "%a %b %d %H:%M:%S %Z %Y")
            tweeted_at = tweeted_at - datetime.timedelta(seconds=time.timezone - 3600 * time.daylight)
            tweeted_at_pretty = pretty.date(tweeted_at)

            sentences.append(status["text"])
            sentences.append(tweeted_at_pretty)
        self.app.recite(sentences)
Esempio n. 33
0
    def bans(self, event, match):
        """A user has issued the bans command, a query to see who is banned and
        for how long.
        
        """
        reply = event.reply

        groupdict = match.groupdict()
        mask = groupdict['mask']
        if not mask:
            mask = "all"

        LaterItem = namedtuple("LaterItem",
                               ["channel", "time", "mask", "mode"])

        # Filter out all but bans and quiets. also put in a list of namedtuples
        # so it's easier to work with
        laters = [
            LaterItem(time=int(x[0]), mask=x[1], channel=x[2], mode=x[3])
            for x in self.config['laters'] if x[3][1] in "bq"
        ]

        # Sort in the order of the namedtuple parameters: by channel and then by time
        laters.sort()

        if mask != "all":
            laters = [x for x in laters if x.mask == mask]
            if not laters:
                reply("No pending events for {0}".format(mask))
                return

        for later in laters:
            when = pretty.date(later.time)
            reply("In {channel} setting {mode} {mask} {when}".format(
                channel=later.channel,
                mode=later.mode,
                mask=later.mask,
                when=when))
Esempio n. 34
0
    def bans(self, event, match):
        """A user has issued the bans command, a query to see who is banned and
        for how long.
        
        """
        reply = event.reply

        groupdict = match.groupdict()
        mask = groupdict["mask"]
        if not mask:
            mask = "all"

        LaterItem = namedtuple("LaterItem", ["channel", "time", "mask", "mode"])

        # Filter out all but bans and quiets. also put in a list of namedtuples
        # so it's easier to work with
        laters = [
            LaterItem(time=int(x[0]), mask=x[1], channel=x[2], mode=x[3])
            for x in self.config["laters"]
            if x[3][1] in "bq"
        ]

        # Sort in the order of the namedtuple parameters: by channel and then by time
        laters.sort()

        if mask != "all":
            laters = [x for x in laters if x.mask == mask]
            if not laters:
                reply("No pending events for {0}".format(mask))
                return

        for later in laters:
            when = pretty.date(later.time)
            reply(
                "In {channel} setting {mode} {mask} {when}".format(
                    channel=later.channel, mode=later.mode, mask=later.mask, when=when
                )
            )
Esempio n. 35
0
 def time_ago(klass, time):
     if isinstance(time, basestring):
         time = dateutil.parser.parse(time)
     if time == NEVER:
         return "Never"
     else:
         p = pretty.date(time)
         p = p.replace(" ago", "")
         p = p.replace("years", "yr")
         p = p.replace("year", "yr")
         p = p.replace("minutes", "min")
         p = p.replace("seconds", "sec")
         p = p.replace("second", "sec")
         p = p.replace("minute", "min")
         p = p.replace("hours", "hr")
         p = p.replace("hour", "hr")
         p = p.replace("days", "d")
         p = p.replace("day", "d")
         p = p.replace("weeks", "wk")
         p = p.replace("week", "wk")
         p = p.replace("months", "mth")
         p = p.replace("month", "mth")
         return p
Esempio n. 36
0
    def containers(self, *_, **kwargs):
        """
        Return the list of containers. Equivalent of docker ps.
        :return: list of dicts
        """

        # Truncate by default.
        if 'trunc' in kwargs and kwargs['trunc'] is None:
            kwargs['trunc'] = True

        def format_names(names):
            """
            Container names start with /.
            Let's strip this for readability.
            """
            if isinstance(names, list):
                formatted = []
                for name in names:
                    if isinstance(name, six.string_types):
                        formatted.append(name.lstrip('/'))
                    else:
                        formatted.append(name)
                return formatted
            return names

        csdict = self.instance.containers(**kwargs)
        if len(csdict) > 0:

            if 'quiet' not in kwargs or not kwargs['quiet']:
                for i in range(len(csdict)):
                    csdict[i]['Names'] = format_names(csdict[i]['Names'])
                    csdict[i]['Created'] = pretty.date(csdict[i]['Created'])

            return csdict
        else:
            return ['There are no containers to list.']
Esempio n. 37
0
    def containers(self, *_, **kwargs):
        """
        Return the list of containers. Equivalent of docker ps.
        :return: list of dicts
        """

        # Truncate by default.
        if 'trunc' in kwargs and kwargs['trunc'] is None:
            kwargs['trunc'] = True

        def format_names(names):
            """
            Container names start with /.
            Let's strip this for readability.
            """
            if isinstance(names, list):
                formatted = []
                for name in names:
                    if isinstance(name, basestring):
                        formatted.append(name.lstrip('/'))
                    else:
                        formatted.append(name)
                return formatted
            return names

        csdict = self.instance.containers(**kwargs)
        if len(csdict) > 0:

            if 'quiet' not in kwargs or not kwargs['quiet']:
                for i in range(len(csdict)):
                    csdict[i]['Names'] = format_names(csdict[i]['Names'])
                    csdict[i]['Created'] = pretty.date(csdict[i]['Created'])

            return csdict
        else:
            return ['There are no containers to list.']
Esempio n. 38
0
    def default(self, country='no', bracket=1, arg3=None,arg4=None, **kwargs):
	try:
            if (country == 'admin'):
              #return self.admin(bracket,arg3,arg4)
              return self.admin(bracket,arg3,arg4,**kwargs)
            elif (country == 'faq'):
              mytemplate = Template(filename="%s/frontend/faq.html" % self.base, input_encoding='utf-8',
        output_encoding='utf-8')
              return mytemplate.render()
            elif (bracket == 'achievements'):
              rows = self.sc2.achievement_ladder(country)
              data = []
              for row in rows:
                (nrank, player, ap) = (row[0], row[1], row[2])
                aPlayer = {
                 'nrank' : nrank,
                 'player' : player,
                 'ap' : ap
                }
                data.append(aPlayer)
               
              mytemplate = Template(filename="%s/frontend/achievement.html" % self.base, input_encoding='utf-8',
        output_encoding='utf-8', default_filters=['decode.utf8'])
              return mytemplate.render(data=data, crawling=os.path.isfile("/tmp/daemon-sc2ladder.pid"))
            elif (country == 'graphs'):
              return self.graphs(bracket,arg3, **kwargs)
            elif (country == 'cup'):
              return self.cup(**kwargs)
            else:
              try:
                bracket = int(bracket)
              except ValueError:
                return None
              if(bracket<1 or bracket>4):
                return None
              
              query = "select \
          array_to_string(array_agg(p.nick), ',') as players, array_to_string(array_agg(p.bnet_id), ',') as playerids, array_to_string(array_agg(tp.fav_race), ',') as fav_race,array_to_string(array_agg(p.last_updated), ',') as last_updated, array_to_string(array_agg(p.cronjob), ',') as cronjob, s2.wins, s2.losses, s2.points, s2.national_rank, s2.region_rank, s2.bracket, s2.teamid, s2.division_id, s2.division_rank, s2.is_random, s2.league, s2.points_adj, s2.world_rank \
      FROM \
      ( \
          SELECT \
              rank() OVER(ORDER BY t.league,t.points desc) AS national_rank, t.bracket,t.division_id, t.division_rank, t.is_random, t.league, t.losses, t.wins, t.points, t.region_rank, t.world_rank, t.teamid, t.points_adj \
          FROM \
          ( \
                    select \
                    distinct on (t.teamid) \
                        t.teamid, t.bracket,t.division_id, t.division_rank, t.is_random, t.league, t.losses, t.wins, t.points, t.region_rank,t.world_rank, t.points_adj  \
                    FROM \
                        team t \
                    ORDER BY \
                         t.teamid \
          ) as t \
          JOIN  \
              teamplayer tp  \
                    ON (t.teamid = tp.teamid AND t.bracket=%i)  \
          JOIN  \
              player p  \
                    ON (tp.playerid = p.playerid)  \
          GROUP BY \
              t.teamid,p.country,t.bracket,t.division_id, t.division_rank, t.is_random, t.league, t.losses, t.wins, t.points, t.region_rank,t.world_rank, t.points_adj  \
          HAVING \
              count(p.country) = %i AND p.country = '%s' \
      ) as s2 \
      JOIN \
          teamplayer tp \
              ON (s2.teamid = tp.teamid) \
      JOIN \
          player p \
              ON (tp.playerid = p.playerid) \
      WHERE \
          s2.teamid in \
          ( \
              select \
                  t.teamid \
              from \
                  team t \
              JOIN \
                  teamplayer tp \
                      ON (t.teamid = tp.teamid AND t.bracket=%i) \
              JOIN \
                  player p \
                      ON (tp.playerid = p.playerid) \
              GROUP BY \
                  t.teamid,p.country \
              HAVING \
                  count(p.country) = %i AND p.country = '%s' \
          ) \
      GROUP by \
          s2.wins, s2.losses, s2.points, s2.national_rank, s2.region_rank,s2.world_rank, s2.bracket, s2.teamid, s2.division_id, s2.division_rank, s2.is_random, s2.league, s2.points_adj \
      ORDER BY \
          national_rank asc" % (bracket, bracket, country , bracket, bracket, country)    

              db_con = psycopg2.connect(database = self.database, host = self.dbhost, user = self.dbuser, password = self.dbpassword)
              cursor = db_con.cursor()
              cursor.execute(query)
              rows = cursor.fetchall()
              cursor.close()
              db_con.close()
              teams = []
              for row in rows:
                #players     | wins | losses | points | national_rank | region_rank | bracket | teamid
                (players, playerids, favteams, last_updated, cronjob, wins, losses, points, nrank, eurank, bracket, teamid, divisionid, divisionrank, israndom, league, pointsadj, wrank) = (row[0], row[1], row[2], row[3], row[4], row[5], row[6], row[7], row[8], row[9], row[10], row[11], row[12], row[13], row[14], row[15], row[16], row[17])
                #lu = [datetime.strptime(x.split(".")[0] , '%Y-%m-%d %H:%M:%S') for x in last_updated.split(",")]
                lu = [dateutil.parser.parse("%s %s" % (x.split(".")[0], "Z")) for x in last_updated.split(",")]
                cronjoblu = [dateutil.parser.parse("%s %s" % (x.split(".")[0], " CEST")) for x in cronjob.split(",")]
                #print lu
                if not pointsadj:
                  pointsadj = 0
                if not points:
                  points = 0
                newest = datetime(1970,1,1,tzinfo=dateutil.tz.tzutc())
                for y in lu:
                  if y > newest:
                    newest = y
                newestcj = datetime(1970,1,1,tzinfo=dateutil.tz.gettz("Europe/Oslo"))
                for y in cronjoblu:
                  if y > newestcj:
                    newestcj = y
                #print lu
                #test =  zip([pretty.date(datetime.strptime(x.split(".")[0], '%Y-%m-%d %H:%M:%S')) for x in lu], [pretty.date(datetime.strptime(y.split(".")[0], '%Y-%m-%d %H:%M:%S')) for y in cronjob.split(",")])
                #print test
                aTeam = {
                 'teamid' : teamid,
                 'bracket' : bracket,
                 'nrank' : nrank,
                 'eurank' : eurank,
                 'worldrank' : wrank,
                 'points' : points,
                 'wins' : wins,
                 'losses' : losses,
                 'divisionid' : divisionid,
                 'divisionrank' : divisionrank,
                 'israndom' : israndom,
                 'league' : self.sc2.league_from_int(league),
                 'players' : zip(players.split(","),playerids.split(","), favteams.split(",")),
                 'lastupdated' : zip(lu, cronjoblu),
                 'cronjoblastupdated' : pretty.date(newestcj),
                 'humanlastupdated' : pretty.date(newest.astimezone(dateutil.tz.gettz("Europe/Oslo"))),
                 'helper' : len(lu),
                 'historypoints' : points-pointsadj,
                 'pointsadj' : pointsadj
                 }
                #'humanlastupdated' : zip([pretty.date(datetime.strptime(x.split(".")[0], '%Y-%m-%d %H:%M:%S')) for x in lu], [pretty.date(datetime.strptime(y.split(".")[0], '%Y-%m-%d %H:%M:%S')) for y in cronjob.split(",")]),
                teams.append(aTeam)
              #print teams
              mytemplate = Template(filename="%s/frontend/index.html" % self.base, input_encoding='UTF-8', output_encoding='UTF-8', default_filters=['decode.utf8'])
              return mytemplate.render(data=teams, bracket=bracket, crawling=os.path.isfile("/tmp/daemon-sc2ladder.pid"))
              #return json.dumps({"teams" : teams})
        except Exception,e:
            exc_type, exc_value, exc_traceback = sys.exc_info()
            self.sc2.log("[%s] Broken: %s \n  %s" % (datetime.now(), e, repr(traceback.extract_tb(exc_traceback))))
            mytemplate = Template(filename="%s/frontend/broken.html" % self.base, input_encoding='utf-8', output_encoding='utf-8')
            return mytemplate.render()
Esempio n. 39
0
    def ban(self, event, match):
        groupdict = match.groupdict()
        # nick here could be a nick, a hostmask (with possible wildcards), or
        # an extban.
        target = groupdict["nick"]
        duration = groupdict["timestr"]
        channel = event.channel
        reason = "Banned by " + event.user.split("!")[0]

        if duration:
            try:
                duration = parse_time(duration)
            except ValueError as e:
                # Not parsable as a time? Use the string as a reason and use
                # the default time instead.
                reason = duration
                duration = None

        if not duration and self.config["defaulttime"]:
            duration = self.config["defaulttime"]

        if "@" not in target and "!" not in target and "$" not in target:
            # Just a nick was given. Do a kick on the target as given, but
            # still lookup the mask and do a ban on that.
            nick = target
            do_kick = True
        else:
            do_kick = False
            # Nick is only used for kicking, and for reply() calls.
            nick = target.split("!", 1)[0]

        # Unconditionally pass the target through _nick_to_hostmask. If target
        # is a nick, we get a hostmask out. If target is already a mask of some
        # sort or an extban, we get the result passed through, but with some
        # syntax checking.
        try:
            hostmask = (yield self._nick_to_hostmask(target))
        except ircutil.NoSuchNick:
            event.reply(
                "There is no user by that nick on the network. "
                "Try {0}!*@* to ban anyone with that nick, or specify a full hostmask.".format(nick)
            )
            return
        except ircutil.WhoisTimedout:
            event.reply("That's odd, the whois I did on %s didn't work. Sorry." % nick)
            return
        except ValueError:
            event.reply("Malformed hostmask. Hostmask syntax is <nick>!<username>@<host>", direct=True, notice=True)
            return

        log.msg("issuing ban for {0}".format(hostmask))
        ban_d = self._do_moderequest(channel, "b", hostmask, duration)

        if do_kick:
            log.msg("issuing kick for {0} to go with the ban".format(nick))
            kick_d = self.transport.issue_request("ircop.kick", channel=channel, target=nick, reason=reason)
        else:
            # Silence the static analysis
            kick_d = defer.succeed(None)

        try:
            yield ban_d
            if do_kick:
                yield kick_d
        except ircop.OpFailed as e:
            event.reply(str(e))

        if duration:
            event.reply(
                "Will unban {} {}".format(
                    hostmask,
                    # bug: pretty.date doesn't accept floats as timestamps
                    pretty.date(int(time.time() + duration)),
                ),
                direct=True,
                notice=True,
            )
        else:
            event.reply("Warning: no duration given. Ban will be permanent", direct=True, notice=True)
Esempio n. 40
0
 def timeago(date):
     return pretty.date(date)
Esempio n. 41
0
 def __unicode__(self):
     return pretty.date(self.createDateTime) + " - " + self.result_text
Esempio n. 42
0
def feed():
    channels = request.args.get('ch')
    ch = channels.split('|m|')
    i = 0
    cl = []
    feed = []
    colors = ['info', 'success', 'warning', '', 'danger']
    while i < len(ch):
        tmp = ch[i].split('-_-')
        response = urllib2.urlopen(
            'https://slack.com/api/channels.history?token=' + session["auth"] +
            '&channel=' + tmp[0])
        cn = tmp[1][0]
        cn = cn.upper()
        co_i = i
        if co_i > len(colors):
            co_i = co_i - len(colors)
        color = colors[co_i]
        data = json.load(response)
        j = 0
        while j < len(data["messages"]):
            if data["messages"][j]["text"] == "":
                ts = data["messages"][j]["ts"]
                dt = datetime.utcfromtimestamp(float(ts))
                timeinfo = pretty.date(dt)
                text = data["messages"][j]["attachments"][0]["text"]
                matches = re.findall(r'\<(.+?)\>', text)
                k = 0
                while k < len(matches):
                    tag = matches[k].split("|")
                    try:
                        code = "<a href=\"" + tag[
                            0] + "\" target=\"_blank\">" + tag[1] + "</a>"
                    except Exception:
                        code = "<a href=\"" + tag[
                            0] + "\" target=\"_blank\">" + tag[0] + "</a>"
                    text = text.replace('<' + matches[k] + '>', code)
                    k = k + 1
                pretext = data["messages"][j]["attachments"][0]["fallback"]
                matches = re.findall(r'\<(.+?)\>', pretext)
                k = 0
                while k < len(matches):
                    tag = matches[k].split("|")
                    try:
                        code = "<a href=\"" + tag[
                            0] + "\" target=\"_blank\">" + tag[1] + "</a>"
                    except Exception:
                        code = "<a href=\"" + tag[
                            0] + "\" target=\"_blank\">" + tag[0] + "</a>"
                    pretext = pretext.replace('<' + matches[k] + '>', code)
                    k = k + 1
                feed.append({
                    "ts": float(ts),
                    "text": text,
                    "pretext": pretext,
                    "cn": cn,
                    "fcn": tmp[1].capitalize(),
                    "color": color,
                    "tsd": timeinfo
                })
            else:
                ts = data["messages"][j]["ts"]
                dt = datetime.utcfromtimestamp(float(ts))
                timeinfo = pretty.date(dt)
                text = data["messages"][j]["text"]
                matches = re.findall(r'\<(.+?)\>', text)
                k = 0
                while k < len(matches):
                    tag = matches[k].split("|")
                    try:
                        code = "<a href=\"" + tag[
                            0] + "\" target=\"_blank\">" + tag[1] + "</a>"
                    except Exception:
                        code = "<a href=\"" + tag[
                            0] + "\" target=\"_blank\">" + tag[0] + "</a>"
                    text = text.replace('<' + matches[k] + '>', code)
                    k = k + 1
                feed.append({
                    "ts": float(ts),
                    "text": text,
                    "pretext": text,
                    "cn": cn,
                    "fcn": tmp[1].capitalize(),
                    "color": color,
                    "tsd": timeinfo
                })
            j = j + 1
        i = i + 1
    if not feed:
        data = {"status": 0, "data": "Failed!"}
        js = json.dumps(data)
        resp = Response(js, status=200, mimetype='application/json')
        return resp
    nfeed = sorted(feed, key=itemgetter('ts'), reverse=True)
    data = {"status": 1, "data": nfeed}
    js = json.dumps(data)
    resp = Response(js, status=200, mimetype='application/json')
    return resp
Esempio n. 43
0
    def get(self):
        start = request.args.get('start') or 0
        length = request.args.get('length') or -1
        radarrid = request.args.get('radarrid')

        upgradable_movies = []
        upgradable_movies_not_perfect = []
        if settings.general.getboolean('upgrade_subs'):
            days_to_upgrade_subs = settings.general.days_to_upgrade_subs
            minimum_timestamp = (
                (datetime.datetime.now() -
                 timedelta(days=int(days_to_upgrade_subs))) -
                datetime.datetime(1970, 1, 1)).total_seconds()

            if settings.general.getboolean('upgrade_manual'):
                query_actions = [1, 2, 3, 6]
            else:
                query_actions = [1, 3]

            upgradable_movies_conditions = [
                (TableHistoryMovie.action.in_(query_actions)),
                (TableHistoryMovie.timestamp > minimum_timestamp),
                (TableHistoryMovie.score.is_null(False))
            ]
            upgradable_movies_conditions += get_exclusion_clause('movie')
            upgradable_movies = TableHistoryMovie.select(TableHistoryMovie.video_path,
                                                         fn.MAX(TableHistoryMovie.timestamp).alias('timestamp'),
                                                         TableHistoryMovie.score,
                                                         TableMovies.tags,
                                                         TableMovies.monitored)\
                .join(TableMovies, on=(TableHistoryMovie.radarrId == TableMovies.radarrId))\
                .where(reduce(operator.and_, upgradable_movies_conditions))\
                .group_by(TableHistoryMovie.video_path)\
                .dicts()
            upgradable_movies = list(upgradable_movies)

            for upgradable_movie in upgradable_movies:
                if upgradable_movie['timestamp'] > minimum_timestamp:
                    try:
                        int(upgradable_movie['score'])
                    except ValueError:
                        pass
                    else:
                        if int(upgradable_movie['score']) < 120:
                            upgradable_movies_not_perfect.append(
                                upgradable_movie)

        query_conditions = [(TableMovies.title.is_null(False))]
        if radarrid:
            query_conditions.append((TableMovies.radarrId == radarrid))
        query_condition = reduce(operator.and_, query_conditions)

        movie_history = TableHistoryMovie.select(TableHistoryMovie.id,
                                                 TableHistoryMovie.action,
                                                 TableMovies.title,
                                                 TableHistoryMovie.timestamp,
                                                 TableHistoryMovie.description,
                                                 TableHistoryMovie.radarrId,
                                                 TableMovies.monitored,
                                                 TableHistoryMovie.video_path.alias('path'),
                                                 TableHistoryMovie.language,
                                                 TableMovies.tags,
                                                 TableHistoryMovie.score,
                                                 TableHistoryMovie.subs_id,
                                                 TableHistoryMovie.provider,
                                                 TableHistoryMovie.subtitles_path)\
            .join(TableMovies, on=(TableHistoryMovie.radarrId == TableMovies.radarrId))\
            .where(query_condition)\
            .order_by(TableHistoryMovie.timestamp.desc())\
            .limit(length)\
            .offset(start)\
            .dicts()
        movie_history = list(movie_history)

        blacklist_db = TableBlacklistMovie.select(
            TableBlacklistMovie.provider, TableBlacklistMovie.subs_id).dicts()
        blacklist_db = list(blacklist_db)

        for item in movie_history:
            # Mark movies as upgradable or not
            item.update({"upgradable": False})
            if {
                    "video_path": str(item['path']),
                    "timestamp": float(item['timestamp']),
                    "score": str(item['score']),
                    "tags": str(item['tags']),
                    "monitored": str(item['monitored'])
            } in upgradable_movies_not_perfect:  # noqa: E129
                if os.path.isfile(
                        path_mappings.path_replace_movie(
                            item['subtitles_path'])):
                    item.update({"upgradable": True})

            del item['path']

            postprocessMovie(item)

            if item['score']:
                item['score'] = str(round(
                    (int(item['score']) * 100 / 120), 2)) + "%"

            # Make timestamp pretty
            if item['timestamp']:
                item["raw_timestamp"] = int(item['timestamp'])
                item["parsed_timestamp"] = datetime.datetime.fromtimestamp(
                    int(item['timestamp'])).strftime('%x %X')
                item['timestamp'] = pretty.date(item["raw_timestamp"])

            # Check if subtitles is blacklisted
            item.update({"blacklisted": False})
            if item['action'] not in [0, 4, 5]:
                for blacklisted_item in blacklist_db:
                    if blacklisted_item['provider'] == item[
                            'provider'] and blacklisted_item[
                                'subs_id'] == item['subs_id']:  # noqa: E125
                        item.update({"blacklisted": True})
                        break

        count = TableHistoryMovie.select()\
            .join(TableMovies, on=(TableHistoryMovie.radarrId == TableMovies.radarrId))\
            .where(TableMovies.title.is_null(False))\
            .count()

        return jsonify(data=movie_history, total=count)
Esempio n. 44
0
def pretty_date(value, short=None):
    if short:
        return pretty.date(value, False, True, False)
    else:
        return pretty.date(value)
Esempio n. 45
0
 def human_last_seen(self, _clock=_clock_):
     ago = _clock.datetime_now() - datetime.fromtimestamp(self.last_seen)
     return pretty.date(_clock.datetime_now() - ago)
Esempio n. 46
0
 def get_created_date_friendly(self):
     print "PRETTY: ", pretty.date(self.created_date)
     return "TEST"
Esempio n. 47
0
 def pub_date_delta(self, lang):
     if lang == Lang.ru:
         return distance_of_time_in_words(self.date)
     else:
         return date(self.date)
Esempio n. 48
0
def system():
    def get_time_from_interval(interval):
        interval_clean = interval.split('[')
        interval_clean = interval_clean[1][:-1]
        interval_split = interval_clean.split(':')

        hour = interval_split[0]
        minute = interval_split[1].lstrip("0")
        second = interval_split[2].lstrip("0")

        text = "every "
        if hour != "0":
            text = text + hour
            if hour == "1":
                text = text + " hour"
            else:
                text = text + " hours"

            if minute != "" and second != "":
                text = text + ", "
            elif minute == "" and second != "":
                text = text + " and "
            elif minute != "" and second == "":
                text = text + " and "
        if minute != "":
            text = text + minute
            if minute == "1":
                text = text + " minute"
            else:
                text = text + " minutes"

            if second != "":
                text = text + " and "
        if second != "":
            text = text + second
            if second == "1":
                text = text + " second"
            else:
                text = text + " seconds"

        return text

    def get_time_from_cron(cron):
        text = "at "
        hour = str(cron[5])
        minute = str(cron[6])
        second = str(cron[7])

        if hour != "0" and hour != "*":
            text = text + hour
            if hour == "0" or hour == "1":
                text = text + " hour"
            else:
                text = text + " hours"

            if minute != "*" and second != "0":
                text = text + ", "
            elif minute == "*" and second != "0":
                text = text + " and "
            elif minute != "0" and minute != "*" and second == "0":
                text = text + " and "
        if minute != "0" and minute != "*":
            text = text + minute
            if minute == "0" or minute == "1":
                text = text + " minute"
            else:
                text = text + " minutes"

            if second != "0" and second != "*":
                text = text + " and "
        if second != "0" and second != "*":
            text = text + second
            if second == "0" or second == "1":
                text = text + " second"
            else:
                text = text + " seconds"

        return text

    task_list = []
    for job in scheduler.get_jobs():
        if job.trigger.__str__().startswith('interval'):
            task_list.append([
                job.name,
                get_time_from_interval(str(job.trigger)),
                pretty.date(job.next_run_time.replace(tzinfo=None)), job.id
            ])
        elif job.trigger.__str__().startswith('cron'):
            task_list.append([
                job.name,
                get_time_from_cron(job.trigger.fields),
                pretty.date(job.next_run_time.replace(tzinfo=None)), job.id
            ])

    i = 0
    with open(os.path.join(os.path.dirname(__file__),
                           'data/log/oscarr.log')) as f:
        for i, l in enumerate(f, 1):
            pass
        row_count = i
        max_page = int(math.ceil(row_count / 50.0))

    return template('system',
                    __file__=__file__,
                    oscarr_version=oscarr_version,
                    base_url=base_url,
                    task_list=task_list,
                    row_count=row_count,
                    max_page=max_page)
Esempio n. 49
0
 def updatelength(self):
     now = datetime.utcnow().replace(tzinfo=utc)
     length = now - self.updated
     return pretty.date(self.updated)
Esempio n. 50
0
def addPrettyDate(quote):
    quote['date_pretty'] = pretty.date(quote['datetime'])
    return quote
Esempio n. 51
0
File: commit.py Progetto: booo/gid
    def addDate(c):
        import pretty
        from datetime import datetime

        c["date"] = pretty.date(datetime.strptime(c["committer"]["date"], "%Y-%m-%d %H:%M:%S"))
                    elif label.name == "Blocked":
                        print('<span class="label label-danger">&nbsp;</span>')
                    else:
                        print('<span class="label label-success">&nbsp;</span>')

                # check if a member's name is present in the card's name,
                # if so, the card is own by that member
                if card_name.find("[%s]" % (member.username)) > -1:
                    print(
                        """%s<span class="label label-info">owner</span>"""
                        % (re.sub("\[[%s]*\]" % (member.username), "", card_name))
                    )

                    card.fetch()
                    if card.due != "":
                        print("due: %s" % pretty.date(datetime.strptime(card.due, "%Y-%m-%dT%H:%M:%S.000Z")))

                else:
                    print("%s" % (card_name))

                if (card.id in cardid_by_memberid[member.id]) and (card_name.find("[%s]" % (member.username)) == -1):
                    print("""&nbsp;<span class="label label-default">supporting</span>""")

                print("</p>")

        print("</div></div><!-- row -->")  # task

    print(HTML_END)
#    who_on_what_template = tmplt_env.get_template('who_on_what.html.j2')
#    print(who_on_what_template.render(members=syseng_board.get_members(), cards=wip_cards))
Esempio n. 53
0
    def ban(self, event, match):
        groupdict = match.groupdict()
        # nick here could be a nick, a hostmask (with possible wildcards), or
        # an extban.
        target = groupdict['nick']
        duration = groupdict['timestr']
        channel = event.channel
        reason = "Banned by " + event.user.split("!")[0]

        if duration:
            try:
                duration = parse_time(duration)
            except ValueError as e:
                # Not parsable as a time? Use the string as a reason and use
                # the default time instead.
                reason = duration
                duration = None

        if not duration and self.config['defaulttime']:
            duration = self.config['defaulttime']

        if "@" not in target and "!" not in target and "$" not in target:
            # Just a nick was given. Do a kick on the target as given, but
            # still lookup the mask and do a ban on that.
            nick = target
            do_kick = True
        else:
            do_kick = False
            # Nick is only used for kicking, and for reply() calls.
            nick = target.split("!", 1)[0]

        # Unconditionally pass the target through _nick_to_hostmask. If target
        # is a nick, we get a hostmask out. If target is already a mask of some
        # sort or an extban, we get the result passed through, but with some
        # syntax checking.
        try:
            hostmask = (yield self._nick_to_hostmask(target))
        except ircutil.NoSuchNick:
            event.reply(
                "There is no user by that nick on the network. "
                "Try {0}!*@* to ban anyone with that nick, or specify a full hostmask."
                .format(nick, ))
            return
        except ircutil.WhoisTimedout:
            event.reply(
                "That's odd, the whois I did on %s didn't work. Sorry." % nick)
            return
        except ValueError:
            event.reply(
                "Malformed hostmask. Hostmask syntax is <nick>!<username>@<host>",
                direct=True,
                notice=True)
            return

        log.msg("issuing ban for {0}".format(hostmask))
        ban_d = self._do_moderequest(channel, 'b', hostmask, duration)

        if do_kick:
            log.msg("issuing kick for {0} to go with the ban".format(nick))
            kick_d = self.transport.issue_request(
                "ircop.kick",
                channel=channel,
                target=nick,
                reason=reason,
            )
        else:
            # Silence the static analysis
            kick_d = defer.succeed(None)

        try:
            yield ban_d
            if do_kick:
                yield kick_d
        except ircop.OpFailed as e:
            event.reply(str(e))

        if duration:
            event.reply(
                "Will unban {} {}".format(
                    hostmask,
                    # bug: pretty.date doesn't accept floats as timestamps
                    pretty.date(int(time.time() + duration))),
                direct=True,
                notice=True)
        else:
            event.reply("Warning: no duration given. Ban will be permanent",
                        direct=True,
                        notice=True)
Esempio n. 54
0
 def human_last_seen(self, _clock=_clock_):
     ago = _clock.datetime_now() - datetime.fromtimestamp(self.last_seen)
     return pretty.date(_clock.datetime_now() - ago)
Esempio n. 55
0
def feed():
    channels = request.args.get('ch')
    ch = channels.split('|m|')
    i = 0
    cl = []
    feed = []
    colors = ['info', 'success', 'warning', '', 'danger']
    while i < len(ch):
        tmp = ch[i].split('-_-')
        response = urllib2.urlopen('https://slack.com/api/channels.history?token='+session["auth"]+'&channel='+tmp[0])
        cn = tmp[1][0]
        cn = cn.upper()
        co_i = i
        if co_i > len(colors):
            co_i = co_i - len(colors)
        color = colors[co_i]
        data = json.load(response)
        j = 0
        while j < len(data["messages"]):
            if data["messages"][j]["text"] == "":
                ts = data["messages"][j]["ts"]
                dt = datetime.utcfromtimestamp(float(ts))
                timeinfo = pretty.date(dt)
                text = data["messages"][j]["attachments"][0]["text"]
                matches = re.findall(r'\<(.+?)\>',text)
                k = 0
                while k < len(matches):
                    tag = matches[k].split("|")
                    try:
                        code = "<a href=\""+tag[0]+"\" target=\"_blank\">"+tag[1]+"</a>"
                    except Exception:
                        code = "<a href=\""+tag[0]+"\" target=\"_blank\">"+tag[0]+"</a>"
                    text = text.replace('<'+matches[k]+'>',code)
                    k = k + 1
                pretext = data["messages"][j]["attachments"][0]["fallback"]
                matches = re.findall(r'\<(.+?)\>',pretext)
                k = 0
                while k < len(matches):
                    tag = matches[k].split("|")
                    try:
                        code = "<a href=\""+tag[0]+"\" target=\"_blank\">"+tag[1]+"</a>"
                    except Exception:
                        code = "<a href=\""+tag[0]+"\" target=\"_blank\">"+tag[0]+"</a>"
                    pretext = pretext.replace('<'+matches[k]+'>',code)
                    k = k + 1
                feed.append({"ts":float(ts), "text": text, "pretext": pretext, "cn": cn, "fcn": tmp[1].capitalize(), "color": color, "tsd":timeinfo})
            else:
                ts = data["messages"][j]["ts"]
                dt = datetime.utcfromtimestamp(float(ts))
                timeinfo = pretty.date(dt)
                text = data["messages"][j]["text"]
                matches = re.findall(r'\<(.+?)\>',text)
                k = 0
                while k < len(matches):
                    tag = matches[k].split("|")
                    try:
                        code = "<a href=\""+tag[0]+"\" target=\"_blank\">"+tag[1]+"</a>"
                    except Exception:
                        code = "<a href=\""+tag[0]+"\" target=\"_blank\">"+tag[0]+"</a>"
                    text = text.replace('<'+matches[k]+'>',code)
                    k = k + 1
                feed.append({"ts":float(ts), "text": text, "pretext": text, "cn": cn, "fcn": tmp[1].capitalize(), "color": color, "tsd":timeinfo})
            j = j + 1
        i = i + 1
    if not feed:
        data = {"status":0,"data":"Failed!"}
        js = json.dumps(data)
        resp = Response(js, status = 200, mimetype = 'application/json')
        return resp
    nfeed = sorted(feed, key=itemgetter('ts'), reverse=True)
    data = {"status":1,"data":nfeed}
    js = json.dumps(data)
    resp = Response(js, status = 200, mimetype = 'application/json')
    return resp