resources/lib/Library.py

   1 #!/usr/bin/env python
   2 # -*- coding: utf-8 -*-
   3 # Module: LibraryExporter
   4 # Created on: 13.01.2017
   5
   6 import os
   7 import shutil
   8 try:
   9    import cPickle as pickle
  10 except:
  11    import pickle
  12 from utils import noop
  13
  14 class Library:
  15     """Exports Netflix shows & movies to a local library folder"""
  16
  17     series_label = 'shows'
  18     """str: Label to identify shows"""
  19
  20     movies_label = 'movies'
  21     """str: Label to identify movies"""
  22
  23     db_filename = 'lib.ndb'
  24     """str: (File)Name of the store for the database dump that contains all shows/movies added to the library"""
  25
  26     def __init__ (self, root_folder, library_settings, log_fn=noop):
  27         """Takes the instances & configuration options needed to drive the plugin
  28
  29         Parameters
  30         ----------
  31         root_folder : :obj:`str`
  32             Cookie location
  33
  34         library_settings : :obj:`str`
  35             User data cache location
  36
  37         library_db_path : :obj:`str`
  38             User data cache location
  39
  40         log_fn : :obj:`fn`
  41              optional log function
  42         """
  43         self.base_data_path = root_folder
  44         self.enable_custom_library_folder = library_settings['enablelibraryfolder']
  45         self.custom_library_folder = library_settings['customlibraryfolder']
  46         self.db_filepath = os.path.join(self.base_data_path, self.db_filename)
  47         self.log = log_fn
  48
  49         # check for local library folder & set up the paths
  50         lib_path = self.base_data_path if self.enable_custom_library_folder != 'true' else self.custom_library_folder
  51         self.movie_path = os.path.join(lib_path, self.movies_label)
  52         self.tvshow_path = os.path.join(lib_path, self.series_label)
  53
  54         # check if we need to setup the base folder structure & do so if needed
  55         self.setup_local_netflix_library(source={
  56             self.movies_label: self.movie_path,
  57             self.series_label: self.tvshow_path
  58         })
  59
  60         # load the local db
  61         self.db = self._load_local_db(filename=self.db_filepath)
  62
  63     def setup_local_netflix_library (self, source):
  64         """Sets up the basic directories
  65
  66         Parameters
  67         ----------
  68         source : :obj:`dict` of :obj:`str`
  69             Dicitionary with directories to be created
  70         """
  71         for label in source:
  72             if not os.path.exists(source[label]):
  73                 os.makedirs(source[label])
  74
  75     def write_strm_file(self, path, url):
  76         """Writes the stream file that Kodi can use to integrate it into the DB
  77
  78         Parameters
  79         ----------
  80         path : :obj:`str`
  81             Filepath of the file to be created
  82
  83         url : :obj:`str`
  84             Stream url
  85         """
  86         with open(path, 'w+') as f:
  87             f.write(url)
  88             f.close()
  89
  90     def _load_local_db (self, filename):
  91         """Loads the local db file and parses it, creates one if not existent
  92
  93         Parameters
  94         ----------
  95         filename : :obj:`str`
  96             Filepath of db file
  97
  98         Returns
  99         -------
 100         :obj:`dict`
 101             Parsed contents of the db file
 102         """
 103         # if the db doesn't exist, create it
 104         if not os.path.isfile(filename):
 105             data = {self.movies_label: {}, self.series_label: {}}
 106             self.log('Setup local library DB')
 107             self._update_local_db(filename=filename, db=data)
 108             return data
 109
 110         with open(filename) as f:
 111             data = pickle.load(f)
 112             if data:
 113                 return data
 114             else:
 115                 return {}
 116
 117     def _update_local_db (self, filename, db):
 118         """Updates the local db file with new data
 119
 120         Parameters
 121         ----------
 122         filename : :obj:`str`
 123             Filepath of db file
 124
 125         db : :obj:`dict`
 126             Database contents
 127
 128         Returns
 129         -------
 130         bool
 131             Update has been successfully executed
 132         """
 133         if not os.path.isdir(os.path.dirname(filename)):
 134             return False
 135         with open(filename, 'w') as f:
 136             f.truncate()
 137             pickle.dump(db, f)
 138         return True
 139
 140     def movie_exists (self, title, year):
 141         """Checks if a movie is already present in the local DB
 142
 143         Parameters
 144         ----------
 145         title : :obj:`str`
 146             Title of the movie
 147
 148         year : :obj:`int`
 149             Release year of the movie
 150
 151         Returns
 152         -------
 153         bool
 154             Movie exists in DB
 155         """
 156         movie_meta = '%s (%d)' % (title, year)
 157         return movie_meta in self.db[self.movies_label]
 158
 159     def show_exists (self, title):
 160         """Checks if a show is present in the local DB
 161
 162         Parameters
 163         ----------
 164         title : :obj:`str`
 165             Title of the show
 166
 167         Returns
 168         -------
 169         bool
 170             Show exists in DB
 171         """
 172         show_meta = '%s' % (title)
 173         return show_meta in self.db[self.series_label]
 174
 175     def season_exists (self, title, season):
 176         """Checks if a season is present in the local DB
 177
 178         Parameters
 179         ----------
 180         title : :obj:`str`
 181             Title of the show
 182
 183         season : :obj:`int`
 184             Season sequence number
 185
 186         Returns
 187         -------
 188         bool
 189             Season of show exists in DB
 190         """
 191         if self.show_exists(title) == False:
 192             return False
 193         show_entry = self.db[self.series_label][title]
 194         return season in show_entry['seasons']
 195
 196     def episode_exists (self, title, season, episode):
 197         """Checks if an episode if a show is present in the local DB
 198
 199         Parameters
 200         ----------
 201         title : :obj:`str`
 202             Title of the show
 203
 204         season : :obj:`int`
 205             Season sequence number
 206
 207         episode : :obj:`int`
 208             Episode sequence number
 209
 210         Returns
 211         -------
 212         bool
 213             Episode of show exists in DB
 214         """
 215         if self.show_exists(title) == False:
 216             return False
 217         show_entry = self.db[self.series_label][title]
 218         episode_entry = 'S%02dE%02d' % (season, episode)
 219         return episode_entry in show_entry['episodes']
 220
 221     def add_movie (self, title, alt_title, year, video_id, pin, build_url):
 222         """Adds a movie to the local db, generates & persists the strm file
 223
 224         Parameters
 225         ----------
 226         title : :obj:`str`
 227             Title of the show
 228
 229         alt_title : :obj:`str`
 230             Alternative title given by the user
 231
 232         year : :obj:`int`
 233             Release year of the show
 234
 235         video_id : :obj:`str`
 236             ID of the video to be played
 237
 238         pin : bool
 239             Needs adult pin
 240
 241         build_url : :obj:`fn`
 242             Function to generate the stream url
 243         """
 244
 245         movie_meta = '%s (%d)' % (title, year)
 246         folder = alt_title
 247         dirname = os.path.join(self.movie_path, folder)
 248         filename = os.path.join(dirname, movie_meta + '.strm')
 249         if os.path.exists(filename):
 250             return
 251         if not os.path.exists(dirname):
 252             os.makedirs(dirname)
 253         if self.movie_exists(title=title, year=year) == False:
 254             self.db[self.movies_label][movie_meta] = {'alt_title': alt_title}
 255             self._update_local_db(filename=self.db_filepath, db=self.db)
 256         self.write_strm_file(path=filename, url=build_url({'action': 'play_video', 'video_id': video_id, 'pin': pin}))
 257
 258     def add_show (self, title, alt_title, episodes, build_url):
 259         """Adds a show to the local db, generates & persists the strm files
 260
 261         Note: Can also used to store complete seasons or single episodes, it all depends on
 262         what is present in the episodes dictionary
 263
 264         Parameters
 265         ----------
 266         title : :obj:`str`
 267             Title of the show
 268
 269         alt_title : :obj:`str`
 270             Alternative title given by the user
 271
 272         episodes : :obj:`dict` of :obj:`dict`
 273             Episodes that need to be added
 274
 275         build_url : :obj:`fn`
 276             Function to generate the stream url
 277         """
 278         show_meta = '%s' % (title)
 279         folder = alt_title
 280         show_dir = os.path.join(self.tvshow_path, folder)
 281         if not os.path.exists(show_dir):
 282             os.makedirs(show_dir)
 283         if self.show_exists(title) == False:
 284             self.db[self.series_label][show_meta] = {'seasons': [], 'episodes': [], 'alt_title': alt_title}
 285         for episode in episodes:
 286             self._add_episode(show_dir=show_dir, title=title, season=episode['season'], episode=episode['episode'], video_id=episode['id'], pin=episode['pin'], build_url=build_url)
 287         self._update_local_db(filename=self.db_filepath, db=self.db)
 288         return show_dir
 289
 290     def _add_episode (self, title, show_dir, season, episode, video_id, pin, build_url):
 291         """Adds a single episode to the local DB, generates & persists the strm file
 292
 293         Parameters
 294         ----------
 295         title : :obj:`str`
 296             Title of the show
 297
 298         show_dir : :obj:`str`
 299             Directory that holds the stream files for that show
 300
 301         season : :obj:`int`
 302             Season sequence number
 303
 304         episode : :obj:`int`
 305             Episode sequence number
 306
 307         video_id : :obj:`str`
 308             ID of the video to be played
 309
 310         pin : bool
 311             Needs adult pin
 312
 313         build_url : :obj:`fn`
 314             Function to generate the stream url
 315         """
 316         season = int(season)
 317         episode = int(episode)
 318
 319         # add season
 320         if self.season_exists(title=title, season=season) == False:
 321             self.db[self.series_label][title]['seasons'].append(season)
 322
 323         # add episode
 324         episode_meta = 'S%02dE%02d' % (season, episode)
 325         if self.episode_exists(title=title, season=season, episode=episode) == False:
 326             self.db[self.series_label][title]['episodes'].append(episode_meta)
 327
 328         # create strm file
 329         filename = episode_meta + '.strm'
 330         filepath = os.path.join(show_dir, filename)
 331         if os.path.exists(filepath):
 332             return
 333         self.write_strm_file(path=filepath, url=build_url({'action': 'play_video', 'video_id': video_id, 'pin': pin}))
 334
 335     def remove_movie (self, title, year):
 336         """Removes the DB entry & the strm file for the movie given
 337
 338         Parameters
 339         ----------
 340         title : :obj:`str`
 341             Title of the movie
 342
 343         year : :obj:`int`
 344             Release year of the movie
 345
 346         Returns
 347         -------
 348         bool
 349             Delete successfull
 350         """
 351         movie_meta = '%s (%d)' % (title, year)
 352         folder = self.db[self.movies_label][movie_meta]['alt_title']
 353         del self.db[self.movies_label][movie_meta]
 354         self._update_local_db(filename=self.db_filepath, db=self.db)
 355         dirname = os.path.join(self.movie_path, folder)
 356         if os.path.exists(dirname):
 357             shutil.rmtree(dirname)
 358             return True
 359         return False
 360
 361     def remove_show (self, title):
 362         """Removes the DB entry & the strm files for the show given
 363
 364         Parameters
 365         ----------
 366         title : :obj:`str`
 367             Title of the show
 368
 369         Returns
 370         -------
 371         bool
 372             Delete successfull
 373         """
 374         folder = self.db[self.series_label][title]['alt_title']
 375         del self.db[self.series_label][title]
 376         self._update_local_db(filename=self.db_filepath, db=self.db)
 377         show_dir = os.path.join(self.tvshow_path, folder)
 378         if os.path.exists(show_dir):
 379             shutil.rmtree(show_dir)
 380             return True
 381         return False
 382
 383     def remove_season (self, title, season):
 384         """Removes the DB entry & the strm files for a season of a show given
 385
 386         Parameters
 387         ----------
 388         title : :obj:`str`
 389             Title of the show
 390
 391         season : :obj:`int`
 392             Season sequence number
 393
 394         Returns
 395         -------
 396         bool
 397             Delete successfull
 398         """
 399         season = int(season)
 400         season_list = []
 401         episodes_list = []
 402         show_meta = '%s' % (title)
 403         for season_entry in self.db[self.series_label][show_meta]['seasons']:
 404             if season_entry != season:
 405                 season_list.append(season_entry)
 406         self.db[self.series_label][show_meta]['seasons'] = season_list
 407         show_dir = os.path.join(self.tvshow_path, self.db[self.series_label][show_meta]['alt_title'])
 408         if os.path.exists(show_dir):
 409             show_files = [f for f in os.listdir(show_dir) if os.path.isfile(os.path.join(show_dir, f))]
 410             for filename in show_files:
 411                 if 'S%02dE' % (season) in filename:
 412                     os.remove(os.path.join(show_dir, filename))
 413                 else:
 414                     episodes_list.append(filename.replace('.strm', ''))
 415             self.db[self.series_label][show_meta]['episodes'] = episodes_list
 416         self._update_local_db(filename=self.db_filepath, db=self.db)
 417         return True
 418
 419     def remove_episode (self, title, season, episode):
 420         """Removes the DB entry & the strm files for an episode of a show given
 421
 422         Parameters
 423         ----------
 424         title : :obj:`str`
 425             Title of the show
 426
 427         season : :obj:`int`
 428             Season sequence number
 429
 430         episode : :obj:`int`
 431             Episode sequence number
 432
 433         Returns
 434         -------
 435         bool
 436             Delete successfull
 437         """
 438         episodes_list = []
 439         show_meta = '%s' % (title)
 440         episode_meta = 'S%02dE%02d' % (season, episode)
 441         show_dir = os.path.join(self.tvshow_path, self.db[self.series_label][show_meta]['alt_title'])
 442         if os.path.exists(os.path.join(show_dir, episode_meta + '.strm')):
 443             os.remove(os.path.join(show_dir, episode_meta + '.strm'))
 444         for episode_entry in self.db[self.series_label][show_meta]['episodes']:
 445             if episode_meta != episode_entry:
 446                 episodes_list.append(episode_entry)
 447         self.db[self.series_label][show_meta]['episodes'] = episodes_list
 448         self._update_local_db(filename=self.db_filepath, db=self.db)
 449         return True