"""
15 | text = input.group().split()
16 | if len(text) < 2 or text[1].startswith('#'): return
17 | if text[1] == jenni.nick:
18 | if (input.nick not in jenni.config.admins):
19 | text[1] = input.nick
20 | else: text[1] = 'herself'
21 | if text[1] in jenni.config.admins:
22 | if (input.nick not in jenni.config.admins):
23 | text[1] = input.nick
24 | verb = random.choice(('slaps', 'kicks', 'destroys', 'annihilates', 'obliterates', 'drop kicks', 'curb stomps', 'backhands', 'punches', 'roundhouse kicks', 'rusty hooks', 'pwns', 'owns'))
25 | jenni.write(['PRIVMSG', input.sender, ' :\x01ACTION', verb, text[1], '\x01'])
26 | slap.commands = ['slap', 'slaps']
27 | slap.priority = 'medium'
28 | slap.rate = 60
29 |
30 | if __name__ == '__main__':
31 | print __doc__.strip()
32 |
--------------------------------------------------------------------------------
/modules/southpark.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env python
2 | """
3 | southpark.py - jenni Southpark Module
4 | Copyright 2011-2013, yano (yanovich.net) and Kenneth Sham (Kays)
5 | Licensed under the Eiffel Forum License 2.
6 |
7 | More info:
8 | * jenni: https://github.com/myano/jenni/
9 | * Phenny: http://inamidst.com/phenny/
10 | """
11 |
12 | from datetime import datetime, timedelta
13 | import web, time, re
14 |
15 | STRINGS = 'The next new episode of South Park will air on \x0300%s\x03, which is in: %s.'
16 |
17 | HTMLEntities = {
18 | ' ' : ' ',
19 | '<' : '<',
20 | '>' : '>',
21 | '&' : '&',
22 | '"' : '"',
23 | ''' : "'"
24 | }
25 |
26 | cache = {
27 | 'TIMES' : None,
28 | 'NEW-EPI' : None
29 | }
30 | cachets = {
31 | 'TIMES' : None,
32 | 'NEW-EPI' : None
33 | }
34 |
35 | months = {
36 | 'January' : 1,
37 | 'February' : 2,
38 | 'March' : 3,
39 | 'April' : 4,
40 | 'May' : 5,
41 | 'June' : 6,
42 | 'July' : 7,
43 | 'August' : 8,
44 | 'September' : 9,
45 | 'October' : 10,
46 | 'November' : 11,
47 | 'December' : 12
48 | }
49 |
50 | cachetsreset = timedelta(hours=6)
51 | maxtitlelen = 0
52 | maxepilen = 0
53 |
54 | def htmlDecode (html):
55 | for k, v in HTMLEntities.iteritems(): html = html.replace(k, v)
56 | return html
57 |
58 | def southpark (jenni, input):
59 | global cache, cachets
60 | text = input.group().split()
61 | if len(text) > 1:
62 | if text[1] == 'cleartimes':
63 | cache['TIMES'] = None
64 | cachets['TIMES'] = None
65 | jenni.reply("Southpark times successfully cleared.")
66 | return
67 | elif text[1] == 'clearnewep':
68 | cache['NEW-EPI'] = None
69 | cachets['NEW-EPI'] = None
70 | jenni.reply("New episodes cleared from cache.")
71 | elif text[1] == 'times':
72 | southparktimes(jenni,input)
73 | return
74 | else:
75 | getNewShowDate(jenni)
76 | southpark.commands = ['southpark']
77 | southpark.priority = 'low'
78 | southpark.rate = 30
79 |
80 | def getNewShowDate (jenni):
81 | global cache, cachets
82 | tsnow = datetime.now()
83 | if cache['NEW-EPI'] is not None and cachets['NEW-EPI'] is not None and tsnow - cachets['NEW-EPI'] <= cachetsreset:
84 | gc = getcountdown(cache['NEW-EPI'])
85 | msg = STRINGS % (cache['NEW-EPI'], gc)
86 | jenni.say(msg)
87 | return
88 |
89 | today = time.localtime()
90 | src = web.get('https://en.wikipedia.org/wiki/List_of_South_Park_episodes')
91 | parts = src.split('Season 15 (2011)')
92 | cont = parts.pop()
93 | parts = cont.split('Shorts and unaired episodes')
94 | cont = parts[0]
95 | tds = cont.split('')
96 | data = None
97 | for i in range(len(tds)):
98 | m = re.match('^[A-Z][a-z]{2,8} \d{1,2}, \d{4}', tds[i])
99 | if m is None:
100 | continue
101 | else:
102 | dt = time.strptime(m.group(), "%B %d, %Y")
103 | if dt < today:
104 | continue
105 | else:
106 | cache['NEW-EPI'] = m.group()
107 | cachets['NEW-EPI'] = tsnow
108 | rcd = getcountdown(m.group())
109 | msg = STRINGS % (m.group(), rcd)
110 | jenni.say(msg)
111 | break
112 |
113 | def getcountdown (x):
114 | mon = x.split()[0]
115 | day = (x.split()[1][:-1])
116 | yr = int(x.split()[2])
117 | month = months[mon]
118 | diff = datetime(int(yr), int(month), int(day), 22, 00, 00) - datetime.today()
119 | weeks, days = divmod(diff.days, 7)
120 | minutes, seconds = divmod(diff.seconds, 60)
121 | hours, minutes = divmod(minutes, 60)
122 | return "%s days, %s hours, %s minutes, and %s seconds" % (days, hours, minutes, seconds)
123 |
124 | def southparktimes (jenni, input):
125 | global cache, cachets, maxtitlelen, maxepilen
126 | tsnow = datetime.now()
127 | if cache['TIMES'] is not None and cachets['TIMES'] is not None and tsnow - cachets['TIMES'] <= cachetsreset:
128 | printListings(jenni)
129 | return
130 |
131 | src = web.get('http://www.comedycentral.com/tv_schedule/index.jhtml?seriesId=11600&forever=please')
132 | parts = src.split('')
133 | cont = parts[1]
134 | parts = cont.split(' ')
135 | cont = parts[0]
136 | schedule = cont.split(' ')
137 | del schedule[0]
138 |
139 | info = []
140 | count = 5
141 | for s in schedule:
142 | s = s.replace('\n',' ')
143 | s = htmlDecode(s)
144 |
145 | ## gets the date
146 | sidx = s.index(' ')
147 | send = s.index(' ', sidx)
148 | if sidx == -1 or send == -1: break
149 |
150 | m = re.search('>([^<]{2,})$', s[sidx:send])
151 | if m is None: break
152 |
153 | date = m.group(1).strip()
154 | sdate = time.strptime(date, '%A %b %d %Y')
155 |
156 | ## get episodes for the s-th date
157 | tepi = s.split(' ')
163 | send = t.index('', sidx)
164 |
165 | if sidx == -1 or send == -1: break
166 |
167 | stime = t[sidx+6:send].strip()
168 |
169 | ## gets the schedule episode name
170 | sidx = t.index('', send)
171 | send = t.index('', sidx)
172 |
173 | if sidx == -1 or send == -1: break
174 |
175 | stitle = t[sidx+3:send].strip()
176 | m = re.search('\(([^)]+)\)$', stitle)
177 | if m is None: break
178 | sepi = str(int(m.group(1)))
179 | if len(sepi) > maxepilen: maxepilen = len(sepi)
180 | stitle = stitle.replace(m.group(), '')
181 | lenstitle = len(stitle)
182 | if lenstitle > maxtitlelen: maxtitlelen = lenstitle
183 |
184 | ## gets the schedule episode desc
185 | sidx = send
186 | send = t.index('', sidx)
187 |
188 | if send == -1: break
189 |
190 | m = re.search('>([^<]{2,})$', t[sidx:send])
191 |
192 | if m is None: break
193 |
194 | sdesc = m.group(1).strip()
195 |
196 | info.append([sdate, sepi, stitle, stime])
197 |
198 | count -= 1
199 | if count == 0: break
200 | if count == 0: break
201 | cache['TIMES'] = info
202 | cachets['TIMES'] = tsnow
203 | printListings(jenni)
204 |
205 | def printListings (jenni):
206 | for i in cache['TIMES']:
207 | jenni.say('%s: #%s - \x02%s\x02 %s (%s) %s' % (time.strftime('%a %b %d', i[0]), i[1]+' '*(maxepilen-len(i[1])), i[2], ' '*(maxtitlelen-len(i[2])+5) , i[3], 'Comedy Central'))
208 |
209 | if __name__ == '__main__':
210 | print __doc__.strip()
211 |
--------------------------------------------------------------------------------
/modules/spotify.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/python
2 |
3 | """
4 | spotify.py - An api interface for spotify lookups
5 | Copyright 2015 - 2016 Micheal Harker
6 | Copyright 2012 Patrick Andrew
7 |
8 | Licensed under the Eiffel Forum License, version 2
9 |
10 | 1. Permission is hereby granted to use, copy, modify and/or
11 | distribute this package, provided that:
12 | * copyright notices are retained unchanged,
13 | * any distribution of this package, whether modified or not,
14 | includes this license text.
15 | 2. Permission is hereby also granted to distribute binary programs
16 | which depend on this package. If the binary program depends on a
17 | modified version of this package, you are encouraged to publicly
18 | release the modified version of this package.
19 |
20 | THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT WARRANTY. ANY EXPRESS OR
21 | IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
22 | WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
23 | DISCLAIMED. IN NO EVENT SHALL THE AUTHORS BE LIABLE TO ANY PARTY FOR ANY
24 | DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25 | DAMAGES ARISING IN ANY WAY OUT OF THE USE OF THIS PACKAGE.
26 | """
27 |
28 | import json
29 | import sys
30 | from datetime import timedelta
31 |
32 | from modules import proxy
33 |
34 |
35 | class NotModifiedError(Exception):
36 | def __init__(self):
37 | super(NotModifiedError, self).__init__(
38 | "The data hasn't changed since your last request.")
39 |
40 |
41 | class ForbiddenError(Exception):
42 | def __init__(self):
43 | super(ForbiddenError, self).__init__(
44 | "The rate-limiting has kicked in. Please try again later.")
45 |
46 |
47 | class NotFoundException(LookupError):
48 | def __init__(self):
49 | super(NotFoundException, self).__init__(
50 | "Could not find that Spotify URI.")
51 |
52 |
53 | class BadRequestException(LookupError):
54 | def __init__(self):
55 | super(BadRequestException, self).__init__(
56 | "The request was not understood.")
57 |
58 |
59 | class InternalServerError(Exception):
60 | def __init__(self):
61 | super(InternalServerError, self).__init__(
62 | "The server encounted an unexpected problem.")
63 |
64 |
65 | class ServiceUnavailable(Exception):
66 | def __init__(self):
67 | super(ServiceUnavailable, self).__init__(
68 | "The API is temporarily unavailable.")
69 |
70 | SpotifyStatusCodes = {
71 | 304: NotModifiedError,
72 | 400: BadRequestException,
73 | 403: ForbiddenError,
74 | 404: NotFoundException,
75 | 500: InternalServerError,
76 | 503: ServiceUnavailable
77 | }
78 |
79 | TRACK_MSG = '"{0}{1}{0}" [{0}{2}{0}] by {3} from "{0}{4}{0}".'
80 | EXPLICIT_TRACK_MSG = '[{0}E{0}]" {0}{1}{0}" [{0}{2}{0}] by {3} from "{0}{4}{0}".'
81 | ALBUM_MSG = '"{0}{1}{0}" by {2}, released in {0}{3}{0}.'
82 | ARTIST_MSG = 'Artist: {0}{1}{0}'
83 |
84 | API_URL = "api.spotify.com"
85 | API_ENDPOINT = "/v1"
86 |
87 |
88 | def lookup(typ, objid):
89 | url = "https://%s%s/%ss/%s" % (API_URL, API_ENDPOINT, typ, objid)
90 |
91 | success, response = proxy.get_more(url)
92 |
93 | if not success:
94 | raise Exception("Unable to connect to proxy: {0}".format(response))
95 |
96 | if response['code'] == 200:
97 | result = json.loads(response['read'])
98 | return result
99 |
100 | try:
101 | raise SpotifyStatusCodes[response['code']]
102 | except KeyError, ValueError:
103 | raise Exception("HTTP Error {0}".format(response['code']))
104 |
105 |
106 | def notify(jenni, recipient, text):
107 | jenni.write(('NOTICE', recipient), text)
108 |
109 |
110 | def print_album(jenni, album):
111 | artist_names = [artist['name'] for artist in album['artists']]
112 | artists = artist_list(artist_names)
113 |
114 | message = ALBUM_MSG.format(
115 | "\x02",
116 | album['name'].encode('utf-8'),
117 | artists.encode('utf-8'),
118 | album['release_date'][:4]
119 | )
120 |
121 | jenni.say(message)
122 |
123 |
124 | def print_artist(jenni, artist):
125 | message = ARTIST_MSG.format(
126 | "\x02",
127 | artist['name'].encode('utf-8')
128 | )
129 |
130 | jenni.say(message)
131 |
132 |
133 | def print_track(jenni, track):
134 | length = str(timedelta(seconds=(track['duration_ms']/1000)))[2:7]
135 | if length[0] == '0':
136 | length = length[1:]
137 |
138 | artist_names = [artist['name'] for artist in track['artists']]
139 | artists = artist_list(artist_names)
140 |
141 | if track['explicit']:
142 | message_format = EXPLICIT_TRACK_MSG
143 | else:
144 | message_format = TRACK_MSG
145 |
146 | message = message_format.format(
147 | "\x02",
148 | track['name'].encode('utf-8'),
149 | length,
150 | artists.encode('utf-8'),
151 | track['album']['name'].encode('utf-8')
152 | )
153 |
154 | jenni.say(message)
155 |
156 |
157 | def query(jenni, input):
158 | typ = (input.group(1) or input.group(3)).lower() # type of object we wanna lookup
159 | objid = input.group(2) or input.group(4) # ID of the object like a track, artist, etc.
160 |
161 | formatters = {
162 | 'track': print_track,
163 | 'album': print_album,
164 | 'artist': print_artist
165 | }
166 |
167 | if typ not in formatters:
168 | notify(jenni, input.nick, "Unknown object type: {0}".format(typ))
169 | return
170 |
171 | try:
172 | result = lookup(typ, objid)
173 | except Exception as e:
174 | notify(jenni, input.nick, str(e))
175 | return
176 |
177 | try:
178 | formatters[typ](jenni, result)
179 | except Exception as e:
180 | notify(jenni, input.nick, str(e))
181 |
182 | query.rule = r'(?i).*\bspotify:(\S+):(\S+)|^\.sp(?:otify)? +https?://open\.spotify\.com/(\S+)/(\S+)$'
183 | query.priority = 'low'
184 |
185 |
186 | def artist_list(data):
187 | if (len(data) > 1):
188 | artists = ""
189 | for artist in data[:-1]:
190 | artists += "{0}{1}{0}".format("\x02", artist)
191 | if artist is not data[-2]:
192 | artists += ", "
193 | artists += " and {0}{1}{0}".format("\x02", data[-1])
194 | return artists
195 | else:
196 | return "{0}{1}{0}".format("\x02", data[0])
197 |
198 |
199 | if __name__ == '__main__':
200 | print __doc__.strip()
201 |
--------------------------------------------------------------------------------
/modules/startup.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env python
2 | """
3 | startup.py - jenni Startup Module
4 | Copyright 2009-2013, yano (yanovich.net)
5 | Copyright 2008-2013, Sean B. Palmer (inamidst.com)
6 | Licensed under the Eiffel Forum License 2.
7 |
8 | More info:
9 | * jenni: https://github.com/myano/jenni/
10 | * Phenny: http://inamidst.com/phenny/
11 | """
12 |
13 | import threading, time
14 |
15 | def setup(jenni):
16 | # by clsn
17 | jenni.data = {}
18 | refresh_delay = 300.0
19 |
20 | if hasattr(jenni.config, 'refresh_delay'):
21 | try: refresh_delay = float(jenni.config.refresh_delay)
22 | except: pass
23 |
24 | def close():
25 | print "Nobody PONGed our PING, restarting"
26 | jenni.handle_close()
27 |
28 | def pingloop():
29 | timer = threading.Timer(refresh_delay, close, ())
30 | jenni.data['startup.setup.timer'] = timer
31 | jenni.data['startup.setup.timer'].start()
32 | # print "PING!"
33 | jenni.write(('PING', jenni.config.host))
34 | jenni.data['startup.setup.pingloop'] = pingloop
35 |
36 | def pong(jenni, input):
37 | try:
38 | # print "PONG!"
39 | jenni.data['startup.setup.timer'].cancel()
40 | time.sleep(refresh_delay + 60.0)
41 | pingloop()
42 | except: pass
43 | pong.event = 'PONG'
44 | pong.thread = True
45 | pong.rule = r'.*'
46 | jenni.variables['pong'] = pong
47 |
48 | # Need to wrap handle_connect to start the loop.
49 | inner_handle_connect = jenni.handle_connect
50 |
51 | def outer_handle_connect():
52 | inner_handle_connect()
53 | if jenni.data.get('startup.setup.pingloop'):
54 | jenni.data['startup.setup.pingloop']()
55 |
56 | jenni.handle_connect = outer_handle_connect
57 |
58 | def startup(jenni, input):
59 | import time
60 |
61 | if hasattr(jenni.config, 'serverpass') and not jenni.auth_attempted:
62 | jenni.write(('PASS', jenni.config.serverpass))
63 |
64 | if not jenni.is_authenticated and hasattr(jenni.config, 'password'):
65 | if hasattr(jenni.config, 'user') and jenni.config.user is not None:
66 | user = jenni.config.user
67 | else:
68 | user = jenni.config.nick
69 |
70 | jenni.msg('NickServ', 'IDENTIFY %s %s' % (user, jenni.config.password))
71 | time.sleep(10)
72 |
73 | # Cf. http://swhack.com/logs/2005-12-05#T19-32-36
74 | for channel in jenni.channels:
75 | jenni.write(('JOIN', channel))
76 | time.sleep(0.5)
77 | startup.rule = r'(.*)'
78 | startup.event = '251'
79 | startup.priority = 'low'
80 |
81 | # Method for populating op/hop/voice information in channels on join
82 | def privs_on_join(jenni, input):
83 | if not input.mode_target or not input.mode_target.startswith('#'):
84 | return
85 |
86 | channel = input.mode_target
87 | if input.names and len(input.names) > 0:
88 | split_names = input.names.split()
89 | for name in split_names:
90 | nick_mode, nick = name[0], name[1:]
91 | if nick_mode == '@':
92 | jenni.add_op(channel, nick)
93 | elif nick_mode == '%':
94 | jenni.add_halfop(channel, nick)
95 | elif nick_mode == '+':
96 | jenni.add_voice(channel, nick)
97 | privs_on_join.rule = r'(.*)'
98 | privs_on_join.event = '353'
99 | privs_on_join.priority = 'high'
100 |
101 | # Method for tracking changes to ops/hops/voices in channels
102 | def track_priv_change(jenni, input):
103 | if not input.sender or not input.sender.startswith('#'):
104 | return
105 |
106 | channel = input.sender
107 |
108 | if input.mode:
109 | add_mode = input.mode.startswith('+')
110 | del_mode = input.mode.startswith('-')
111 |
112 | # Check that this is a mode change and that it is a mode change on a user
113 | if (add_mode or del_mode) and input.mode_target and len(input.mode_target) > 0:
114 | mode_change = input.mode[1:]
115 | mode_target = input.mode_target
116 |
117 | if add_mode:
118 | if mode_change == 'o':
119 | jenni.add_op(channel, mode_target)
120 | elif mode_change == 'h':
121 | jenni.add_halfop(channel, mode_target)
122 | elif mode_change == 'v':
123 | jenni.add_voice(channel, mode_target)
124 | else:
125 | if mode_change == 'o':
126 | jenni.del_op(channel, mode_target)
127 | elif mode_change == 'h':
128 | jenni.del_halfop(channel, mode_target)
129 | elif mode_change == 'v':
130 | jenni.del_voice(channel, mode_target)
131 | track_priv_change.rule = r'(.*)'
132 | track_priv_change.event = 'MODE'
133 | track_priv_change.priority = 'high'
134 |
135 | if __name__ == '__main__':
136 | print __doc__.strip()
137 |
--------------------------------------------------------------------------------
/modules/strawpoll.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env python
2 | '''
3 | strawpoll.py - jenni Strawpoll Module
4 | Copyright 2015, Bekey
5 | Licensed under the Eiffel Forum License 2.
6 |
7 | More info:
8 | * jenni: https://github.com/myano/jenni/
9 | * Phenny: http://inamidst.com/phenny/
10 | '''
11 |
12 | import urllib2
13 | import json
14 | import shlex
15 | import getopt
16 |
17 | def create_strawpoll_json(title, arguments, multi, permissive):
18 | data = {'options':arguments,'title':title,'multi':multi,'permissive':permissive}
19 | return json.dumps(data)
20 |
21 | def create_strawpoll_link(json_data):
22 | req = urllib2.Request('http://strawpoll.me/api/v2/polls')
23 | req.add_header('Content-Type', 'application/json')
24 | req.add_header('User-Agent', 'Mozilla/5.0 (Jenni)')
25 |
26 | response = urllib2.urlopen(req, json_data).read()
27 | strawpoll_id = json.loads(response)['id']
28 | return "http://strawpoll.me/" + str(strawpoll_id)
29 |
30 | def strawpoll(jenni, input):
31 | """ .strawpoll --title='Example Title'
32 | [--multi]
33 | [--permissive]
34 | 'Option 1'
35 | 'Option 2'
36 | 'Option 3'
37 |
38 | Creates a strawpoll with the given title and options
39 | """
40 |
41 | if not input.admin:
42 | return;
43 |
44 | arguments = shlex.split(input)
45 | try:
46 | optlist, arguments = getopt.getopt(arguments[1:], 't:mp', ['title=', 'multi', 'permissive'])
47 | except getopt.GetoptError as err:
48 | return jenni.say(str(err))
49 |
50 | multi = False
51 | permissive = False
52 | title = "N/A"
53 |
54 | for o, a in optlist:
55 | if o in ("-m", "--multi"):
56 | multi = True
57 | elif o in ("-p", "--permissive"):
58 | permissive = True
59 | elif o in ("-t", "--title"):
60 | title = a
61 | else:
62 | return jenni.say("Unrecognized arguments.")
63 |
64 | if len(arguments) == 0:
65 | return jenni.say("No options found.")
66 |
67 | if len(arguments) > 30:
68 | return jenni.say("Cannot create strawpoll with more than 30 options.")
69 |
70 | try:
71 | data = create_strawpoll_json(title, arguments, multi, permissive)
72 | link = create_strawpoll_link(data)
73 | except Exception, e:
74 | return jenni.say(str(e))
75 |
76 | if not hasattr(jenni.config, "last_strawpoll"):
77 | jenni.config.last_strawpoll = {}
78 |
79 | channel = input.sender
80 | jenni.config.last_strawpoll[channel] = link
81 |
82 | jenni.say(link)
83 |
84 | strawpoll.commands = ['straw', 'strawpoll']
85 | strawpoll.priority = 'medium'
86 | strawpoll.example = '.strawpoll -t "Title Here" "Option 1" "Option 2" "Option 3"'
87 |
88 | def resend_strawpoll(jenni, input):
89 | """.resendstrawpoll - Resends the last strawpoll link created"""
90 | if hasattr(jenni.config, "last_strawpoll"):
91 | channel = input.sender
92 | if channel in jenni.config.last_strawpoll:
93 | return jenni.say(jenni.config.last_strawpoll[channel])
94 | jenni.say("No Strawpoll links have been created yet.")
95 |
96 | resend_strawpoll.commands = ['rsp', 'restraw', 'resendstrawpoll']
97 | resend_strawpoll.priority = 'low'
98 | resend_strawpoll.example = '.rsp'
99 |
100 | if __name__ == "__main__":
101 | print __doc__.strip()
102 |
--------------------------------------------------------------------------------
/modules/tell.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env python
2 | """
3 | tell.py - jenni Tell and Ask Module
4 | Copyright 2012-2013, yano (yanovich.net)
5 | Copyright 2008, Sean B. Palmer (inamidst.com)
6 | Licensed under the Eiffel Forum License 2.
7 |
8 | More info:
9 | * jenni: https://github.com/myano/jenni/
10 | * Phenny: http://inamidst.com/phenny/
11 | """
12 |
13 | import os, re, time, random
14 | import threading
15 |
16 | maximum = 4
17 |
18 |
19 | def loadReminders(fn, lock):
20 | lock.acquire()
21 | try:
22 | result = {}
23 | f = open(fn)
24 | for line in f:
25 | line = line.strip()
26 | if line:
27 | try: tellee, teller, verb, timenow, msg = line.split('\t', 4)
28 | except ValueError: continue # @@ hmm
29 | result.setdefault(tellee, []).append((teller, verb, timenow, msg))
30 | f.close()
31 | finally:
32 | lock.release()
33 | return result
34 |
35 |
36 | def dumpReminders(fn, data, lock):
37 | lock.acquire()
38 | try:
39 | f = open(fn, 'w')
40 | for tellee in data.iterkeys():
41 | for remindon in data[tellee]:
42 | line = '\t'.join((tellee,) + remindon)
43 | try: f.write(line + '\n')
44 | except IOError: break
45 | try: f.close()
46 | except IOError: pass
47 | finally:
48 | lock.release()
49 | return True
50 |
51 |
52 | def setup(self):
53 | fn = self.nick + '-' + self.config.host + '.tell.db'
54 | self.tell_filename = os.path.join(os.path.expanduser('~/.jenni'), fn)
55 | if not os.path.exists(self.tell_filename):
56 | try: f = open(self.tell_filename, 'w')
57 | except OSError: pass
58 | else:
59 | f.write('')
60 | f.close()
61 | self.tell_lock = threading.Lock()
62 | self.reminders = loadReminders(self.tell_filename, self.tell_lock) # @@ tell
63 |
64 |
65 | def f_remind(jenni, input):
66 | teller = input.nick
67 |
68 | #if hasattr(jenni.config, 'logchan_pm'):
69 | #jenni.msg(jenni.config.logchan_pm, 'TELL used by %s in %s: %s' % (str(input.nick), str(input.sender), input))
70 |
71 | #if not input.group(2) or input.group(3):
72 | if not input.group(2):
73 | return jenni.say('Please tell me who and what to tell people.')
74 |
75 | # @@ Multiple comma-separated tellees? Cf. Terje, #swhack, 2006-04-15
76 | line_prefix = (input.group()).lower()
77 | if input.group() and (line_prefix.startswith('.tell') or line_prefix.startswith('.yell')):
78 | verb = 'tell'.encode('utf-8')
79 | line = input.groups()
80 | line_txt = line[1].split()
81 | tellee = line_txt[0]
82 | msg = ' '.join(line_txt[1:])
83 | if line_prefix.startswith('.yell'):
84 | msg = (msg).upper()
85 | else:
86 | verb, tellee, msg = input.groups()
87 |
88 | ## handle unicode
89 | verb = verb.encode('utf-8')
90 | tellee = tellee.encode('utf-8')
91 | msg = msg.encode('utf-8')
92 |
93 | tellee = tellee.rstrip('.,:;')
94 |
95 | if not os.path.exists(jenni.tell_filename):
96 | return
97 |
98 | timenow = time.strftime('%d %b %H:%MZ', time.gmtime())
99 | whogets = list()
100 | for tellee in tellee.split(','):
101 | if len(tellee) > 20:
102 | jenni.say('Nickname %s is too long.' % (tellee))
103 | continue
104 | if not tellee.lower() in (teller.lower(), jenni.nick): # @@
105 | jenni.tell_lock.acquire()
106 | try:
107 | if not tellee.lower() in whogets:
108 | whogets.append(tellee)
109 | if tellee not in jenni.reminders:
110 | jenni.reminders[tellee] = [(teller, verb, timenow, msg)]
111 | else:
112 | jenni.reminders[tellee].append((teller, verb, timenow, msg))
113 | finally:
114 | jenni.tell_lock.release()
115 | response = str()
116 | if teller.lower() == tellee.lower() or tellee.lower() == 'me':
117 | response = 'You can %s yourself that.' % (verb)
118 | elif tellee.lower() == jenni.nick.lower():
119 | response = "Hey, I'm not as stupid as Monty you know!"
120 | else:
121 | response = "I'll pass that on when %s is around."
122 | if len(whogets) > 1:
123 | listing = ', '.join(whogets[:-1]) + ', or ' + whogets[-1]
124 | response = response % (listing)
125 | elif len(whogets) == 1:
126 | response = response % (whogets[0])
127 | else:
128 | return jenni.say('Huh?')
129 |
130 | if not whogets: # Only get cute if there are not legits
131 | rand = random.random()
132 | if rand > 0.9999: response = 'yeah, yeah'
133 | elif rand > 0.999: response = 'yeah, sure, whatever'
134 |
135 | jenni.reply(response)
136 |
137 | dumpReminders(jenni.tell_filename, jenni.reminders, jenni.tell_lock) # @@ tell
138 | f_remind.rule = ('$nick', ['[tTyY]ell', '[aA]sk'], r'(\S+) (.*)')
139 | f_remind.commands = ['tell', 'to', 'yell']
140 |
141 |
142 | def getReminders(jenni, channel, key, tellee):
143 | lines = []
144 | template = '%s: %s <%s> %s %s %s'
145 | today = time.strftime('%d %b', time.gmtime())
146 |
147 | jenni.tell_lock.acquire()
148 |
149 | try:
150 | for (teller, verb, datetime, msg) in jenni.reminders[key]:
151 | if datetime.startswith(today):
152 | datetime = datetime[len(today) + 1:]
153 | lines.append(template % (tellee, datetime, teller, verb, tellee, msg))
154 |
155 | try: del jenni.reminders[key]
156 | except KeyError: jenni.msg(channel, 'Er...')
157 | finally:
158 | jenni.tell_lock.release()
159 |
160 | return lines
161 |
162 |
163 | def message(jenni, input):
164 | #if not input.sender.startswith('#'): return
165 |
166 | tellee = input.nick
167 | channel = input.sender
168 |
169 | if not os: return
170 | if not os.path.exists(jenni.tell_filename):
171 | return
172 |
173 | reminders = []
174 | remkeys = list(reversed(sorted(jenni.reminders.keys())))
175 | for remkey in remkeys:
176 | if not remkey.endswith('*') or remkey.endswith(':'):
177 | if tellee.lower() == remkey.lower():
178 | reminders.extend(getReminders(jenni, channel, remkey, tellee))
179 | elif tellee.lower().startswith(remkey.rstrip('*:').lower()):
180 | reminders.extend(getReminders(jenni, channel, remkey, tellee))
181 |
182 | for line in reminders[:maximum]:
183 | jenni.say(line)
184 |
185 | if reminders[maximum:]:
186 | jenni.say('Further messages sent privately')
187 | for line in reminders[maximum:]:
188 | jenni.msg(tellee, line)
189 |
190 | if len(jenni.reminders.keys()) != remkeys:
191 | dumpReminders(jenni.tell_filename, jenni.reminders, jenni.tell_lock) # @@ tell
192 | message.rule = r'(.*)'
193 | message.priority = 'low'
194 |
195 | if __name__ == '__main__':
196 | print __doc__.strip()
197 |
--------------------------------------------------------------------------------
/modules/tld.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env python
2 | """
3 | tld.py - jenni Why Module
4 | Copyright 2009-2013, yano (yanovich.net)
5 | Licensed under the Eiffel Forum License 2.
6 |
7 | More info:
8 | * jenni: https://github.com/myano/jenni/
9 | * Phenny: http://inamidst.com/phenny/
10 | """
11 |
12 | import BeautifulSoup
13 | import datetime as dt
14 | import re
15 | import urllib2
16 | import web
17 |
18 | BS = BeautifulSoup.BeautifulSoup
19 |
20 | uri = 'https://en.wikipedia.org/wiki/List_of_Internet_top-level_domains'
21 | r_tag = re.compile(r'<(?!!)[^>]+>')
22 | r_quote = re.compile(r'\[.*?\]')
23 |
24 | soup = False
25 | last_updated = dt.datetime.now() - dt.timedelta(days=30)
26 |
27 |
28 | def gettld(jenni, input):
29 | '''.tld .sh -- displays information about a given top level domain.'''
30 | global soup
31 |
32 | text = input.group(2)
33 | if not text:
34 | jenni.reply("You didn't provide any input.")
35 | return
36 | text = text.split()[0]
37 | if text and text.startswith('.'):
38 | text = text[1:]
39 | text = text.encode('utf-8')
40 |
41 | if (dt.datetime.now() - last_updated) >= dt.timedelta(days=14):
42 | ## reloads cache if data becomes too old
43 | reload_cache()
44 |
45 | if not soup:
46 | reload_cache()
47 |
48 | tlds = soup.findAll('tr', {'valign': 'top'})
49 | for tld in tlds:
50 | tld_tds = tld('td')
51 | out = dict()
52 | if not text.startswith('.'):
53 | text = '.' + text
54 | if len(tld_tds[0]('a')) > 0 and tld_tds[0]('a')[0].text == text:
55 | if tld_tds[1]('a') and tld_tds[1]('img'):
56 | out['entity'] = tld_tds[1]('a')[0].text
57 | else:
58 | out['entity'] = tld_tds[1].text
59 | none_avail = 'N/A'
60 | out['expl'] = none_avail
61 | if tld_tds[2].text:
62 | out['expl'] = tld_tds[2].text
63 | out['notes'] = none_avail
64 | out['idn'] = none_avail
65 | out['dnssec'] = none_avail
66 | out['sld'] = none_avail
67 | out['ipv6'] = none_avail
68 |
69 | if len(tld_tds) >= 7:
70 | out['notes'] = str(tld_tds[3])
71 | out['idn'] = str(tld_tds[4].text)
72 | out['dnssec'] = str(tld_tds[5].text)
73 | out['sld'] = str(tld_tds[6].text)
74 | if len(tld_tds) == 8:
75 | out['ipv6'] = str(tld_tds[7].text)
76 | elif len(tld_tds) == 5:
77 | out['idn'] = str(tld_tds[3].text)
78 | out['dnssec'] = str(tld_tds[4].text)
79 |
80 | new_out = dict()
81 | for x in out:
82 | chomped = r_tag.sub('', out[x].strip())
83 | chomped = r_quote.sub('', chomped)
84 | if chomped == ' ':
85 | chomped = none_avail
86 | try:
87 | chomped = (chomped).encode('utf-8')
88 | except:
89 | pass
90 | chomped = (chomped).decode('utf-8')
91 | new_out[x] = chomped
92 |
93 | return jenni.say('Entity: %s (Explanation: %s, Notes: %s). IDN: %s, DNSSEC: %s, SLD: %s, IPv6: %s' % (new_out['entity'], new_out['expl'], new_out['notes'], new_out['idn'], new_out['dnssec'], new_out['sld'], new_out['ipv6']))
94 |
95 | return jenni.say('No matches found for TLD: %s' % (text))
96 |
97 | gettld.commands = ['tld']
98 | gettld.example = '.tld .it'
99 |
100 |
101 | def reload_cache():
102 | global last_updated
103 | global soup
104 |
105 | last_updated = dt.datetime.now()
106 | page = web.get(uri)
107 | soup = BS(page)
108 |
109 |
110 | def tld_cache(jenni, input):
111 | jenni.say('TLD cache from Wikipedia last updated: ' + str(last_updated))
112 |
113 | reload_cache()
114 |
115 | jenni.say('TLD cache is now current.')
116 | tld_cache.commands = ['tld-cache']
117 |
118 |
119 | if __name__ == '__main__':
120 | print __doc__.strip()
121 |
--------------------------------------------------------------------------------
/modules/twitter.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env python
2 | """
3 | twitter.py - jenni Twitter Module
4 | Copyright 2012-2013, yano (yanovich.net)
5 | Copyright 2012-2013, Sean B. Palmer (inamidst.com)
6 | Licensed under the Eiffel Forum License 2.
7 |
8 | More info:
9 | * jenni: https://github.com/myano/jenni/
10 | * Phenny: http://inamidst.com/phenny/
11 | """
12 |
13 | from htmlentitydefs import name2codepoint
14 | import json
15 | import oauth2 as oauth
16 | import re
17 | import time
18 | import urllib
19 | import urllib2
20 | import web
21 |
22 | from modules import unicode as uc
23 |
24 | r_username = re.compile(r'^[a-zA-Z0-9_]{1,15}$')
25 | r_link = re.compile(r'^https?://twitter.com/\S+$')
26 | r_p = re.compile(r'(?ims)(|]*>.*?')
22 | r_tag = re.compile(r'<(?!!)[^>]+>')
23 | r_whitespace = re.compile(r'[\t\r\n ]+')
24 | r_empty = re.compile(r'\S+')
25 | #
26 | r_redirect = re.compile(
27 | r'(?ims)class=.redirectText.>\s*')
40 | s = s.replace('<', '<')
41 | s = s.replace('&', '&')
42 | s = s.replace(' ', ' ')
43 | return s
44 |
45 | def text(html):
46 | html = r_empty.sub('', html)
47 | html = r_tag.sub('', html)
48 | html = r_whitespace.sub(' ', html)
49 | return unescape(html).strip()
50 |
51 | def search(term):
52 | try: import search
53 | except ImportError, e:
54 | print e
55 | return term
56 |
57 | if isinstance(term, unicode):
58 | term = term.encode('utf-8')
59 | else: term = term.decode('utf-8')
60 |
61 | term = term.replace('_', ' ')
62 | try: uri, url_only = search.duck_search('site:en.wikipedia.org %s' % term)
63 | except IndexError: return term
64 | if url_only and uri:
65 | return uri[len('https://en.wikipedia.org/wiki/'):]
66 | else: return term
67 |
68 |
69 | def wikipedia(term, language='en', last=False):
70 | global wikiuri
71 | if not '%' in term:
72 | if isinstance(term, unicode):
73 | t = term.encode('utf-8')
74 | else: t = term
75 | q = urllib.quote(t)
76 | u = wikiuri % (language, q)
77 | bytes = web.get(u)
78 | else: bytes = web.get(wikiuri % (language, term))
79 |
80 | if bytes.startswith('\x1f\x8b\x08\x00\x00\x00\x00\x00'):
81 | f = StringIO.StringIO(bytes)
82 | f.seek(0)
83 | gzip_file = gzip.GzipFile(fileobj=f)
84 | bytes = gzip_file.read()
85 | gzip_file.close()
86 | f.close()
87 |
88 | bytes = r_tr.sub('', bytes)
89 |
90 | if not last:
91 | r = r_redirect.search(bytes[:4096])
92 | if r:
93 | term = urllib.unquote(r.group(1))
94 | return wikipedia(term, language=language, last=True)
95 |
96 | paragraphs = r_paragraph.findall(bytes)
97 |
98 | if not paragraphs:
99 | if not last:
100 | term = search(term)
101 | return wikipedia(term, language=language, last=True)
102 | return None
103 |
104 | # Pre-process
105 | paragraphs = [para for para in paragraphs
106 | if (para and 'technical limitations' not in para
107 | and 'window.showTocToggle' not in para
108 | and 'Deletion_policy' not in para
109 | and 'Template:AfD_footer' not in para
110 | and not (para.startswith(' ') and
111 | para.endswith(' '))
112 | and not 'disambiguation)"' in para)
113 | and not '(images and media)' in para
114 | and not 'This article contains a' in para
115 | and not 'id="coordinates"' in para
116 | and not 'class="thumb' in para]
117 | # and not 'style="display:none"' in para]
118 |
119 | for i, para in enumerate(paragraphs):
120 | para = para.replace('', '|')
121 | para = para.replace('', '|')
122 | paragraphs[i] = text(para).strip()
123 |
124 | # Post-process
125 | paragraphs = [para for para in paragraphs if
126 | (para and not (para.endswith(':') and len(para) < 150))]
127 |
128 | para = text(paragraphs[0])
129 | m = r_sentence.match(para)
130 |
131 | if not m:
132 | if not last:
133 | term = search(term)
134 | return wikipedia(term, language=language, last=True)
135 | return None
136 | sentence = m.group(0)
137 |
138 | maxlength = 275
139 | if len(sentence) > maxlength:
140 | sentence = sentence[:maxlength]
141 | words = sentence[:-5].split(' ')
142 | words.pop()
143 | sentence = ' '.join(words) + ' [...]'
144 |
145 | if (('using the Article Wizard if you wish' in sentence)
146 | or ('or add a request for it' in sentence)
147 | or ('in existing articles' in sentence)):
148 | if not last:
149 | term = search(term)
150 | return wikipedia(term, language=language, last=True)
151 | return None
152 |
153 | sentence = '"' + sentence.replace('"', "'") + '"'
154 | sentence = sentence.decode('utf-8').encode('utf-8')
155 | wikiuri = wikiuri.decode('utf-8').encode('utf-8')
156 | term = term.decode('utf-8').encode('utf-8')
157 | return sentence + ' - ' + (wikiuri % (language, term))
158 |
159 | def wik(jenni, input):
160 | origterm = input.groups()[1]
161 | if not origterm:
162 | return jenni.say('Perhaps you meant ".wik Zen"?')
163 | origterm = origterm.encode('utf-8')
164 | origterm = origterm.strip()
165 |
166 | term = urllib.unquote(origterm)
167 | language = 'en'
168 | if term.startswith(':') and (' ' in term):
169 | a, b = term.split(' ', 1)
170 | a = a.lstrip(':')
171 | if a.isalpha():
172 | language, term = a, b
173 | term = term[0].upper() + term[1:]
174 | term = term.replace(' ', '_')
175 |
176 | try: result = wikipedia(term, language)
177 | except IOError:
178 | args = (language, wikiuri % (language, term))
179 | error = "Can't connect to %s.wikipedia.org (%s)" % args
180 | return jenni.say(error)
181 |
182 | if result is not None:
183 | jenni.say(result)
184 | else: jenni.say('Can\'t find anything in Wikipedia for "%s".' % origterm)
185 |
186 | wik.commands = ['w', 'wik', 'wiki']
187 | wik.priority = 'high'
188 | wik.rate = 5
189 |
190 | if __name__ == '__main__':
191 | print __doc__.strip()
192 |
--------------------------------------------------------------------------------
/modules/wikiquote.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env python
2 | """
3 | wikiquote.py - jenni Random Quote Module
4 | Copyright 2009-2013, yano (yanovich.net)
5 | Copyright 2008-2013, Sean B. Palmer (inamidst.com)
6 | Licensed under the Eiffel Forum License 2.
7 |
8 | Developed by kaneda (https://jbegleiter.com / https://github.com/kaneda)
9 |
10 | More info:
11 | * jenni: https://github.com/myano/jenni/
12 | * Phenny: http://inamidst.com/phenny/
13 | """
14 |
15 | import json
16 | from random import randrange
17 | import urllib
18 |
19 | try:
20 | from BeautifulSoup import BeautifulSoup as Soup
21 | except ImportError:
22 | raise ImportError("Could not find BeautifulSoup library,"
23 | "please install to use the wikiquote module")
24 |
25 | USER_AGENT = "JenniBot/1.0 (https://github.com/myano/jenni) JenniBot/1.0"
26 |
27 | class JenniURLopener(urllib.FancyURLopener):
28 | version = USER_AGENT
29 |
30 | urllib._urlopener = JenniURLopener()
31 |
32 | BASE_URL = "https://en.wikiquote.org/w/api.php?format=json&"
33 |
34 | LIMIT = "5000"
35 | MAX_TRIES = 10
36 |
37 | CATS = [
38 | "Category:Television_shows",
39 | "Category:Proverbs",
40 | "Category:Literary_works",
41 | "Category:Films",
42 | "Category:Philosophers"
43 | ]
44 |
45 | CAT_PREFIX = "Category:"
46 | IGNORE_PREFIX = "Wikiquote:"
47 |
48 | SUBCATS = "action=query&list=categorymembers&cmtype=subcat|page&cmprop=ids|title|type&cmlimit=" + LIMIT + "&cmtitle=%s"
49 | SECTIONS = "action=parse&prop=sections&pageid=%s"
50 | SECTION = "action=parse&pageid=%i§ion=%s"
51 |
52 | def choose_random_member(members):
53 | num_members = len(members)
54 | if num_members == 0: return None
55 |
56 | num_tries = 0
57 | random_member = None
58 |
59 | # Try 10 times
60 | while random_member == None and num_tries < MAX_TRIES:
61 | random_member = members[randrange(num_members)]
62 |
63 | # We only want a page or a subcategory
64 | if random_member["title"].startswith(IGNORE_PREFIX):
65 | random_member = None
66 |
67 | num_tries += 1
68 |
69 | return random_member
70 |
71 | def choose_random_section(sections):
72 | num_sections = len(sections)
73 | if num_sections == 0: return None
74 |
75 | num_tries = 0
76 | random_section = None
77 |
78 | # Try 10 times
79 | while random_section == None and num_tries < MAX_TRIES:
80 | random_section = sections[randrange(num_sections)]
81 | num_tries += 1
82 |
83 | return random_section
84 |
85 | def random_quote(jenni, cat):
86 | if cat is not None:
87 | if cat not in CATS:
88 | jenni.say("I don't know that category, please select from one of: {0}".format(', '.join(CATS)))
89 | return
90 | else:
91 | cat = CATS[randrange(len(CATS))]
92 |
93 | page_title = page_id = None
94 |
95 | # First drill down to the lowest category
96 | while(True):
97 | try:
98 | cat_url = BASE_URL + SUBCATS % cat
99 | content = json.loads(urllib.urlopen(cat_url).read())
100 | cat_members = content["query"]["categorymembers"]
101 |
102 | # Select at random
103 | random_member = choose_random_member(cat_members)
104 | if random_member is None:
105 | jenni.say("An error occurred fetching a subcategory")
106 | return
107 |
108 | if random_member["type"] == "subcat":
109 | cat = random_member["title"]
110 | else:
111 | page_title = random_member["title"]
112 | page_id = random_member["pageid"]
113 | break
114 | except Exception as e:
115 | jenni.say("An error occurred fetching a quote: {0}".format(e))
116 | return
117 |
118 | # Next select a random quote from the page
119 | try:
120 | page_url = BASE_URL + SECTIONS % page_id
121 | content = json.loads(urllib.urlopen(page_url).read())
122 | sections = content["parse"]["sections"]
123 |
124 | quote = None
125 | num_tries = 0
126 | while quote == None and num_tries < MAX_TRIES:
127 | section = choose_random_section(sections)
128 |
129 | if section is None:
130 | jenni.say("We accidentally chose a page with no quotes, sorry about that!")
131 | return
132 |
133 | section_index = randrange(len(sections)) + 1
134 |
135 | section_url = BASE_URL + SECTION % (page_id, section_index)
136 | content = json.loads(urllib.urlopen(section_url).read())
137 | section_title = content["parse"]["title"]
138 | html = Soup(content["parse"]["text"]["*"])
139 | all_quotes = []
140 | for ul in html.findAll('ul'):
141 | for li in ul.findAll('li'):
142 | all_quotes.append(li.text)
143 |
144 | for dd in html.findAll('dd'):
145 | all_quotes.append(dd.text.replace("","").replace("",""))
146 |
147 | len_all_quotes = len(all_quotes)
148 | if len_all_quotes == 0:
149 | num_tries += 1
150 | else:
151 | quote = all_quotes[randrange(len_all_quotes)]
152 |
153 | if quote is None:
154 | jenni.say("We accidentally chose a section of a page with no quotes, sorry about that!")
155 | return
156 |
157 | jenni.say("{0}: {1}".format(section_title, quote.encode('utf-8')))
158 | except Exception as e:
159 | jenni.say("An error occurred fetching a quote: {0}".format(e))
160 | return
161 |
162 | def wikiquote(jenni, input):
163 | origterm = input.groups()[1]
164 | if origterm:
165 | origterm = origterm.encode('utf-8')
166 | origterm = origterm.strip()
167 |
168 | error = None
169 |
170 | random_quote(jenni, origterm)
171 | wikiquote.commands = ['wq', 'wikiquote']
172 | wikiquote.priority = 'low'
173 | wikiquote.rate = 10
174 |
175 | def list_cats(jenni, input):
176 | jenni.say("WikiQuote categories I know: {0}".format(", ".join(CATS)))
177 | list_cats.commands = ['list_quote_cats', 'list_wikiquote_cats', 'ls_wq_cats']
178 | list_cats.priority = 'low'
179 |
180 | if __name__ == '__main__':
181 | print __doc__.strip()
182 |
--------------------------------------------------------------------------------
/modules/wiktionary.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env python
2 | """
3 | wiktionary.py - jenni Wiktionary Module
4 | Copyright 2009-2013, yano (yanovich.net)
5 | Copyright 2009-2013, Sean B. Palmer (inamidst.com)
6 | Licensed under the Eiffel Forum License 2.
7 |
8 | More info:
9 | * jenni: https://github.com/myano/jenni/
10 | * Phenny: http://inamidst.com/phenny/
11 | """
12 |
13 | import re
14 | import web
15 |
16 | uri = 'https://en.wiktionary.org/w/index.php?title=%s&printable=yes'
17 | r_tag = re.compile(r'<[^>]+>')
18 | r_ul = re.compile(r'(?ims)')
19 |
20 | def text(html):
21 | text = r_tag.sub('', html).strip()
22 | text = text.replace('\n', ' ')
23 | text = text.replace('\r', '')
24 | text = text.replace('(intransitive', '(intr.')
25 | text = text.replace('(transitive', '(trans.')
26 | return text
27 |
28 | def wiktionary(word):
29 | bytes = web.get(uri % web.urllib.quote(word.encode('utf-8')))
30 | bytes = r_ul.sub('', bytes)
31 |
32 | mode = None
33 | etymology = None
34 | definitions = {}
35 | for line in bytes.splitlines():
36 | if 'id="Etymology"' in line:
37 | mode = 'etymology'
38 | elif 'id="Noun"' in line:
39 | mode = 'noun'
40 | elif 'id="Verb"' in line:
41 | mode = 'verb'
42 | elif 'id="Adjective"' in line:
43 | mode = 'adjective'
44 | elif 'id="Adverb"' in line:
45 | mode = 'adverb'
46 | elif 'id="Interjection"' in line:
47 | mode = 'interjection'
48 | elif 'id="Particle"' in line:
49 | mode = 'particle'
50 | elif 'id="Preposition"' in line:
51 | mode = 'preposition'
52 | elif 'id="' in line:
53 | mode = None
54 |
55 | elif (mode == 'etmyology') and ('' in line):
56 | etymology = text(line)
57 | elif (mode is not None) and (' ' in line):
58 | definitions.setdefault(mode, []).append(text(line))
59 |
60 | if ' 300:
95 | result = result[:295] + '[...]'
96 | jenni.say(result)
97 | define.commands = ['dict', 'define', 'word']
98 | define.example = '.w bailiwick'
99 |
100 | if __name__ == '__main__':
101 | print __doc__.strip()
102 |
--------------------------------------------------------------------------------
/modules/woot.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env python
2 | """
3 | why.py - jenni Why Module
4 | Copyright 2009-2013, yano (yanovich.net)
5 | Licensed under the Eiffel Forum License 2.
6 |
7 | More info:
8 | * jenni: https://github.com/myano/jenni/
9 | * Phenny: http://inamidst.com/phenny/
10 | """
11 |
12 | import feedparser
13 |
14 | api = "https://api.woot.com/1/sales/current.rss/www.woot.com"
15 |
16 |
17 | def woot(jenni, input):
18 | """ .woot -- pulls the latest information from woot.com """
19 | output = str()
20 | parsed = feedparser.parse(api)
21 | if not parsed['entries']:
22 | jenni.reply("No item currently available.")
23 | return
24 | item = parsed['entries'][0]['woot_products']
25 | link = parsed['entries'][0]['link']
26 | price = parsed['entries'][0]['woot_price']
27 | s = parsed['entries'][0]['woot_soldoutpercentage']
28 | if len(s) == 1:
29 | soldout = 0
30 | else:
31 | soldout = int(s.split('.')[1]) * 10
32 | condition = parsed['entries'][0]['woot_condition']
33 | quantity = parsed['entries'][0]['woot_product']['quantity']
34 | woot_off = parsed['entries'][0]['woot_wootoff']
35 |
36 | base1 = "{0} -- \x02Price:\x02 {1}, \x02Soldout:\x02 {2}% \x02Condition:"
37 | base2 = "\x02 {3}, \x02Quantity:\x02 {4}, \x02Woot-Off:\x02 {5} -- {6}"
38 | base = base1 + base2
39 |
40 | link = link.split('?')[0]
41 |
42 | output = base.format(item, price, soldout, condition, quantity,
43 | woot_off, link.replace("http:", "https:"))
44 | jenni.reply(output)
45 | woot.commands = ['woot']
46 | woot.priority = 'low'
47 | woot.rate = 30
48 |
49 | if __name__ == '__main__':
50 | print __doc__.strip()
51 |
--------------------------------------------------------------------------------
/modules/xkcd.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env python
2 | '''
3 | xkcd.py - XKCD Module
4 | Copyright 2010-2014 yano (yanovich.net), and Morgan Goose
5 | Partially re-written by Paul Schellin (paulschellin@gmail.com) 2014
6 |
7 | Licensed under the Eiffel Forum License 2.
8 |
9 | More info:
10 | * jenni: https://github.com/myano/jenni/
11 | * Phenny: http://inamidst.com/phenny/
12 | '''
13 |
14 | import json
15 | import random
16 | import web
17 | import re
18 | from modules import unicode as uc
19 |
20 | '''
21 | Randall Munroe is nice and provides a simple JSON API for fetching comics.
22 |
23 | See this page:
24 | https://xkcd.com/json.html
25 |
26 |
27 | Can access:
28 | https://xkcd.com/info.0.json
29 | for the current comic, or:
30 | https://xkcd.com/614/info.0.json
31 | for the 614th comic.
32 |
33 | Each comic contains the following JSON keys:
34 |
35 | {
36 | "month": "10"
37 | ,"num": 1432
38 | , "link": ""
39 | , "year": "2014"
40 | , "news": ""
41 | , "safe_title": "The Sake of Argument"
42 | , "transcript": ""
43 | , "alt": "'It's not actually ... it's a DEVICE for EXPLORING a PLAUSIBLE REALITY that's not the one we're in, to gain a broader understanding about it.' 'oh, like a boat!' '...' 'Just for the sake of argument, we should get a boat! You can invite the Devil, too, if you want.'"
44 | , "img": "http:\/\/imgs.xkcd.com\/comics\/the_sake_of_argument.png"
45 | , "title": "The Sake of Argument"
46 | , "day": "10"
47 | }
48 |
49 | '''
50 |
51 | random.seed()
52 |
53 |
54 | def xkcd(jenni, input):
55 | '''.xkcd - Print all available information about the most recent (or specified) XKCD clip.'''
56 |
57 | def tryToGetJSON (site_url):
58 | try:
59 | page = web.get(xkcd_url)
60 | except:
61 | return jenni.say('Failed to access xkcd.com: <' + xkcd_url + '>')
62 | try:
63 | body = json.loads(page)
64 | except:
65 | return jenni.say('Failed to make use of data loaded by xkcd.com: <' + xkcd_url + '>')
66 | return body
67 |
68 |
69 | xkcd_url = 'https://xkcd.com/info.0.json'
70 |
71 | show_random_comic = False
72 |
73 | line = input.group(2)
74 | if line:
75 | if line.isdigit():
76 | xkcd_num = line.lstrip().rstrip()
77 | xkcd_url = 'https://xkcd.com/' + xkcd_num + '/info.0.json'
78 | elif any([line.lower() in ['r', 'ran', 'rand', 'random']]):
79 | show_random_comic = True
80 | else:
81 | jenni.say(u'Incorrect argument for .xkcd: ' + line)
82 |
83 |
84 | body = tryToGetJSON(xkcd_url)
85 |
86 | if show_random_comic:
87 | max_int = body['num']
88 | xkcd_rand_num = random.randint(0, max_int)
89 | xkcd_url = 'https://xkcd.com/' + str(xkcd_rand_num) + '/info.0.json'
90 | body = tryToGetJSON(xkcd_url)
91 |
92 |
93 | comic_date_str = body['year'] + u'-' + str(body['month']).zfill(2) + u'-' + str(body['day']).zfill(2)
94 | header_str = u'\x02xkcd #\x02' + str(body['num']) + u' (' + comic_date_str + u') \x02' + body['title'] + u'\x02'
95 | jenni.say(header_str)
96 |
97 | if body['transcript'].encode('UTF-8'):
98 | transcript_text = '\x02Transcript:\x02 ' + body['transcript']
99 | jenni.say(transcript_text)
100 |
101 |
102 | alt_text = u'\x02Alt text\x02: ' + body['alt']
103 | jenni.say(alt_text)
104 |
105 | img_ssl_link = u'[ ' + re.sub(r'http://', 'https://ssl', body['img']) + u' ]'
106 | jenni.say(img_ssl_link)
107 |
108 |
109 | xkcd.commands = ['xkcd']
110 | xkcd.example = '.xkcd (for most recent), .xkcd [comic number] (for specific comic), or .xkcd [r | ran | rand | random] (for a random comic)'
111 | xkcd.priority = 'medium'
112 |
113 | if __name__ == '__main__':
114 | print __doc__.strip()
115 |
--------------------------------------------------------------------------------
/tools.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env python
2 | """
3 | tools.py - Jenni Tools
4 | Copyright 2009-2013, yano (yanovich.net)
5 | Copyright 2008-2013, Sean B. Palmer (inamidst.com)
6 | Licensed under the Eiffel Forum License 2.
7 |
8 | More info:
9 | * jenni: https://github.com/myano/jenni/
10 | * Phenny: http://inamidst.com/phenny/
11 | """
12 |
13 | def deprecated(old):
14 | def new(jenni, input, old=old):
15 | self = jenni
16 | origin = type('Origin', (object,), {
17 | 'sender': input.sender,
18 | 'nick': input.nick
19 | })()
20 | match = input.match
21 | args = [input.bytes, input.sender, '@@']
22 |
23 | old(self, origin, match, args)
24 | new.__module__ = old.__module__
25 | new.__name__ = old.__name__
26 | return new
27 |
28 | if __name__ == '__main__':
29 | print __doc__.strip()
30 |
31 |
--------------------------------------------------------------------------------
/web.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env python
2 | """
3 | web.py - Web Facilities
4 | Copyright 2009-2013, yano (yanovich.net)
5 | Copyright 2012, Dimitri Molenaars (Tyrope.nl)
6 | Copyright 2012, Elad Alfassa (elad@fedoraproject.org)
7 | Copyright 2008-2013, Sean B. Palmer (inamidst.com)
8 |
9 | More info:
10 | * Willie: https://willie.dftba.net
11 | * jenni: https://github.com/myano/jenni/
12 | * Phenny: http://inamidst.com/phenny/
13 | """
14 |
15 | import re
16 | import urllib
17 | import urllib2
18 | from htmlentitydefs import name2codepoint
19 | from modules import unicode as uc
20 |
21 | r_entity = re.compile(r'&([^;\s]+);')
22 |
23 |
24 | class Grab(urllib.URLopener):
25 | def __init__(self, *args):
26 | self.version = 'Mozilla/5.0 (Windows NT 6.1; rv:24.0) Gecko/20100101 Firefox/24.0'
27 | urllib.URLopener.__init__(self, *args)
28 |
29 | def http_error_default(self, url, fp, errcode, errmsg, headers):
30 | return urllib.addinfourl(fp, [headers, errcode], "http:" + url)
31 | urllib._urlopener = Grab()
32 |
33 |
34 | def get(uri):
35 | if not uri.startswith('http'):
36 | return
37 | u = urllib.urlopen(uri)
38 | bytes = u.read()
39 | u.close()
40 | return bytes
41 |
42 |
43 | def head(uri):
44 | if not uri.startswith('http'):
45 | return
46 | u = urllib.urlopen(uri)
47 | info = u.info()
48 | u.close()
49 | return info
50 |
51 |
52 | def head_info(uri):
53 | if not uri.startswith('http'):
54 | return
55 | output = dict()
56 |
57 | u = urllib.urlopen(uri)
58 | if hasattr(u, 'geturl'):
59 | output['geturl'] = u.geturl()
60 | if hasattr(u, 'code'):
61 | output['code'] = u.code
62 | if hasattr(u, 'url'):
63 | output['url'] = u.url
64 | if hasattr(u, 'headers'):
65 | output['headers'] = u.headers
66 | if hasattr(u, 'info'):
67 | output['info'] = u.info()
68 |
69 | u.close()
70 | return output
71 |
72 |
73 | def post(uri, query):
74 | if not uri.startswith('http'):
75 | return
76 | data = urllib.urlencode(query)
77 | u = urllib.urlopen(uri, data)
78 | bytes = u.read()
79 | u.close()
80 | return bytes
81 |
82 |
83 |
84 | def entity(match):
85 | value = match.group(1).lower()
86 | if value.startswith('#x'):
87 | return unichr(int(value[2:], 16))
88 | elif value.startswith('#'):
89 | return unichr(int(value[1:]))
90 | elif value in name2codepoint:
91 | return unichr(name2codepoint[value])
92 | return '[' + value + ']'
93 |
94 |
95 | def decode(html):
96 | return r_entity.sub(entity, html)
97 |
98 | def entity_replace(txt):
99 | return r_entity.sub(ep, txt)
100 |
101 | def ep(m):
102 | entity = m.group()
103 | if entity.startswith('&#x'):
104 | cp = int(entity[3:-1], 16)
105 | meep = unichr(cp)
106 | elif entity.startswith('&#'):
107 | cp = int(entity[2:-1])
108 | meep = unichr(cp)
109 | else:
110 | entity_stripped = entity[1:-1]
111 | try:
112 | char = name2codepoint[entity_stripped]
113 | meep = unichr(char)
114 | except:
115 | if entity_stripped in HTML_ENTITIES:
116 | meep = HTML_ENTITIES[entity_stripped]
117 | else:
118 | meep = str()
119 | try:
120 | return uc.decode(meep)
121 | except:
122 | return uc.decode(uc.encode(meep))
123 |
124 |
125 | def remove_xml_tags(txt):
126 | r_tag = re.compile(r'<(?!!)[^>]+>')
127 | return re.sub(r_tag, '', txt)
128 |
129 |
130 | def get_urllib_object(uri, timeout):
131 | '''Return a urllib2 object for `uri` and `timeout`. This is better than
132 | using urrlib2 directly, for it handles redirects, makes sure URI is utf8,
133 | and is shorter and easier to use.
134 | Modules may use this if they need a urllib2 object to execute .read() on.
135 | For more information, refer to the urllib2 documentation.'''
136 | redirects = 0
137 | try:
138 | uri = uri.encode("utf-8")
139 | except:
140 | pass
141 | while True:
142 | req = urllib2.Request(uri, headers={'Accept': '*/*', 'User-Agent': 'Mozilla/5.0 (Jenni)'})
143 | try:
144 | u = urllib2.urlopen(req, None, timeout)
145 | except urllib2.HTTPError, e:
146 | return e.fp
147 | except:
148 | raise
149 | info = u.info()
150 | if not isinstance(info, list):
151 | status = '200'
152 | else:
153 | status = str(info[1])
154 | try: info = info[0]
155 | except: pass
156 | if status.startswith('3'):
157 | uri = urlparse.urljoin(uri, info['Location'])
158 | else: break
159 | redirects += 1
160 | if redirects >= 50:
161 | return "Too many re-directs."
162 | return u
163 |
164 |
165 | def quote(string):
166 | '''Identical to urllib2.quote. Use this if you already importing web in
167 | your module and don't want to import urllib2 just to use the quote
168 | function.'''
169 | return urllib2.quote(string)
170 |
171 |
172 | def urlencode(data):
173 | '''Identical to urllib.urlencode. Use this if you already importing web
174 | in your module and don't want to import urllib just to use the urlencode
175 | function.'''
176 | return urllib.urlencode(data)
177 |
178 |
179 | if __name__ == "__main__":
180 | main()
181 |
--------------------------------------------------------------------------------
| |