src/rtv_schedule.py

   1 #!/usr/bin/python
   2
   3 import time, datetime, os, re
   4 import rtv_favourite, rtv_utils, rtv_programmeinfo
   5 import rtv_propertiesfile, rtv_selection
   6
   7 # TODO: delete old files:
   8 #          - scheduled recordings
   9 #          - logs
  10 #          - selections
  11
  12 MESSAGE_TIME_FORMAT = "%H:%M on %a"
  13
  14 at_output_re = re.compile( "job (\d+) at .*\n" )
  15
  16 def priority_time_compare( pi1, pi2 ):
  17         pi1Pri = pi1.get_priority()
  18         pi2Pri = pi2.get_priority()
  19
  20         if pi1Pri > pi2Pri:
  21                 return -1
  22         elif pi1Pri < pi2Pri:
  23                 return 1
  24         elif pi1.startTime < pi2.startTime:
  25                 return -1
  26         elif pi1.startTime > pi2.startTime:
  27                 return 1
  28
  29         return 0
  30
  31 class Schedule:
  32
  33         def __init__( self, config ):
  34                 self.config = config
  35
  36         def sub_title_matters( self, proginfo ):
  37                 return ( proginfo.sub_title is not None
  38                         and proginfo.unique_subtitles == True )
  39
  40         def add_to_old_progs_map( self, dr, fn, ret, delete_unused ):
  41                 if not fn.endswith( ".rtvinfo" ):
  42                         return
  43
  44                 full_path = os.path.join( dr, fn )
  45                 proginfo = rtv_programmeinfo.ProgrammeInfo()
  46                 proginfo.load( full_path )
  47
  48                 if not self.sub_title_matters( proginfo ):
  49                         if delete_unused:
  50                                 os.remove( full_path )
  51                         return
  52
  53                 if proginfo.title not in ret:
  54                         ret[proginfo.title] = {}
  55
  56                 if proginfo.sub_title not in ret[proginfo.title]:
  57                         ret[proginfo.title][proginfo.sub_title] = 1
  58
  59         def find_old_programmes_map( self, old_dir, converted_dir ):
  60                 ret = {}
  61
  62                 dr_list = os.listdir( old_dir )
  63                 for fn in dr_list:
  64                         self.add_to_old_progs_map( old_dir, fn, ret, True )
  65
  66                 for (dirpath, dirnames, filenames) in os.walk( converted_dir ):
  67                         for fn in filenames:
  68                                 self.add_to_old_progs_map( dirpath, fn, ret, False )
  69
  70                 return ret
  71
  72         def get_at_job( self, at_output ):
  73                 for ln in at_output:
  74                         m = at_output_re.match( ln )
  75                         if m:
  76                                 return m.group( 1 )
  77                 print ( "Unable to understand at command output '%s' - "
  78                         + "can't create a scheduled_events entry" ) % at_output
  79                 return None
  80
  81         def print_already_recorded( self, prog ):
  82                 print ( "Not recording '%s : %s' - we have recorded it in the past."
  83                         % ( prog.title, prog.sub_title ) )
  84
  85         def print_recording_today( self, prog ):
  86                 print ( "Not recording '%s : %s' - we are recording it today already."
  87                         % ( prog.title, prog.sub_title ) )
  88
  89         def remove_already_recorded( self, scheduler ):
  90                 old_dir = os.path.join( self.config.recorded_progs_dir, "old" )
  91                 converted_dir = self.config.converted_progs_dir
  92                 old_progs_map = scheduler.find_old_programmes_map( old_dir,
  93                         converted_dir )
  94
  95                 new_queue = []
  96                 new_queue_sub_titles_map = {}
  97
  98                 for prog in self.record_queue:
  99                         if ( prog.title in old_progs_map and
 100                                         prog.sub_title in old_progs_map[prog.title] ):
 101                                 self.print_already_recorded( prog )
 102                         elif ( prog.title in new_queue_sub_titles_map and
 103                                         prog.sub_title is not None and
 104                                         prog.sub_title in new_queue_sub_titles_map[prog.title] ):
 105                                 self.print_recording_today( prog )
 106                         else:
 107                                 new_queue.append( prog )
 108                                 if self.sub_title_matters( prog ):
 109                                         new_queue_sub_titles_map[prog.title] = prog.sub_title
 110
 111                 self.record_queue = new_queue
 112
 113
 114         def print_clash_priority_error( self, losePi, keepPi ):
 115                 print ( ("Not recording '%s' at %s - it clashes with '%s',"
 116                                                 + " which is higher priority (%d > %d).")
 117                                         % ( losePi.title,
 118                                                 losePi.startTime.strftime(
 119                                                         MESSAGE_TIME_FORMAT ),
 120                                                 keepPi.title, keepPi.get_priority(),
 121                                                 losePi.get_priority() ) )
 122
 123         def print_clash_time_error( self, losePi, keepPi ):
 124                 print ( ("Not recording '%s' at %s - it clashes with '%s',"
 125                                         + " which has the same priority (%d), but starts earlier"
 126                                         + " (%s).")
 127                                         % ( losePi.title,
 128                                                 losePi.startTime.strftime(
 129                                                         MESSAGE_TIME_FORMAT ),
 130                                                 keepPi.title, keepPi.get_priority(),
 131                                                 keepPi.startTime.strftime(
 132                                                         MESSAGE_TIME_FORMAT ) ) )
 133
 134         def print_clash_same_time( self, losePi, keepPi ):
 135                 print ( ("Not recording '%s' at %s - it clashes with '%s',"
 136                                         + " which has the same priority (%d). They start at"
 137                                         + " the same time, so the one to record was chosen"
 138                                         + " randomly.")
 139                                         % ( losePi.title,
 140                                                 losePi.startTime.strftime(
 141                                                         MESSAGE_TIME_FORMAT ),
 142                                                 keepPi.title, keepPi.get_priority() ) )
 143
 144
 145         def remove_clashes( self ):
 146                 self.record_queue.sort( priority_time_compare )
 147                 new_queue = []
 148
 149                 for pi1Num in range( len( self.record_queue ) ):
 150                         pi1 = self.record_queue[pi1Num]
 151
 152                         clashed_with = None
 153
 154                         for pi2 in new_queue:
 155
 156                                 if pi1.clashes_with( pi2 ):
 157                                         clashed_with = pi2
 158                                         break
 159
 160                         if not clashed_with:
 161                                 new_queue.append( pi1 )
 162                         else:
 163                                 if pi1.get_priority() < clashed_with.get_priority():
 164                                         self.print_clash_priority_error( pi1, clashed_with )
 165                                 elif pi1.startTime > clashed_with.startTime:
 166                                         self.print_clash_time_error( pi1, clashed_with )
 167                                 else:
 168                                         self.print_clash_same_time( pi1, clashed_with )
 169
 170                 self.record_queue = new_queue
 171
 172         def schedule_recordings( self, queue ):
 173
 174                 if len( queue ) == 0:
 175                         print "No programmes found to record."
 176                         return
 177
 178                 rtv_utils.ensure_dir_exists( self.config.recorded_progs_dir )
 179                 rtv_utils.ensure_dir_exists( self.config.scheduled_events_dir )
 180                 rtv_utils.ensure_dir_exists( self.config.recording_log_dir )
 181
 182                 for programmeInfo in queue:
 183
 184                         if programmeInfo.sub_title is None:
 185                                 st = ""
 186                         else:
 187                                 st = ": " + programmeInfo.sub_title
 188
 189                         print "Recording '%s%s' at '%s'" % ( programmeInfo.title,
 190                                 st, programmeInfo.startTime.strftime( MESSAGE_TIME_FORMAT ) )
 191
 192                         filename = rtv_utils.prepare_filename( programmeInfo.title )
 193                         filename += programmeInfo.startTime.strftime( "-%Y-%m-%d_%H_%M" )
 194
 195                         length_timedelta = programmeInfo.endTime - programmeInfo.startTime
 196                         length_in_seconds = ( ( length_timedelta.days
 197                                 * rtv_utils.SECS_IN_DAY ) + length_timedelta.seconds )
 198                         length_in_seconds += 60 * self.config.extra_recording_time_mins
 199
 200                         sched_filename = os.path.join( self.config.scheduled_events_dir,
 201                                 filename + ".rtvinfo" )
 202
 203                         outfilename = os.path.join( self.config.recorded_progs_dir,
 204                                 filename )
 205                         cmds_array = ( "at",
 206                                 programmeInfo.startTime.strftime( "%H:%M %d.%m.%Y" ) )
 207
 208                         if programmeInfo.filetype is not None:
 209                                 filetype = programmeInfo.filetype
 210                         else:
 211                                 filetype = ""
 212
 213                         at_output = rtv_utils.run_command_feed_input( cmds_array,
 214                                 self.config.record_start_command % (
 215                                         self.channel_xmltv2tzap.get_value( programmeInfo.channel ),
 216                                         outfilename, length_in_seconds, sched_filename, filetype,
 217                                         os.path.join( self.config.recording_log_dir,
 218                                                 filename + ".log" ) ) )
 219                         at_job_start = self.get_at_job( at_output )
 220
 221                         if at_job_start != None:
 222                                 programmeInfo.atJob = at_job_start
 223                                 programmeInfo.save( sched_filename )
 224
 225         def sax_callback( self, pi ):
 226                 for fav in self.favs_and_sels:
 227                         if fav.matches( pi ):
 228                                 dtnow = datetime.datetime.today()
 229                                 if( pi.startTime > dtnow
 230                                                 and (pi.startTime - dtnow).days
 231                                                         < self.config.options.days ):
 232
 233                                         if fav.deleteAfterDays:
 234                                                 pi.deleteTime = pi.endTime + datetime.timedelta(
 235                                                         float( fav.deleteAfterDays ), 0 )
 236
 237                                         pi.channel_pretty = self.channel_xmltv2tzap.get_value(
 238                                                 pi.channel )
 239                                         if not pi.channel_pretty:
 240                                                 print (
 241                                                         "Pretty channel name not found for channel %s"
 242                                                         % pi.channel )
 243
 244                                         pi.priority         = fav.priority
 245                                         pi.destination      = fav.destination
 246                                         pi.unique_subtitles = fav.unique_subtitles
 247                                         pi.filetype         = fav.filetype
 248
 249                                         if fav.real_title:
 250                                                 pi.title = fav.real_title
 251
 252                                         self.record_queue.append( pi )
 253                                 break
 254
 255         def remove_scheduled_events( self ):
 256
 257                 rtv_utils.ensure_dir_exists( self.config.scheduled_events_dir )
 258
 259                 for fn in os.listdir( self.config.scheduled_events_dir ):
 260                         full_fn = os.path.join( self.config.scheduled_events_dir, fn )
 261
 262                         pi = rtv_programmeinfo.ProgrammeInfo()
 263                         pi.load( full_fn )
 264
 265                         done_atrm = False
 266                         try:
 267                                 at_job_start = int( pi.atJob )
 268                                 rtv_utils.run_command( ( "atrm", str( at_job_start ) ) )
 269                                 done_atrm = True
 270                         except ValueError:
 271                                 pass
 272
 273                         if done_atrm:
 274                                 os.unlink( full_fn )
 275
 276         def delete_pending_recordings( self ):
 277                 rtv_utils.ensure_dir_exists( self.config.recorded_progs_dir )
 278
 279                 dttoday = datetime.datetime.today()
 280
 281                 for fn in os.listdir( self.config.recorded_progs_dir ):
 282                         if fn[-4:] in ( ".flv", ".avi" ):
 283
 284                                 infofn = os.path.join( self.config.recorded_progs_dir,
 285                                         fn[:-4] + ".rtvinfo" )
 286
 287                                 if os.path.isfile( infofn ):
 288
 289                                         pi = rtv_programmeinfo.ProgrammeInfo()
 290                                         pi.load( infofn )
 291
 292                                         if pi.deleteTime and pi.deleteTime < dttoday:
 293                                                 full_fn = os.path.join(
 294                                                         self.config.recorded_progs_dir, fn )
 295
 296                                                 print "Deleting file '%s'" % full_fn
 297
 298                                                 os.unlink( full_fn )
 299                                                 os.unlink( infofn )
 300
 301
 302
 303         def schedule( self, xmltv_parser = rtv_utils, fav_reader = rtv_selection,
 304                         scheduler = None ):
 305
 306                 if scheduler == None:
 307                         scheduler = self
 308
 309                 # TODO: if we are generating a TV guide as well as scheduling,
 310                 #       we should share the same XML parser.
 311
 312                 self.delete_pending_recordings()
 313
 314                 self.favs_and_sels = fav_reader.read_favs_and_selections(
 315                         self.config, record_only = True )
 316
 317                 self.channel_xmltv2tzap = rtv_propertiesfile.PropertiesFile()
 318                 self.channel_xmltv2tzap.load( self.config.channel_xmltv2tzap_file )
 319
 320                 scheduler.remove_scheduled_events()
 321
 322                 self.record_queue = []
 323                 xmltv_parser.parse_xmltv_files( self.config, self.sax_callback )
 324                 self.remove_already_recorded( scheduler )
 325                 self.remove_clashes()
 326                 scheduler.schedule_recordings( self.record_queue )
 327                 self.record_queue = []
 328
 329
 330 def schedule( config ):
 331         sch = Schedule( config )
 332         sch.schedule()
 333
 334
 335
 336
 337
 338 # === Test code ===
 339
 340 def format_title_subtitle( pi ):
 341         ret = pi.title
 342         if pi.sub_title:
 343                 ret += " : "
 344                 ret += pi.sub_title
 345         return ret
 346
 347 def format_pi_list( qu ):
 348         ret = "[ "
 349         for pi in qu[:-1]:
 350                 ret += format_title_subtitle( pi )
 351                 ret += ", "
 352         if len( qu ) > 0:
 353                 ret += format_title_subtitle( qu[-1] )
 354         ret += " ]"
 355
 356         return ret
 357
 358 class FakeScheduler( object ):
 359
 360         def __init__( self, schedule ):
 361
 362                 self.schedule = schedule
 363                 self.remove_scheduled_events_called = False
 364
 365                 dtnow = datetime.datetime.today()
 366
 367                 favHeroes = rtv_favourite.Favourite()
 368                 favHeroes.title_re = "Heroes"
 369
 370                 favNewsnight = rtv_favourite.Favourite()
 371                 favNewsnight.title_re = "Newsnight.*"
 372                 favNewsnight.priority = -50
 373
 374                 favLost = rtv_favourite.Favourite()
 375                 favLost.title_re = "Lost"
 376                 favLost.priority = -50
 377
 378                 favPocoyo = rtv_favourite.Favourite()
 379                 favPocoyo.title_re = "Pocoyo"
 380
 381                 self.test_favs = [ favHeroes, favNewsnight, favLost, favPocoyo ]
 382
 383                 self.piHeroes = rtv_programmeinfo.ProgrammeInfo()
 384                 self.piHeroes.title = "Heroes"
 385                 self.piHeroes.startTime = dtnow + datetime.timedelta( hours = 1 )
 386                 self.piHeroes.endTime = dtnow + datetime.timedelta( hours = 2 )
 387                 self.piHeroes.channel = "south-east.bbc2.bbc.co.uk"
 388
 389                 self.piNewsnight = rtv_programmeinfo.ProgrammeInfo()
 390                 self.piNewsnight.title = "Newsnight"
 391                 self.piNewsnight.startTime = dtnow + datetime.timedelta( hours = 1,
 392                         minutes = 30 )
 393                 self.piNewsnight.endTime = dtnow + datetime.timedelta( hours = 2 )
 394                 self.piNewsnight.channel = "south-east.bbc1.bbc.co.uk"
 395
 396                 self.piNR = rtv_programmeinfo.ProgrammeInfo()
 397                 self.piNR.title = "Newsnight Review"
 398                 self.piNR.startTime = dtnow + datetime.timedelta( hours = 2 )
 399                 self.piNR.endTime = dtnow + datetime.timedelta( hours = 2,
 400                         minutes = 30 )
 401                 self.piNR.channel = "south-east.bbc2.bbc.co.uk"
 402
 403                 self.piLost = rtv_programmeinfo.ProgrammeInfo()
 404                 self.piLost.title = "Lost"
 405                 self.piLost.startTime = dtnow + datetime.timedelta( hours = 1,
 406                         minutes = 25 )
 407                 self.piLost.endTime = dtnow + datetime.timedelta( hours = 2,
 408                         minutes = 30 )
 409                 self.piLost.channel = "channel4.com"
 410
 411                 self.piTurnip = rtv_programmeinfo.ProgrammeInfo()
 412                 self.piTurnip.title = "Newsnight Turnip"
 413                 self.piTurnip.startTime = dtnow + datetime.timedelta( hours = 1,
 414                         minutes = 30 )
 415                 self.piTurnip.endTime = dtnow + datetime.timedelta( hours = 2,
 416                         minutes = 30 )
 417                 self.piTurnip.channel = "channel5.co.uk"
 418
 419                 self.piPocoyo1 = rtv_programmeinfo.ProgrammeInfo()
 420                 self.piPocoyo1.title = "Pocoyo"
 421                 self.piPocoyo1.sub_title = "Subtitle already seen"
 422                 self.piPocoyo1.startTime = dtnow + datetime.timedelta( hours = 1 )
 423                 self.piPocoyo1.endTime = dtnow + datetime.timedelta( hours = 2 )
 424                 self.piPocoyo1.channel = "south-east.bbc2.bbc.co.uk"
 425
 426                 self.piPocoyo2 = rtv_programmeinfo.ProgrammeInfo()
 427                 self.piPocoyo2.title = "Pocoyo"
 428                 self.piPocoyo2.sub_title = "Subtitle not seen"
 429                 self.piPocoyo2.startTime = dtnow + datetime.timedelta( hours = 2 )
 430                 self.piPocoyo2.endTime = dtnow + datetime.timedelta( hours = 3 )
 431                 self.piPocoyo2.channel = "south-east.bbc2.bbc.co.uk"
 432
 433                 self.which_test = None
 434
 435         def find_old_programmes_map( self, old_dir, converted_dir ):
 436                 return { self.piPocoyo1.title : { self.piPocoyo1.sub_title : 1 } }
 437
 438         def parse_xmltv_files( self, config, callback ):
 439                 if self.which_test == "no_clash1":
 440                         callback( self.piNewsnight )
 441                         callback( self.piNR )
 442                 elif self.which_test == "priority_clash1":
 443                         callback( self.piHeroes )
 444                         callback( self.piNewsnight )
 445                 elif self.which_test == "time_clash1":
 446                         callback( self.piNewsnight )
 447                         callback( self.piLost )
 448                 elif self.which_test == "same_clash1":
 449                         callback( self.piNewsnight )
 450                         callback( self.piTurnip )
 451                 elif self.which_test == "norerecord":
 452                         callback( self.piPocoyo1 )
 453                         callback( self.piPocoyo2 )
 454
 455         def remove_scheduled_events( self ):
 456                 if self.remove_scheduled_events_called:
 457                         raise Exception( "remove_scheduled_events called twice." )
 458                 self.remove_scheduled_events_called = True
 459
 460         def read_favs_and_selections( self, config, record_only ):
 461                 return self.test_favs
 462
 463         def schedule_recordings( self, queue ):
 464                 self.queue = queue
 465
 466         def test( self ):
 467                 self.which_test = "priority_clash1"
 468                 self.schedule.schedule( self, self, self )
 469                 if not self.remove_scheduled_events_called:
 470                         raise Exception( "remove_scheduled_events never called" )
 471                 if self.queue != [self.piHeroes]:
 472                         raise Exception( "queue should look like %s, but it looks like %s"
 473                                 % ( [self.piHeroes], self.queue ) )
 474
 475
 476                 self.which_test = "no_clash1"
 477                 self.remove_scheduled_events_called = False
 478                 self.schedule.schedule( self, self, self )
 479                 if not self.remove_scheduled_events_called:
 480                         raise Exception( "remove_scheduled_events never called" )
 481                 if self.queue != [self.piNewsnight, self.piNR]:
 482                         raise Exception( "queue should look like %s, but it looks like %s"
 483                                 % ( [self.piNewsnight, self.piNR], self.queue ) )
 484
 485                 self.which_test = "time_clash1"
 486                 self.remove_scheduled_events_called = False
 487                 self.schedule.schedule( self, self, self )
 488                 if not self.remove_scheduled_events_called:
 489                         raise Exception( "remove_scheduled_events never called" )
 490                 if self.queue != [self.piLost]:
 491                         raise Exception( "queue should look like %s, but it looks like %s"
 492                                 % ( [self.piLost], self.queue ) )
 493
 494                 self.which_test = "same_clash1"
 495                 self.remove_scheduled_events_called = False
 496                 self.schedule.schedule( self, self, self )
 497                 if not self.remove_scheduled_events_called:
 498                         raise Exception( "remove_scheduled_events never called" )
 499                 if self.queue != [self.piNewsnight] and self.queue != [self.piTurnip]:
 500                         raise Exception( ("queue should look like %s or %s, but it"
 501                                         + " looks like %s" )
 502                                 % ( format_pi_list( [self.piNewsnight] ),
 503                                         format_pi_list( [self.piTurnip] ),
 504                                         format_pi_list( self.queue ) ) )
 505
 506         def test_norerecord( self ):
 507                 self.which_test = "norerecord"
 508                 self.remove_scheduled_events_called = False
 509                 self.schedule.schedule( self, self, self )
 510
 511                 if not self.remove_scheduled_events_called:
 512                         raise Exception( "remove_scheduled_events never called" )
 513                 if self.queue != [self.piPocoyo2]:
 514                         raise Exception( ("queue should look like %s, but it"
 515                                         + " looks like %s" )
 516                                 % ( format_pi_list( [self.piPocoyo2] ),
 517                                         format_pi_list( self.queue ) ) )
 518
 519
 520
 521 class FakeScheduler_SameTitleSameDay( FakeScheduler ):
 522
 523         def __init__( self, schedule ):
 524                 FakeScheduler.__init__( self, schedule )
 525
 526         def find_old_programmes_map( self, old_dir, converted_dir ):
 527                 return {}
 528
 529         def parse_xmltv_files( self, config, callback ):
 530                 dtnow = datetime.datetime.today()
 531
 532                 # 2 with no subtitle
 533                 self.piPocoyo1 = rtv_programmeinfo.ProgrammeInfo()
 534                 self.piPocoyo1.title = "Pocoyo"
 535                 self.piPocoyo1.startTime = dtnow + datetime.timedelta( hours = 1 )
 536                 self.piPocoyo1.endTime = dtnow + datetime.timedelta( hours = 2 )
 537                 self.piPocoyo1.channel = "south-east.bbc2.bbc.co.uk"
 538
 539                 self.piPocoyo2 = rtv_programmeinfo.ProgrammeInfo()
 540                 self.piPocoyo2.title = "Pocoyo"
 541                 self.piPocoyo2.startTime = dtnow + datetime.timedelta( hours = 2 )
 542                 self.piPocoyo2.endTime = dtnow + datetime.timedelta( hours = 3 )
 543                 self.piPocoyo2.channel = "south-east.bbc2.bbc.co.uk"
 544
 545                 # 2 with identical subtitle
 546                 self.piPocoyo3 = rtv_programmeinfo.ProgrammeInfo()
 547                 self.piPocoyo3.title = "Pocoyo"
 548                 self.piPocoyo3.sub_title = "Subtitle we will see twice"
 549                 self.piPocoyo3.startTime = dtnow + datetime.timedelta( hours = 3 )
 550                 self.piPocoyo3.endTime = dtnow + datetime.timedelta( hours = 4 )
 551                 self.piPocoyo3.channel = "south-east.bbc2.bbc.co.uk"
 552
 553                 self.piPocoyo4 = rtv_programmeinfo.ProgrammeInfo()
 554                 self.piPocoyo4.title = "Pocoyo"
 555                 self.piPocoyo4.sub_title = "Subtitle we will see twice"
 556                 self.piPocoyo4.startTime = dtnow + datetime.timedelta( hours = 4 )
 557                 self.piPocoyo4.endTime = dtnow + datetime.timedelta( hours = 5 )
 558                 self.piPocoyo4.channel = "south-east.bbc2.bbc.co.uk"
 559
 560                 callback( self.piPocoyo1 )
 561                 callback( self.piPocoyo2 )
 562                 callback( self.piPocoyo3 )
 563                 callback( self.piPocoyo4 )
 564
 565         def read_favs_and_selections( self, config, record_only ):
 566                 favPocoyo = rtv_favourite.Favourite()
 567                 favPocoyo.title_re = "Pocoyo"
 568                 return [ favPocoyo ]
 569
 570         def test( self ):
 571                 self.schedule.schedule( self, self, self )
 572
 573                 if not self.remove_scheduled_events_called:
 574                         raise Exception( "remove_scheduled_events never called" )
 575
 576                 expected_queue = [ self.piPocoyo1, self.piPocoyo2, self.piPocoyo3 ]
 577
 578                 if self.queue != expected_queue:
 579                         raise Exception( ("queue should look like %s, but it"
 580                                         + " looks like %s" )
 581                                 % ( format_pi_list( [self.piPocoyo3] ),
 582                                         format_pi_list( self.queue ) ) )
 583
 584
 585 def test( config ):
 586         p = FakeScheduler( Schedule( config ) )
 587
 588         p.test()
 589         p.test_norerecord()
 590
 591         FakeScheduler_SameTitleSameDay( Schedule( config ) ).test()
 592
 593
 594