def test_timesince():
then = datetime(2010, 4, 12, 12, 30, 0)
then_timestamp = 1271075400.0
then_future = datetime(2012, 4, 12, 12, 30, 0)
now = datetime(2010, 5, 15, 1, 50, 0)
now_timestamp = 1273888200.0
# timestamp
assert time_since(then_timestamp, now_timestamp) == "1 month and 2 days"
# basic
assert time_since(then, now) == "1 month and 2 days"
# count
assert time_since(then, now, count=3) == "1 month, 2 days and 13 hours"
# future
assert time_since(then_future, now) == "0 minutes"
def seen(text, nick, chan, db, event, conn):
"""<nick> <channel> - tells when a nickname was last in active in one of my channels
:type db: sqlalchemy.orm.Session
:type event: ralybot.event.Event
:type conn: ralybot.client.Client
"""
if event.conn.nick.lower() == text.lower():
return "You need to get your eyes checked."
if text.lower() == nick.lower():
return "Have you looked in a mirror lately?"
if not re.match("^[A-Za-z0-9_|.\-\]\[]*$", text.lower()):
return "I can't look up that name, its impossible to use!"
db_init(db, conn.name)
last_seen = db.execute("select name, time, quote from seen_user where name like :name and chan = :chan",
{'name': text, 'chan': chan}).fetchone()
if last_seen:
reltime = timeformat.time_since(last_seen[1])
if last_seen[0] != text.lower(): # for glob matching
text = last_seen[0]
if last_seen[2][0:1] == "\x01":
return '{} was last seen {} ago: * {} {}'.format(text, reltime, text, last_seen[2][8:-1])
else:
return '{} was last seen {} ago saying: {}'.format(text, reltime, last_seen[2])
else:
return "I've never seen {} talking in this channel.".format(text)
def twitter_url(match):
# Find the Tweet ID from the URL
tweet_id = match.group(1)
# Get the Tweet using the tweepy API
if tw_api is None:
return
try:
tweet = tw_api.get_status(tweet_id)
user = tweet.user
except tweepy.error.TweepError:
return
# Format the return the text of the tweet
text = " ".join(tweet.text.split())
if user.verified:
prefix = "\u2713"
else:
prefix = ""
time = timeformat.time_since(tweet.created_at, datetime.utcnow())
return "{}@\x02{}\x02 ({}): {} ({} ago)".format(prefix, user.screen_name, user.name, text, time)
def format_output(item, show_url=False):
""" takes a reddit post and returns a formatted sting """
item["title"] = formatting.truncate(item["title"], 70)
item["link"] = short_url.format(item["id"])
raw_time = datetime.fromtimestamp(int(item["created_utc"]))
item["timesince"] = timeformat.time_since(raw_time, count=1, simple=True)
item["comments"] = formatting.pluralize(item["num_comments"], 'comment')
item["points"] = formatting.pluralize(item["score"], 'point')
if item["over_18"]:
item["warning"] = " \x02NSFW\x02"
else:
item["warning"] = ""
if show_url:
return "\x02{title} : {subreddit}\x02 - {comments}, {points}" \
" - \x02{author}\x02 {timesince} ago - {link}{warning}".format(**item)
else:
return "\x02{title} : {subreddit}\x02 - {comments}, {points}" \
" - \x02{author}\x02, {timesince} ago{warning}".format(**item)
for reminder in reminder_cache:
network, remind_time, added_time, user, message = reminder
if remind_time <= current_time:
if network not in bot.connections:
# connection is invalid
yield from add_reminder(async, db, network, remind_time, user)
yield from load_cache(async, db)
continue
conn = bot.connections[network]
if not conn.ready:
return
remind_text = colors.parse(time_since(added_time, count=2))
alert = colors.parse("{}, you have a reminder from $(b){}$(clear) ago!".format(user, remind_text))
conn.message(user, alert)
conn.message(user, '"{}"'.format(message))
delta = (remind_time-added_time).seconds
if delta > (30*60):
late_time = time_since(remind_time, count=2)
late = "(I'm sorry for delivering this message $(b){}$(clear) late," \
" it seems I was unable to deliver it on time)".format(late_time)
conn.message(user, colors.parse(late))
yield from delete_reminder(async, db, network, remind_time, user)
yield from load_cache(async, db)
def lastfm(text, nick, db, bot, notice):
"""[user] [dontsave] - displays the now playing (or last played) track of LastFM user [user]"""
api_key = bot.config.get("api_keys", {}).get("lastfm")
if not api_key:
return "Error: This command requires a LastFM API key."
# check if the user asked us not to save his details
dontsave = text.endswith(" dontsave")
if dontsave:
user = text[:-9].strip().lower()
else:
user = text
if not user:
user = get_account(nick)
if not user:
notice(lastfm.__doc__)
return
params = {'method': 'user.getrecenttracks',
'api_key': api_key, 'user': user, 'limit': 1}
request = requests.get(api_url, params=params)
if request.status_code != requests.codes.ok:
return "Failed to fetch info ({})".format(request.status_code)
response = request.json()
if 'error' in response:
return "Last.FM Error: {}.".format(response["message"])
if "track" not in response["recenttracks"] or len(response["recenttracks"]["track"]) == 0:
return 'No recent tracks for user "{}" found.'.format(user)
tracks = response["recenttracks"]["track"]
if type(tracks) == list:
# if the user is listening to something, the tracks entry is a list
# the first item is the current track
track = tracks[0]
status = 'is listening to the song'
ending = ''
elif type(tracks) == dict:
# otherwise, they aren't listening to anything right now, and
# the tracks entry is a dict representing the most recent track
track = tracks
status = 'last listened to the song'
# lets see how long ago they listened to it
time_listened = datetime.fromtimestamp(int(track["date"]["uts"]))
time_since = timeformat.time_since(time_listened)
ending = ' ({} ago)'.format(time_since)
else:
return "error: could not parse track listing"
title = track["name"]
album = track["album"]["#text"]
artist = track["artist"]["#text"]
url = web.try_shorten(track["url"])
out = '{} {} "{}"'.format(user, status, title)
if artist:
out += " by \x02{}\x0f".format(artist)
if album:
out += " from the album \x02{}\x0f".format(album)
if url:
out += " - {}".format(url)
# append ending based on what type it was
out += ending
if text and not dontsave:
db.execute("insert or replace into lastfm(nick, acc) values (:nick, :account)",
{'nick': nick.lower(), 'account': user})
db.commit()
load_cache(db)
return out
def twitter(text):
"""twitter <user> [n] -- Gets last/[n]th tweet from <user>"""
if tw_api is None:
return "This command requires a twitter API key."
if re.match(r'^\d+$', text):
# user is getting a tweet by id
try:
# get tweet by id
tweet = tw_api.get_status(text)
except tweepy.error.TweepError as e:
if "404" in e.reason:
return "Could not find tweet."
else:
return "Error: {}".format(e.reason)
user = tweet.user
elif re.match(r'^\w{1,15}$', text) or re.match(r'^\w{1,15}\s+\d+$', text):
# user is getting a tweet by name
if text.find(' ') == -1:
username = text
tweet_number = 0
else:
username, tweet_number = text.split()
tweet_number = int(tweet_number) - 1
if tweet_number > 200:
return "This command can only find the last \x02500\x02 tweets."
try:
# try to get user by username
user = tw_api.get_user(username)
except tweepy.error.TweepError as e:
if "404" in e.reason:
return "Could not find user."
else:
return "Error: {}".format(e.reason)
# get the users tweets
user_timeline = tw_api.user_timeline(id=user.id, count=tweet_number + 1)
# if the timeline is empty, return an error
if not user_timeline:
return "The user \x02{}\x02 has no tweets.".format(user.screen_name)
# grab the newest tweet from the users timeline
try:
tweet = user_timeline[tweet_number]
except IndexError:
tweet_count = len(user_timeline)
return "Thia user \x02{}\x02 only has \x02{}\x02 tweets.".format(user.screen_name, tweet_count)
elif re.match(r'^#\w+$', text):
# user is searching by hashtag
search = tw_api.search(text)
if not search:
return "No tweets found."
tweet = random.choice(search)
user = tweet.user
else:
# ???
return "Invalid Input"
# Format the return the text of the tweet
text = " ".join(tweet.text.split())
if user.verified:
prefix = "\u2713"
else:
prefix = ""
time = timeformat.time_since(tweet.created_at, datetime.utcnow())
return "{}@\x02{}\x02 ({}): {} ({} ago)".format(prefix, user.screen_name, user.name, text, time)