1 | #!/usr/local/bin/python |
---|
2 | # -*- coding: UTF-8 -*- |
---|
3 | #--------------------------- |
---|
4 | # Name: mythvidexport.py |
---|
5 | # Python Script |
---|
6 | # Author: Raymond Wagner |
---|
7 | # Purpose |
---|
8 | # This python script is intended to function as a user job, run through |
---|
9 | # mythjobqueue, capable of exporting recordings into MythVideo. |
---|
10 | #--------------------------- |
---|
11 | __title__ = "MythVidExport" |
---|
12 | __author__ = "Raymond Wagner" |
---|
13 | __version__= "v0.5.0" |
---|
14 | |
---|
15 | usage_txt = """ |
---|
16 | This script can be run from the command line, or called through the mythtv |
---|
17 | jobqueue. The input format will be: |
---|
18 | mythvidexport.py [options] <--chanid <channel id>> <--starttime <start time>> |
---|
19 | --- or --- |
---|
20 | mythvidexport.py [options] %JOBID% |
---|
21 | |
---|
22 | Options are: |
---|
23 | --mformat <format string> |
---|
24 | --tformat <format string> |
---|
25 | --gformat <format string> |
---|
26 | overrides the stored format string for a single run |
---|
27 | --listingonly |
---|
28 | use EPG data rather than grabbers for metadata |
---|
29 | will still try to grab episode and season information from ttvdb.py |
---|
30 | |
---|
31 | Additional functions are available beyond exporting video |
---|
32 | mythvidexport.py <options> |
---|
33 | -h, --help show this help message |
---|
34 | -p, --printformat print existing format strings |
---|
35 | -f, --helpformat lengthy description for formatting strings |
---|
36 | --mformat <string> replace existing Movie format |
---|
37 | --tformat <string> replace existing TV format |
---|
38 | --gformat <string> replace existing Generic format |
---|
39 | """ |
---|
40 | |
---|
41 | from MythTV import MythTV, MythDB, MythLog, MythVideo, Program, FileTransfer, Job |
---|
42 | #from MythTV.MythLog import EMERGENCY, ALERT, CRITICAL, ERROR, WARNING, NOTICE, INFO, DEBUG, ALL |
---|
43 | from socket import gethostname |
---|
44 | from urllib import urlretrieve |
---|
45 | from optparse import OptionParser |
---|
46 | import sys, re, os, time |
---|
47 | |
---|
48 | |
---|
49 | #log = MythLog(NOTICE, 'MythVidExport.py') |
---|
50 | |
---|
51 | class VIDEO: |
---|
52 | job = None |
---|
53 | dest = None |
---|
54 | |
---|
55 | viddata = {} |
---|
56 | cast = [] |
---|
57 | genre = [] |
---|
58 | country = [] |
---|
59 | image = {'coverfile':None, 'banner':None, 'fanart':None} |
---|
60 | |
---|
61 | def __init__(self, opts, jobid): |
---|
62 | if jobid: |
---|
63 | self.job = Job(jobid) |
---|
64 | self.chanid = self.job.chanid |
---|
65 | self.rtime = int("%04d%02d%02d%02d%02d%02d" % self.job.starttime.timetuple()[0:6]) |
---|
66 | self.jobhost = self.job.host |
---|
67 | self.job.setStatus(3) |
---|
68 | else: |
---|
69 | self.chanid = opts.chanid |
---|
70 | self.rtime = opts.starttime |
---|
71 | self.jobhost = gethostname() |
---|
72 | |
---|
73 | self.opts = opts |
---|
74 | self.mythdb = MythDB() |
---|
75 | self.cursor = self.mythdb.cursor() |
---|
76 | |
---|
77 | # load grabber scripts |
---|
78 | self.get_grabber() |
---|
79 | |
---|
80 | # load formatting strings |
---|
81 | self.get_fmt() |
---|
82 | if opts.tformat: |
---|
83 | selt.tfmt = opts.tformat |
---|
84 | if opts.mformat: |
---|
85 | self.mfmt = opts.mformat |
---|
86 | if opts.gformat: |
---|
87 | self.gfmt = opts.gformat |
---|
88 | |
---|
89 | # process file |
---|
90 | self.get_source() |
---|
91 | self.get_meta() |
---|
92 | self.get_dest() |
---|
93 | |
---|
94 | # save file |
---|
95 | self.copy() |
---|
96 | self.write_meta() |
---|
97 | |
---|
98 | def get_source(self): |
---|
99 | ## connects to myth data socket and finds recording |
---|
100 | mythinst = MythTV() |
---|
101 | self.prog = mythinst.getRecording(self.chanid,self.rtime) |
---|
102 | |
---|
103 | self.srchost = self.prog.hostname |
---|
104 | self.source = mythinst.getCheckfile(self.prog) |
---|
105 | |
---|
106 | def get_grabber(self): |
---|
107 | # grab ttvdb commands |
---|
108 | glist = ('TitleSub','Data','Poster','Fanart','Banner') |
---|
109 | self.ttvdb = {} |
---|
110 | for cmd in glist: |
---|
111 | self.ttvdb[cmd] = self.mythdb.getSetting('mythvideo.TV%sCommandLine' % cmd,self.jobhost) |
---|
112 | |
---|
113 | # insert optional ttvdb config file |
---|
114 | if os.access(os.path.expanduser("~/.mythtv/ttvdb.conf"),os.F_OK): |
---|
115 | ttvdbconf = os.path.expanduser("~/.mythtv/ttvdb.conf") |
---|
116 | for cmd in glist: |
---|
117 | tmp = self.ttvdb[cmd].split(' ') |
---|
118 | tmp.insert(1,'-c '+ttvdbconf) |
---|
119 | self.ttvdb[cmd] = ' '.join(tmp) |
---|
120 | |
---|
121 | # grab tmdb commands |
---|
122 | glist = ('List','Data','Poster','Fanart') |
---|
123 | self.tmdb = {} |
---|
124 | for cmd in glist: |
---|
125 | self.tmdb[cmd] = self.mythdb.getSetting('Movie%sCommandLine' % cmd,self.jobhost) |
---|
126 | |
---|
127 | def get_meta(self): |
---|
128 | if self.prog.subtitle: # subtitle exists, assume tv show |
---|
129 | self.get_ttvdb() |
---|
130 | else: # assume movie |
---|
131 | self.get_tmdb() |
---|
132 | |
---|
133 | def get_ttvdb(self): |
---|
134 | ## grab season and episode number from thetvdb.com, exit if failed |
---|
135 | fp = os.popen("""%s "%s" "%s" """ % (self.ttvdb['TitleSub'],self.prog.title,self.prog.subtitle),"r") |
---|
136 | match = re.search("S(?P<season>[0-9]*)E(?P<episode>[0-9]*)", fp.read()) |
---|
137 | fp.close() |
---|
138 | if match is None: |
---|
139 | #log.warning('Grabber error', "TTVDB.py failed to get season/episode numbers for %s - %s. Reverting to generic export." % (self.prog.title, self.prog.subtitle)) |
---|
140 | self.get_generic() |
---|
141 | return |
---|
142 | |
---|
143 | self.viddata['season'] = int(match.group('season')) |
---|
144 | self.viddata['episode'] = int(match.group('episode')) |
---|
145 | |
---|
146 | if self.opts.listingonly: # do not grab subsequent information from ttvdb |
---|
147 | self.get_generic() |
---|
148 | |
---|
149 | else: # gather remaining data |
---|
150 | self.process_meta("""%s "%s" %d %d""" % (self.ttvdb['Data'],self.prog.title,self.viddata['season'],self.viddata['episode'])) |
---|
151 | |
---|
152 | # grab links to images |
---|
153 | link = re.compile('http://images.thetvdb.com.nyud.net:8080/.*') |
---|
154 | for (key, grabber) in (('coverfile','Poster'),('banner','Banner'),('fanart','Fanart')): |
---|
155 | fp = os.popen("""%s "%s" %d %d""" % (self.ttvdb[grabber],self.viddata['title'],self.viddata['season'],self.viddata['episode'])) |
---|
156 | match = link.search(fp.read()) |
---|
157 | fp.close() |
---|
158 | if match: |
---|
159 | self.image[key] = match.group() |
---|
160 | |
---|
161 | # set some common data |
---|
162 | self.country = () |
---|
163 | self.viddata['showlevel'] = 1 |
---|
164 | self.viddata['rating'] = 'NR' |
---|
165 | self.viddata['coverfile'] = 'No Cover' |
---|
166 | self.type = 'TV' |
---|
167 | |
---|
168 | def get_tmdb(self): |
---|
169 | if self.opts.listingonly: # do not grab from tmdb |
---|
170 | self.get_generic() |
---|
171 | else: # find inetref from tmdb |
---|
172 | match = None |
---|
173 | fp = os.popen("""%s "%s" """ % (self.tmdb['List'], self.prog.title)) |
---|
174 | if self.prog.year: |
---|
175 | match = re.search("(?P<inetref>[0-9]*):%s[ ]*\(%s\)" % (self.prog.title, self.prog.year), fp.read()) |
---|
176 | else: |
---|
177 | match = re.search("(?P<inetref>[0-9]*):%s[ ]*\([0-9]*\)" % self.prog.title, fp.read()) |
---|
178 | fp.close() |
---|
179 | if match is None: |
---|
180 | #log.warning('Grabber error', "TMDB.py failed to find matching movie for %s. Reverting to generic export." % self.prog.title) |
---|
181 | self.get_generic() |
---|
182 | return |
---|
183 | |
---|
184 | # gather remanining data |
---|
185 | self.viddata['inetref'] = match.group('inetref') |
---|
186 | self.process_meta("%s %s" % (self.tmdb['Data'], match.group('inetref'))) |
---|
187 | |
---|
188 | # grab links to images |
---|
189 | link = re.compile('http://images.themoviedb.org/.*') |
---|
190 | for (key, grabber) in (('coverfile','Poster'),('fanart','Fanart')): |
---|
191 | fp = os.popen("%s %s" % (self.tmdb[grabber], self.viddata['inetref'])) |
---|
192 | match = link.search(fp.read()) |
---|
193 | fp.close() |
---|
194 | if match: |
---|
195 | self.image[key] = match.group() |
---|
196 | |
---|
197 | # set some common data |
---|
198 | self.country = () |
---|
199 | self.viddata['showlevel'] = 1 |
---|
200 | self.viddata['rating'] = 'NR' |
---|
201 | self.viddata['coverfile'] = 'No Cover' |
---|
202 | self.type = 'MOVIE' |
---|
203 | |
---|
204 | def get_generic(self): |
---|
205 | # pull available program data |
---|
206 | self.viddata['title'] = self.prog.title |
---|
207 | if self.prog.subtitle: |
---|
208 | self.viddata['subtitle'] = self.prog.subtitle |
---|
209 | if self.prog.description: |
---|
210 | self.viddata['plot'] = self.prog.description |
---|
211 | if self.prog.year: |
---|
212 | self.viddata['year'] = self.prog.year |
---|
213 | self.viddata['length'] = str(int((self.prog.recendts-self.prog.recstartts).seconds/60)) |
---|
214 | self.viddata['inetref'] = '00000000' |
---|
215 | self.viddata['director'] = self.mythdb.getCast(self.chanid, self.rtime, roles='director') |
---|
216 | if len(self.viddata['director']) == 0: |
---|
217 | self.viddata['director'] = 'NULL' |
---|
218 | else: |
---|
219 | self.viddata['director'] = self.viddata['director'][0] |
---|
220 | self.cast = self.mythdb.getCast(self.chanid, self.rtime, roles=('actor','guest_star','host','commentator','guest')) |
---|
221 | self.country = () |
---|
222 | self.viddata['showlevel'] = 1 |
---|
223 | self.viddata['rating'] = 'NR' |
---|
224 | self.viddata['coverfile'] = 'No Cover' |
---|
225 | self.type = 'GENERIC' |
---|
226 | |
---|
227 | |
---|
228 | def process_meta(self, command): |
---|
229 | # process grabber command and pull available data |
---|
230 | fp = os.popen(command) |
---|
231 | res = fp.read() |
---|
232 | fp.close() |
---|
233 | dict = {} |
---|
234 | for point in res.split('\n')[:-1]: |
---|
235 | key,dat = point.split(':',1) |
---|
236 | dict[key] = dat |
---|
237 | for (dbkey, datkey) in (('title','Title'),('subtitle','Subtitle'),('director','Director'), |
---|
238 | ('plot','Plot'),('inetref','Seriesid'), ('year','Year'), |
---|
239 | ('userrating','UserRating'),('length','Runtime')): |
---|
240 | if datkey in dict.keys(): |
---|
241 | self.viddata[dbkey] = dict[datkey].strip() |
---|
242 | if 'Cast' in dict.keys(): |
---|
243 | self.cast = tuple(dict['Cast'].split(', ')) |
---|
244 | if 'Genres' in dict.keys(): |
---|
245 | self.genre = tuple(dict['Genres'].split(', ')) |
---|
246 | |
---|
247 | def get_dest(self): |
---|
248 | |
---|
249 | subpath = None |
---|
250 | if self.type == 'TV': |
---|
251 | subpath = self.process_fmt(self.tfmt) |
---|
252 | elif self.type == 'MOVIE': |
---|
253 | subpath = self.process_fmt(self.mfmt) |
---|
254 | elif self.type == 'GENERIC': |
---|
255 | subpath = self.process_fmt(self.gfmt) |
---|
256 | subpath += self.source[self.source.rfind('.'):] |
---|
257 | |
---|
258 | c = self.mythdb.cursor() |
---|
259 | res = c.execute("""SELECT dirname FROM storagegroup WHERE groupname='Videos' and hostname='%s' LIMIT 1""" % self.jobhost) |
---|
260 | res = self.mythdb.getStorageGroup('Videos',self.jobhost) |
---|
261 | if res: |
---|
262 | self.dest = c.fetchone()[0]+subpath |
---|
263 | self.destdb = subpath |
---|
264 | else: |
---|
265 | self.dest = self.mythdb.getSetting("VideoStartupDir",self.jobhost)+'/'+subpath |
---|
266 | self.destdb = self.dest |
---|
267 | |
---|
268 | tmppath = self.dest[0:self.dest.rfind('/')] |
---|
269 | if not os.access(tmppath,os.F_OK): |
---|
270 | os.makedirs(tmppath) |
---|
271 | |
---|
272 | def get_fmt(self): |
---|
273 | self.tfmt = self.mythdb.getSetting('mythvideo.TVexportfmt') |
---|
274 | if not self.tfmt: |
---|
275 | self.tfmt = 'Television/%TITLE%/Season %SEASON%/%TITLE% - S%SEASON%E%EPISODEPAD% - %SUBTITLE%' |
---|
276 | self.mfmt = self.mythdb.getSetting('mythvideo.MOVIEexportfmt') |
---|
277 | if not self.mfmt: |
---|
278 | self.mfmt = 'Movies/%TITLE%' |
---|
279 | self.gfmt = self.mythdb.getSetting('mythvideo.GENERICexportfmt') |
---|
280 | if not self.gfmt: |
---|
281 | self.gfmt = 'Videos/%TITLE%' |
---|
282 | |
---|
283 | def process_fmt(self, fmt): |
---|
284 | # replace fields from viddata |
---|
285 | rep = ( ('%TITLE%','title','%s'),('%SUBTITLE%','subtitle','%s'), |
---|
286 | ('%SEASON%','season','%d'),('%SEASONPAD%','season','%02d'), |
---|
287 | ('%EPISODE%','episode','%d'),('%EPISODEPAD%','episode','%02d'), |
---|
288 | ('%YEAR%','year','%s'),('%DIRECTOR%','director','%s')) |
---|
289 | for (tag, data, format) in rep: |
---|
290 | if data in self.viddata.keys(): |
---|
291 | fmt = fmt.replace(tag,format % self.viddata[data]) |
---|
292 | else: |
---|
293 | fmt = fmt.replace(tag,'') |
---|
294 | |
---|
295 | # replace fields from program data |
---|
296 | rep = ( ('%HOSTNAME','hostname','%s'),('%STORAGEGROUP%','storagegroup','%s')) |
---|
297 | for (tag, data, format) in rep: |
---|
298 | data = eval('self.prog.%s' % data) |
---|
299 | fmt = fmt.replace(tag,format % data) |
---|
300 | |
---|
301 | # fmt = fmt.replace('%CARDID%',self.prog.cardid) |
---|
302 | # fmt = fmt.replace('%CARDNAME%',self.prog.cardid) |
---|
303 | # fmt = fmt.replace('%SOURCEID%',self.prog.cardid) |
---|
304 | # fmt = fmt.replace('%SOURCENAME%',self.prog.cardid) |
---|
305 | # fmt = fmt.replace('%CHANNUM%',self.prog.channum) |
---|
306 | # fmt = fmt.replace('%CHANNAME%',self.prog.cardid) |
---|
307 | |
---|
308 | if len(self.genre): |
---|
309 | fmt = fmt.replace('%GENRE%',self.genre[0]) |
---|
310 | else: |
---|
311 | fmt = fmt.replace('%GENRE%','') |
---|
312 | # if len(self.country): |
---|
313 | # fmt = fmt.replace('%COUNTRY%',self.country[0]) |
---|
314 | # else: |
---|
315 | # fmt = fmt.replace('%COUNTRY%','') |
---|
316 | return fmt |
---|
317 | |
---|
318 | def copy(self): |
---|
319 | if self.opts.skip: |
---|
320 | return |
---|
321 | srcp = None |
---|
322 | dtime = None |
---|
323 | |
---|
324 | #log.notice('Starting transfer','from "%s:%s" to "%s"' % (self.srchost,self.source,self.dest)) |
---|
325 | stime = time.time() |
---|
326 | ctime = time.time() |
---|
327 | if os.access(self.source,os.F_OK): |
---|
328 | srcp = open(self.source,'r') |
---|
329 | else: |
---|
330 | srcp = FileTransfer(self.prop) |
---|
331 | destp = open(self.dest,'w') |
---|
332 | srcsize = self.prog.filesize |
---|
333 | destsize = [0,0,0,0,0,0,0,0,0,0] |
---|
334 | if self.job: |
---|
335 | self.job.setStatus(4) |
---|
336 | tsize = 2**18 |
---|
337 | while tsize == 2**18: |
---|
338 | if (srcsize - destp.tell()) < tsize: |
---|
339 | tsize = srcsize - destp.tell() |
---|
340 | if time.time() - ctime > 4: |
---|
341 | ctime = time.time() |
---|
342 | destsize.append(destp.tell()) |
---|
343 | rem = srcsize - destp.tell() |
---|
344 | if destsize[0]: |
---|
345 | dtime = 40 |
---|
346 | else: |
---|
347 | dtime = int(ctime - stime) |
---|
348 | rate = (destp.tell() - destsize.pop(0))/dtime |
---|
349 | remt = rem/rate |
---|
350 | if self.job: |
---|
351 | self.job.setComment("%02d%% complete - %s seconds remaining" % (destsize[9]*100/srcsize, remt)) |
---|
352 | destp.write(srcp.read(tsize)) |
---|
353 | |
---|
354 | srcp.close() |
---|
355 | destp.close() |
---|
356 | #log.notice('Transfer complete','%d seconds elapsed' % int(time.time()-stime)) |
---|
357 | if self.job: |
---|
358 | self.job.setComment("Complete - %d seconds elapsed" % (int(time.time()-stime))) |
---|
359 | self.job.setStatus(256) |
---|
360 | |
---|
361 | |
---|
362 | def write_meta(self): |
---|
363 | mythvid = MythVideo() |
---|
364 | mythtv = MythTV() |
---|
365 | self.viddata['filename'] = self.destdb |
---|
366 | self.viddata['host'] = self.jobhost |
---|
367 | |
---|
368 | |
---|
369 | intid = mythvid.getMetadataId(self.destdb) |
---|
370 | if intid: |
---|
371 | mythvid.setMetadata(self.viddata,intid) |
---|
372 | else: |
---|
373 | intid = mythvid.setMetadata(self.viddata) |
---|
374 | for name in self.cast: |
---|
375 | mythvid.setCast(name, intid) |
---|
376 | self.write_image('coverfile',intid) |
---|
377 | self.write_image('banner',intid) |
---|
378 | self.write_image('fanart',intid) |
---|
379 | if self.job: |
---|
380 | self.job.setStatus(272) |
---|
381 | |
---|
382 | def write_image(self,mode,intid): |
---|
383 | if not self.image[mode]: |
---|
384 | return |
---|
385 | path = None |
---|
386 | dbpath = None |
---|
387 | SG = {'coverfile':'Coverart','banner':'Banners','fanart':'Fanart'} |
---|
388 | DB = {'coverfile':'VideoArtworkDir','banner':'mythvideo.bannerDir','fanart':'mythvideo.fanartDir'} |
---|
389 | mythvid = MythVideo() |
---|
390 | |
---|
391 | file = self.viddata['inetref']+'_'+self.image[mode][self.image[mode].rfind('/')+1:] |
---|
392 | |
---|
393 | c = self.mythdb.cursor() |
---|
394 | res = c.execute("""SELECT dirname FROM storagegroup WHERE groupname='%s' and hostname='%s' LIMIT 1""" % (SG[mode],self.jobhost)) |
---|
395 | if res: |
---|
396 | path = c.fetchone()[0]+file |
---|
397 | dbpath = file |
---|
398 | else: |
---|
399 | path = self.mythdb.getSetting(DB[mode],self.jobhost)+'/'+file |
---|
400 | dbpath = path |
---|
401 | |
---|
402 | if not os.access(path,os.F_OK): |
---|
403 | urlretrieve(self.image[mode],path) |
---|
404 | if (mode == 'coverfile') & (self.type == 'TV'): |
---|
405 | vdir = self.dest[:self.dest.rfind('/')] |
---|
406 | if not os.access(vdir+'folder.jpg',os.F_OK): |
---|
407 | urlretrieve(self.image[mode],vdir+'/folder.jpg') |
---|
408 | |
---|
409 | mythvid.setMetadata({mode:dbpath}, intid) |
---|
410 | |
---|
411 | |
---|
412 | def usage(): |
---|
413 | print("mythvidexport.py [options] [--chanid=<chanid> --starttime=<starttime> | <jobid>]") |
---|
414 | print(" This script can be run by specifing the channel and start time directly") |
---|
415 | print(" or by specifing the ID of a job in jobqueue") |
---|
416 | print("") |
---|
417 | print(" Run from the command line through the former:") |
---|
418 | print(" mythvidexport.py --chanid=1002 --starttime=200907010000") |
---|
419 | print(" Or from a user script through the latter:") |
---|
420 | print(" mythvidexport.py %JOBID%") |
---|
421 | print("") |
---|
422 | print(" Options:") |
---|
423 | print(" -h/--help and -f/--helpformat:") |
---|
424 | print(" return this help, or a listing of available formatting strings") |
---|
425 | print(" --fformat='<string>' and --dformat='<string>':") |
---|
426 | print(" override the stored formatting string in the database") |
---|
427 | print(" if no recording is specified, store format string to the database") |
---|
428 | |
---|
429 | def usage_format(): |
---|
430 | print("The default strings are:") |
---|
431 | print(" Television: 'Television/%TITLE%/Season %SEASON%/%TITLE% - S%SEASON%E%EPISODEPAD% - %SUBTITLE%'") |
---|
432 | print(" Movie: 'Movies/%TITLE%'") |
---|
433 | print(" Generic: 'Videos/%TITLE%'") |
---|
434 | print("") |
---|
435 | print("Available strings:") |
---|
436 | print(" %TITLE%: series title") |
---|
437 | print(" %SUBTITLE%: episode title") |
---|
438 | print(" %SEASON%: season number") |
---|
439 | print(" %SEASONPAD%: season number, padded to 2 digits") |
---|
440 | print(" %EPISODE%: episode number") |
---|
441 | print(" %EPISODEPAD%: episode number, padded to 2 digits") |
---|
442 | print(" %YEAR%: year") |
---|
443 | print(" %DIRECTOR%: director") |
---|
444 | # print(" %CARDID%: ID of tuner card used to record show") |
---|
445 | # print(" %CARDNAME%: name of tuner card used to record show") |
---|
446 | # print(" %SOURCEID%: ID of video source used to record show") |
---|
447 | # print(" %SOURCENAME%: name of video source used to record show") |
---|
448 | print(" %HOSTNAME%: backend used to record show") |
---|
449 | print(" %STORAGEGROUP%: storage group containing recorded show") |
---|
450 | # print(" %CHANNUM%: ID of channel used to record show") |
---|
451 | # print(" %CHANNAME%: name of channel used to record show") |
---|
452 | print(" %GENRE%: first genre listed for recording") |
---|
453 | # print(" %COUNTRY%: first country listed for recording") |
---|
454 | |
---|
455 | def print_format(): |
---|
456 | db = MythDB() |
---|
457 | tfmt = db.getSetting('mythvideo.TVexportfmt') |
---|
458 | if not tfmt: |
---|
459 | tfmt = 'Television/%TITLE%/%TITLE% - S%SEASON%E%EPISODEPAD% - %SUBTITLE%' |
---|
460 | mfmt = db.getSetting('mythvideo.MOVIEexportfmt') |
---|
461 | if not mfmt: |
---|
462 | mfmt = 'Movies/%TITLE%' |
---|
463 | gfmt = db.getSetting('mythvideo.GENERICexportfmt') |
---|
464 | if not gfmt: |
---|
465 | gfmt = 'Videos/%TITLE%' |
---|
466 | print "Current output formats:" |
---|
467 | print " TV: "+tfmt |
---|
468 | print " Movies: "+mfmt |
---|
469 | print " Generic: "+gfmt |
---|
470 | |
---|
471 | def main(): |
---|
472 | parser = OptionParser(usage="usage: %prog [options] [jobid]") |
---|
473 | |
---|
474 | parser.add_option("-f", "--helpformat", action="store_true", default=False, dest="fmthelp", |
---|
475 | help="Print explination of file format string.") |
---|
476 | parser.add_option("-p", "--printformat", action="store_true", default=False, dest="fmtprint", |
---|
477 | help="Print current file format string.") |
---|
478 | parser.add_option("--tformat", action="store", type="string", dest="tformat", |
---|
479 | help="Use TV format for current task. If no task, store in database.") |
---|
480 | parser.add_option("--mformat", action="store", type="string", dest="mformat", |
---|
481 | help="Use Movie format for current task. If no task, store in database.") |
---|
482 | parser.add_option("--gformat", action="store", type="string", dest="gformat", |
---|
483 | help="Use Generic format for current task. If no task, store in database.") |
---|
484 | parser.add_option("--chanid", action="store", type="int", dest="chanid", |
---|
485 | help="Use chanid for manual operation") |
---|
486 | parser.add_option("--starttime", action="store", type="int", dest="starttime", |
---|
487 | help="Use starttime for manual operation") |
---|
488 | parser.add_option("--listingonly", action="store_true", default=False, dest="listingonly", |
---|
489 | help="Use data from listing provider, rather than grabber") |
---|
490 | parser.add_option("--skip", action="store_true", default=False, dest="skip") # debugging use only |
---|
491 | |
---|
492 | opts, args = parser.parse_args() |
---|
493 | |
---|
494 | if opts.fmthelp: |
---|
495 | usage_format() |
---|
496 | sys.exit(0) |
---|
497 | |
---|
498 | if opts.fmtprint: |
---|
499 | usage_current() |
---|
500 | sys.exit(0) |
---|
501 | |
---|
502 | if opts.chanid and opts.starttime: |
---|
503 | export = VIDEO(opts,0) |
---|
504 | elif len(args) == 1: |
---|
505 | export = VIDEO(opts,int(args[0])) |
---|
506 | else: |
---|
507 | if opts.tformat or opts.mformat or opts.gformat: |
---|
508 | db = MythDB() |
---|
509 | if opts.tformat: |
---|
510 | print "Changing TV format to: "+opts.tformat |
---|
511 | db.setSetting('mythvideo.TVexportfmt',opts.tformat) |
---|
512 | if opts.mformat: |
---|
513 | print "Changing Movie format to: "+opts.mformat |
---|
514 | db.setSetting('mythvideo.MOVIEexportfmt',opts.mformat) |
---|
515 | if opts.gformat: |
---|
516 | print "Changing Generic format to: "+opts.gformat |
---|
517 | db.setSetting('mythvideo.GENERICexportfmt',opts.gformat) |
---|
518 | sys.exit(0) |
---|
519 | else: |
---|
520 | parser.print_help() |
---|
521 | sys.exit(2) |
---|
522 | |
---|
523 | if __name__ == "__main__": |
---|
524 | main() |
---|