-
Notifications
You must be signed in to change notification settings - Fork 0
/
LeafsTV.py
443 lines (338 loc) · 15.1 KB
/
LeafsTV.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
'''
@author: Micah Galizia <[email protected]>
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License version 2 as
published by the Free Software Foundation.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
'''
import urllib, urllib2, re, xml.dom.minidom, time, logging
class LeafsTVError(Exception):
def __init__(self, value):
self.value = value
def __str__(self):
return repr(self.value)
class LeafsTV:
"""
Class to handle LeafsTV Interactive web requests
"""
def __init__(self, username, password):
"""
Initialize the class
"""
self.username = username
self.password = password
return
def authenticate(self):
"""
Authenticate with Leafs TV Interactive
"""
# set up the username and password
values = {'username' : self.username,
'password' : self.password }
# set up the request and add the post data (user and pass)
req = urllib2.Request("https://leafstv.neulion.com/leafstv/secure/login")
req.add_data(urllib.urlencode(values))
# make the request and read the response
try:
resp = urllib2.urlopen(req)
except:
return False
if resp.read().find("<code>loginsuccess</code>") < 0:
return False
self.cookie = resp.headers.get("Set-Cookie")
return True;
def getGames(self):
"""
Get the list of games available on LeafsTV Interactive
"""
# create teh request
req = urllib2.Request("http://leafstv.neulion.com/leafstv/servlets/games")
req.add_header('cookie', self.cookie)
# make the request and read the response
try:
resp = urllib2.urlopen(req)
except urllib2.URLError, ue:
logging.error("URL error trying to open games list: %s" % ue.read())
raise LeafsTVError("URL error trying to open games list")
except urllib2.HTTPError, he:
logging.error("HTTP error trying to open games list: %s" % he.read())
raise LeafsTVError("HTTP error trying to open games list")
return self.parseGamesList(resp.read())
def parseGamesList(self, list):
"""
parse the string containing the list of games
"""
# first cut out only the list
start = list.find("[") + 1
end = list.find("]")
real_list = list[start:end]
offset = 0
games = []
# loop through each game in the list
while offset < len(real_list):
# search for the next '}' that encapsulates the game
game_end = real_list[offset:len(real_list)].find("}") + 1 + offset
# get just the game
game = self.parseGame(real_list[offset:game_end])
if game == None:
continue
games.append(game)
#move the offset past the '}' and the game delimiting ','
offset += (game_end - offset) + 1
return games
def parseGame(self, game):
"""
parse a single game string. This method returns a dictionary containing
information about a single game.
"""
# get the start of the long date
date_start = game.find("\"longStartDate\"") + 17
date_end = game[date_start:len(game)].find("\"") + date_start
# try to parse date/time formated as '01/13/2012 19:30:00'
try:
game_time = time.strptime(game[date_start:date_end], "%m/%d/%Y %H:%M:%S")
except ValueError, ve:
print "Unable to parse time for game '" + game + "'"
return None
# parse the home team
home_start = game.find("\"homeTeamName\"") + 16
home_end = game[home_start:len(game)].find("\"") + home_start
home_team = game[home_start:home_end]
# parse the away team
away_start = game.find("\"awayTeamName\"") + 16
away_end = game[away_start:len(game)].find("\"") + away_start
away_team = game[away_start:away_end]
# parse the id
id_start = game.find("\"id\"") + 5
id_end = game[id_start:len(game)].find(",") + id_start
id = game[id_start:id_end]
game_dict = {'time' : game_time, 'home_team' : home_team,
'away_team' : away_team,'id' : id }
# parse the start time. If it contains a value this game has not
# happened yet, so we can just ignore it later on
start_start = game.find("\"startTime\"") + 13
start_end = game[start_start:len(game)].find("\"")
if start_end > 0:
game_dict['start_time'] = game[start_start:start_start + start_end]
# parse the progressTime. I'm assuming this is our clue to which game
# is live. Games not in progress do not have this field and ended games
# have "progressTime":"FINAL". Live games will have a value of
# "progressTime":"LIVE"
progress_start = game.find("\"progressTime\"")
if progress_start >= 0:
progress_start += 16
progress_end = game[progress_start:len(game)].find("\"") + progress_start
progress = game[progress_start:progress_end]
game_dict['progress'] = progress
else:
game_dict['progress'] = ""
return game_dict
def prioritizeGames(self, games):
"""
Put the games in priority watching order. Right now this just puts the
a live game first.
"""
# loop over each game and if the progress is live, add it to the start
for game in games:
if game['progress'] == "LIVE":
games.remove(game)
games.insert(0, game)
break;
return games
def getLiveGame(self):
"""
Get a live game
"""
# set the post data
values = {'isFlex' : "true"}
# create the request
req = urllib2.Request("http://leafstv.neulion.com/leafstv/servlets/game")
req.add_header('cookie', self.cookie)
req.add_data(urllib.urlencode(values))
# make the request and read the response
try:
resp = urllib2.urlopen(req)
except urllib2.URLError, ue:
logging.error("URL error trying to open game: %s" % ue.read())
raise LeafsTVError("URL error trying to open game")
except urllib2.HTTPError, he:
logging.error("HTTP error trying to open game: %s" % he.read())
raise LeafsTVError("HTTP error trying to open game")
xml = resp.read()
program_id = self.parseLiveGameXML(xml)
if program_id == None:
logging.error("ERROR: program ID is none")
raise LeafsTVError("Program ID is none")
# by default use the 1600 bitrate... poor, I know, but that is the best
full_id = program_id + "_3000"
try:
live_game = self.getEncryptedLiveGame(full_id)
except LeafsTVError, ltvError:
raise ltvError
return live_game
def parseLiveGameXML(self, xml_string):
"""
Parse the XML for a live game.
"""
dom = xml.dom.minidom.parseString(xml_string.lstrip())
for game in dom.getElementsByTagName('game'):
# skip nodes that do not have an isLive tag
is_live_node = game.getElementsByTagName('isLive')
if is_live_node.length == 0:
continue
# skip any non live nodes
is_live = is_live_node[0].firstChild.nodeValue
if is_live.lower() != "true":
continue
# get the program id node
program_id_node = game.getElementsByTagName('programId')
if program_id_node.length == 0:
logging.error("ERROR: no programId tag in live game.")
continue
program_id = program_id_node[0].firstChild.nodeValue
return program_id
return None
def getEncryptedLiveGame(self, path):
values = {'isFlex' : "true",
'type' : "game",
'path' : path }
req = urllib2.Request("http://leafstv.neulion.com/leafstv/servlets/encryptvideopath")
req.add_header('cookie', self.cookie)
req.add_data(urllib.urlencode(values))
# make the request and read the response
try:
resp = urllib2.urlopen(req)
except urllib2.URLError, ue:
logging.error("URL error trying to open game: %s" % ue.read())
raise LeafsTVError("URL error trying to open game")
except urllib2.HTTPError, he:
logging.error("HTTP error trying to open game: %s" % he.read())
raise LeafsTVError("HTTP error trying to open game")
match = re.search('<path><\!\[CDATA\[(.*?)\]\]></path>', resp.read())
if match == None:
logging.error("Unable to match live game with <path/>")
raise LeafsTVError("Unable to match live game with <path/>")
try:
url = match.group(1)
except IndexError, ie:
logging.error("ERROR: Unable to get URL from live game")
raise LeafsTVError("ERROR: Unable to get URL from live game")
return url
def getArchivedGame(self, game_id, type=2):
"""
Get an archived game.
"""
# get the id of the archived game
#id = game['id']
id = game_id[len(game_id)-4:len(game_id)]
# setup the POST values
values= {'isFlex' : "true",
'type' : str(type),
'id' : id }
# setup the request
req = urllib2.Request("http://leafstv.neulion.com/leafstv/servlets/archive")
req.add_header('cookie', self.cookie)
req.add_data(urllib.urlencode(values))
try:
resp = urllib2.urlopen(req)
except urllib2.URLError, ue:
logging.error("URL error trying to open archive: %s" % ue.read())
raise LeafsTVError("URL error trying to open archive")
except urllib2.HTTPError, he:
logging.error("HTTP error trying to open archive: %s" % he.read())
raise LeafsTVError("HTTP error trying to open archive")
match = re.search('<publishPoint><\!\[CDATA\[(.*?)\]\]></publishPoint>', resp.read())
if match == None:
# we have recursed down to preseason and that also did not work
if type == 1:
logging.error("All known game types attempted. Unable to play game")
raise LeafsTVError("All known game types attempted. Unable to play game")
# use a lower game type. From what I can tell 2 means regular
# season and 1 means pre-season -- pointless IMO
try:
archived_game = self.getArchivedGame(game_id, type-1)
except LeafsTVError, ltvError:
raise ltvError
# return the archived game if it works as another game type
return archived_game
# if we get a match, make sure there is actual data
try:
url = match.group(1)
except IndexError:
logging.error("ERROR: Unable to get URL from archived game")
raise LeafsTVError("ERROR: Unable to get URL from archived game")
# for whatever reason the url is modified in this way for the next request
try:
encrypted_game = self.getEncryptedArchivePath(re.sub('\.mp4', '_hd.mp4', url))
except LeafsTVError, ltvErr:
raise ltvErr
# return the encrypted game URL
return encrypted_game
def getEncryptedArchivePath(self, path):
"""
Get the authenticated stream url
"""
# setup the request values
values = {'isFlex' : "true",
'path' : path,
'type' : "fvod"}
# setup the request
req = urllib2.Request("http://leafstv.neulion.com/leafstv/servlets/encryptvideopath")
req.add_header('cookie', self.cookie)
req.add_data(urllib.urlencode(values))
# make the request
try:
resp = urllib2.urlopen(req)
except urllib2.URLError, ue:
logging.error("URL error trying to open encrypted archive: %s" % ue.read())
raise LeafsTVError("URL error trying to open encrypted archive")
except urllib2.HTTPError, he:
logging.error("HTTP error trying to open encrypted archive: %s" % he.read())
raise LeafsTVError("HTTP error trying to open encrypted archive")
# try to match the path from the response
match = re.search('<path><\!\[CDATA\[(.*?)\]\]></path>', resp.read())
if match == None:
logging.error("Unable to match archive game with <path/>")
raise LeafsTVError("Unable to match archive game with <path/>")
# ensure a valid path was returned
try:
url = match.group(1)
except IndexError, ie:
logging.error("ERROR: Unable to get URL from archived game")
raise LeafsTVError("ERROR: Unable to get URL from archived game")
return url
def getLiveGameXML(self, uri):
"""
Get the XML data describing the streams.
@param uri The location returned from the encrypted video path
"""
# chop up the URI so we can call it with encrypt video path
match = re.search("(.*?)://(.*?)/(.*)", uri)
if match == None:
print "Unable to match URI"
return None
if len(match.groups()) != 3:
print "Imperfect match on URI"
return None
# chop up the URI
xml_src = "http://" + match.group(2) + "/play?url=" + match.group(3)
# create the request
req = urllib2.Request(xml_src)
# request the games
try:
resp = urllib2.urlopen(req)
except urllib2.URLError, ue:
logging.error("URL error trying to open playlist: %s" % ue.read())
raise GameCenterError("URL error trying to open playlist")
except urllib2.HTTPError, he:
logging.error("HTTP error trying to open playlist: %s" % he.read())
raise GameCenterError("HTTP error trying to open playlist")
# get the xml
xml = resp.read()
#return the xml
return xml