code.delx.au - webdl/blob - brightcove.py

   1 #!/usr/bin/env python
   2 # vim:ts=4:sts=4:sw=4:noet
   3
   4 import re
   5 import sys
   6
   7 from common import grab_json, download_rtmp, Node, append_to_qs
   8
   9 CH9_TOKEN = "ogxhPgSphIVa2hhxbi9oqtYwtg032io4B4-ImwddYliFWHqS0UfMEw.."
  10 CH10_TOKEN = "lWCaZyhokufjqe7H4TLpXwHSTnNXtqHxyMvoNOsmYA_GRaZ4zcwysw.."
  11
  12 BRIGHTCOVE_API = "http://api.brightcove.com/services/library?"
  13 HASH_URL = "http://admin.brightcove.com/viewer/us20130530.1140/connection/ExternalConnection_2.swf"
  14
  15
  16 class BrightcoveVideoNode(Node):
  17         def __init__(self, title, parent, token, video_id):
  18                 Node.__init__(self, title, parent)
  19                 self.can_download = True
  20                 self.token = token
  21                 self.video_id = video_id
  22
  23         def download(self):
  24                 desc_url = append_to_qs(BRIGHTCOVE_API, {
  25                         "token": self.token,
  26                         "command": "find_video_by_id",
  27                         "video_fields": "renditions",
  28                         "video_id": self.video_id,
  29                 })
  30                 print "video desc_url", desc_url
  31
  32                 doc = grab_json(desc_url, 3600)
  33
  34                 best_encoding_rate = 0
  35                 best_url = None
  36                 for item in doc['renditions']:
  37                         encoding_rate = item['encodingRate']
  38                         if encoding_rate > best_encoding_rate:
  39                                 best_encoding_rate = encoding_rate
  40                                 best_url = item['url']
  41
  42                 if best_url is None:
  43                         raise Exception("Could not find video URL: " + desc_url)
  44
  45                 vbase, vpath = best_url.split("&")
  46                 filename = self.title + ".mp4"
  47                 return download_rtmp(filename, vbase, vpath, HASH_URL)
  48
  49
  50 class BrightcoveRootNode(Node):
  51         def __init__(self, title, parent, token):
  52                 Node.__init__(self, title, parent)
  53                 self.token = token
  54                 self.series_nodes = {}
  55
  56         def get_series_node(self, series_name):
  57                 series_name = series_name.split("-")[0].strip()
  58                 key = series_name.lower()
  59                 node = self.series_nodes.get(key, None)
  60                 if node is None:
  61                         node = Node(series_name, self)
  62                         self.series_nodes[key] = node
  63                 return node
  64
  65         def fill_children(self):
  66                 page_number = 0
  67                 while page_number < 100:
  68                         sys.stdout.write(".")
  69                         sys.stdout.flush()
  70                         url = self.get_all_videos_url(page_number)
  71                         page_number += 1
  72
  73                         page = grab_json(url, 3600)
  74                         items = page["items"]
  75                         if len(items) == 0:
  76                                 break
  77
  78                         for video_desc in items:
  79                                 self.process_video(video_desc)
  80                 print
  81
  82         def process_video(self, video_desc):
  83                 if not video_desc["customFields"]:
  84                         return
  85
  86                 video_id = video_desc["id"]
  87                 title = self.get_video_title(video_desc)
  88                 series_name = self.get_series_name(video_desc)
  89
  90                 parent_node = self.get_series_node(series_name)
  91                 BrightcoveVideoNode(title, parent_node, self.token, video_id)
  92
  93         def get_video_title(self, video_desc):
  94                 raise NotImplementedError()
  95
  96         def get_series_name(self, video_desc):
  97                 raise NotImplementedError()
  98
  99         def get_all_videos_url(self, page_number):
 100                 raise NotImplementedError()
 101
 102
 103 class Ch9RootNode(BrightcoveRootNode):
 104         def __init__(self, root_node):
 105                 BrightcoveRootNode.__init__(self, "Nine", root_node, CH9_TOKEN)
 106
 107         def get_video_title(self, video_desc):
 108                 title = video_desc["name"]
 109                 series = video_desc["customFields"]["series"]
 110                 season = video_desc["customFields"].get("season", "")
 111                 episode = video_desc["customFields"].get("episode", "1").rjust(2, "0")
 112
 113                 if re.match(R"ep(isode)?\s*[0-9]+\s*:", title.lower()):
 114                         title = title.split(":", 1)[1].strip()
 115
 116                 title = "%s - %sx%s - %s" % (
 117                         series,
 118                         season,
 119                         episode,
 120                         title
 121                 )
 122                 return title
 123
 124         def get_series_name(self, video_desc):
 125                 return video_desc["customFields"]["series"]
 126
 127         def get_all_videos_url(self, page_number):
 128                 return append_to_qs(BRIGHTCOVE_API, {
 129                         "token": self.token,
 130                         "command": "search_videos",
 131                         "video_fields": "id,name,customFields",
 132                         "custom_fields": "series,season,episode",
 133                         "sort_by": "PUBLISH_DATE",
 134                         "page_number": str(page_number),
 135                 })
 136
 137
 138 class Ch10RootNode(BrightcoveRootNode):
 139         def __init__(self, root_node):
 140                 BrightcoveRootNode.__init__(self, "Ten", root_node, CH10_TOKEN)
 141
 142         def get_video_title(self, video_desc):
 143                 return video_desc["name"]
 144
 145         def get_series_name(self, video_desc):
 146                 return video_desc["customFields"]["tv_show"]
 147
 148         def get_all_videos_url(self, page_number):
 149                 return append_to_qs(BRIGHTCOVE_API, {
 150                         "token": self.token,
 151                         "command": "search_videos",
 152                         "video_fields": "id,name,customFields",
 153                         "custom_fields": "tv_show",
 154                         "sort_by": "PUBLISH_DATE",
 155                         "any": "video_type_long_form:Full Episode",
 156                         "page_number": str(page_number),
 157                 })
 158
 159
 160 def fill_nodes(root_node):
 161         Ch9RootNode(root_node)
 162         Ch10RootNode(root_node)
 163