rename nzbtomedia to core. Fixes #744 #746

core/autoProcess/autoProcessComics.py

@@ -0,0 +1,78 @@
+import os
+import time
+import core
+import requests
+import time
+from core.nzbToMediaUtil import convert_to_ascii, remoteDir, server_responding
+from core.nzbToMediaSceneExceptions import process_all_exceptions
+from core import logger
+
+class autoProcessComics:
+    def processEpisode(self, section, dirName, inputName=None, status=0, clientAgent='manual', inputCategory=None):
+        if int(status) != 0:
+            logger.warning("FAILED DOWNLOAD DETECTED, nothing to process.",section)
+            return [1, "%s: Failed to post-process. %s does not support failed downloads" % (section, section) ]
+
+        host = core.CFG[section][inputCategory]["host"]
+        port = core.CFG[section][inputCategory]["port"]
+        username = core.CFG[section][inputCategory]["username"]
+        password = core.CFG[section][inputCategory]["password"]
+        try:
+            ssl = int(core.CFG[section][inputCategory]["ssl"])
+        except:
+            ssl = 0
+        try:
+            web_root = core.CFG[section][inputCategory]["web_root"]
+        except:
+            web_root = ""
+        try:
+            remote_path = int(core.CFG[section][inputCategory]["remote_path"])
+        except:
+            remote_path = 0
+
+        if ssl:
+            protocol = "https://"
+        else:
+            protocol = "http://"
+
+        url = "%s%s:%s%s/post_process" % (protocol, host, port, web_root)
+        if not server_responding(url):
+            logger.error("Server did not respond. Exiting", section)
+            return [1, "%s: Failed to post-process - %s did not respond." % (section, section) ]
+
+        inputName, dirName = convert_to_ascii(inputName, dirName)
+        clean_name, ext = os.path.splitext(inputName)
+        if len(ext) == 4:  # we assume this was a standrard extension. 
+            inputName = clean_name
+
+        params = {}
+        params['nzb_folder'] = dirName
+
+        if remote_path:
+            params['nzb_folder'] = remoteDir(dirName)
+
+        if inputName != None:
+            params['nzb_name'] = inputName
+
+        success = False
+
+        logger.debug("Opening URL: %s" % (url), section)
+        try:
+            r = requests.get(url, auth=(username, password), params=params, stream=True, verify=False, timeout=(30, 300))
+        except requests.ConnectionError:
+            logger.error("Unable to open URL", section)
+            return [1, "%s: Failed to post-process - Unable to connect to %s" % (section, section) ]
+        for line in r.iter_lines():
+            if line: logger.postprocess("%s" % (line), section)
+            if ("Post Processing SUCCESSFUL!" or "Post Processing SUCCESSFULL!")in line: success = True
+
+        if not r.status_code in [requests.codes.ok, requests.codes.created, requests.codes.accepted]:
+            logger.error("Server returned status %s" % (str(r.status_code)), section)
+            return [1, "%s: Failed to post-process - Server returned status %s" % (section, str(r.status_code)) ]
+
+        if success:
+            logger.postprocess("SUCCESS: This issue has been processed successfully",section)
+            return [0, "%s: Successfully post-processed %s" % (section, inputName) ]
+        else:
+            logger.warning("The issue does not appear to have successfully processed. Please check your Logs",section)
+            return [1, "%s: Failed to post-process - Returned log from %s was not as expected." % (section, section) ]

core/autoProcess/autoProcessGames.py

@@ -0,0 +1,83 @@
+import core
+import requests
+import shutil
+from core.nzbToMediaUtil import convert_to_ascii, server_responding
+from core.nzbToMediaSceneExceptions import process_all_exceptions
+from core import logger
+
+class autoProcessGames:
+    def process(self, section, dirName, inputName=None, status=0, clientAgent='manual', inputCategory=None):
+        status = int(status)
+
+        host = core.CFG[section][inputCategory]["host"]
+        port = core.CFG[section][inputCategory]["port"]
+        apikey = core.CFG[section][inputCategory]["apikey"]
+        try:
+            library = core.CFG[section][inputCategory]["library"]
+        except:
+            library = None
+        try:
+            ssl = int(core.CFG[section][inputCategory]["ssl"])
+        except:
+            ssl = 0
+        try:
+            web_root = core.CFG[section][inputCategory]["web_root"]
+        except:
+            web_root = ""
+
+        if ssl:
+            protocol = "https://"
+        else:
+            protocol = "http://"
+
+        url = "%s%s:%s%s/api" % (protocol, host, port, web_root)
+        if not server_responding(url):
+            logger.error("Server did not respond. Exiting", section)
+            return [1, "%s: Failed to post-process - %s did not respond." % (section, section) ]
+
+        inputName, dirName = convert_to_ascii(inputName, dirName)
+
+        fields = inputName.split("-")
+
+        gamezID = fields[0].replace("[","").replace("]","").replace(" ","")
+
+        downloadStatus = 'Wanted'
+        if status == 0:
+            downloadStatus = 'Downloaded'
+
+        params = {}
+        params['api_key'] = apikey
+        params['mode'] = 'UPDATEREQUESTEDSTATUS'
+        params['db_id'] = gamezID
+        params['status'] = downloadStatus
+
+        logger.debug("Opening URL: %s" % (url),section)
+
+        try:
+            r = requests.get(url, params=params, verify=False, timeout=(30, 300))
+        except requests.ConnectionError:
+            logger.error("Unable to open URL")
+            return [1, "%s: Failed to post-process - Unable to connect to %s" % (section, section) ]
+
+        result = r.json()
+        logger.postprocess("%s" % (result),section)
+        if library:
+            logger.postprocess("moving files to library: %s" % (library),section)
+            try:
+                shutil.move(dirName, os.path.join(library, inputName))
+            except:
+                logger.error("Unable to move %s to %s" % (dirName, os.path.join(library, inputName)), section)
+                return [1, "%s: Failed to post-process - Unable to move files" % (section) ]
+        else:
+            logger.error("No library specified to move files to. Please edit your configuration.", section)
+            return [1, "%s: Failed to post-process - No library defined in %s" % (section, section) ]
+
+        if not r.status_code in [requests.codes.ok, requests.codes.created, requests.codes.accepted]:
+            logger.error("Server returned status %s" % (str(r.status_code)), section)
+            return [1, "%s: Failed to post-process - Server returned status %s" % (section, str(r.status_code)) ]
+        elif result['success']:
+            logger.postprocess("SUCCESS: Status for %s has been set to %s in Gamez" % (gamezID, downloadStatus),section)
+            return [0, "%s: Successfully post-processed %s" % (section, inputName) ]
+        else:
+            logger.error("FAILED: Status for %s has NOT been updated in Gamez" % (gamezID),section)
+            return [1, "%s: Failed to post-process - Returned log from %s was not as expected." % (section, section) ]

core/autoProcess/autoProcessMovie.py

@@ -0,0 +1,354 @@
+import os
+import time
+import requests
+import core
+
+from core.nzbToMediaSceneExceptions import process_all_exceptions
+from core.nzbToMediaUtil import convert_to_ascii, rmDir, find_imdbid, find_download, listMediaFiles, remoteDir, import_subs, server_responding, reportNzb
+from core import logger
+from core.transcoder import transcoder
+
+
+class autoProcessMovie:
+    def get_release(self, baseURL, imdbid=None, download_id=None, release_id=None):
+        results = {}
+        params = {}
+
+        # determin cmd and params to send to CouchPotato to get our results
+        section = 'movies'
+        cmd = "/media.list"
+        if release_id or imdbid:
+            section = 'media'
+            cmd = "/media.get"
+            params['id'] = release_id or imdbid
+
+        url = baseURL + cmd
+        logger.debug("Opening URL: %s with PARAMS: %s" % (url, params))
+
+        try:
+            r = requests.get(url, params=params, verify=False, timeout=(30, 60))
+        except requests.ConnectionError:
+            logger.error("Unable to open URL %s" % url)
+            return results
+
+        try:
+            result = r.json()
+        except:
+            logger.error("CouchPotato returned the following non-json data")
+            for line in r.iter_lines():
+                logger.error("%s" %(line))
+            return results
+
+        if not result['success']:
+            if 'error' in result:
+                logger.error(str(result['error']))
+            else:
+                logger.error("no media found for id %s" % (params['id'])) 
+            return results
+
+        # Gather release info and return it back, no need to narrow results
+        if release_id:
+            try:
+                id = result[section]['_id']
+                results[id] = result[section]
+                return results
+            except:pass
+
+        # Gather release info and proceed with trying to narrow results to one release choice
+
+        movies = result[section]
+        if not isinstance(movies, list):
+            movies = [movies]
+        for movie in movies:
+            if movie['status'] not in ['active', 'done']:
+                continue
+            releases = movie['releases']
+            for release in releases:
+                try:
+                    if release['status'] not in ['snatched', 'downloaded', 'done']:
+                        continue
+                    if download_id:
+                        if download_id != release['download_info']['id']:
+                            continue
+
+                    id = release['_id']
+                    results[id] = release
+                except:
+                    continue
+
+        # Narrow results by removing old releases by comparing their last_edit field
+        if len(results) > 1:
+            for id1, x1 in results.items():
+                for id2, x2 in results.items():
+                    try:
+                        if x2["last_edit"] > x1["last_edit"]:
+                            results.pop(id1)
+                    except:
+                        continue
+
+        # Search downloads on clients for a match to try and narrow our results down to 1
+        if len(results) > 1:
+            for id, x in results.items():
+                try:
+                    if not find_download(str(x['download_info']['downloader']).lower(), x['download_info']['id']):
+                        results.pop(id)
+                except:
+                    continue
+
+        return results
+
+    def process(self, section, dirName, inputName=None, status=0, clientAgent="manual", download_id="", inputCategory=None, failureLink=None):
+
+        host = core.CFG[section][inputCategory]["host"]
+        port = core.CFG[section][inputCategory]["port"]
+        apikey = core.CFG[section][inputCategory]["apikey"]
+        method = core.CFG[section][inputCategory]["method"]
+        delete_failed = int(core.CFG[section][inputCategory]["delete_failed"])
+        wait_for = int(core.CFG[section][inputCategory]["wait_for"])
+
+        try:
+            ssl = int(core.CFG[section][inputCategory]["ssl"])
+        except:
+            ssl = 0
+        try:
+            web_root = core.CFG[section][inputCategory]["web_root"]
+        except:
+            web_root = ""
+        try:
+            remote_path = int(core.CFG[section][inputCategory]["remote_path"])
+        except:
+            remote_path = 0
+        try:
+            extract = int(section[inputCategory]["extract"])
+        except:
+            extract = 0
+
+        if ssl:
+            protocol = "https://"
+        else:
+            protocol = "http://"
+
+        baseURL = "%s%s:%s%s/api/%s" % (protocol, host, port, web_root, apikey)
+        if not server_responding(baseURL):
+            logger.error("Server did not respond. Exiting", section)
+            return [1, "%s: Failed to post-process - %s did not respond." % (section, section) ]
+
+        imdbid = find_imdbid(dirName, inputName)
+        release = self.get_release(baseURL, imdbid, download_id)
+
+        # pull info from release found if available
+        release_id = None
+        media_id = None
+        downloader = None
+        release_status_old = None
+        if release:
+            try:
+                release_id = release.keys()[0]
+                media_id = release[release_id]['media_id']
+                download_id = release[release_id]['download_info']['id']
+                downloader = release[release_id]['download_info']['downloader']
+                release_status_old = release[release_id]['status']
+            except:
+                pass
+
+        if not os.path.isdir(dirName) and os.path.isfile(dirName): # If the input directory is a file, assume single file download and split dir/name.
+            dirName = os.path.split(os.path.normpath(dirName))[0]
+
+        SpecificPath = os.path.join(dirName, str(inputName))
+        cleanName = os.path.splitext(SpecificPath)
+        if cleanName[1] == ".nzb":
+            SpecificPath = cleanName[0]
+        if os.path.isdir(SpecificPath):
+            dirName = SpecificPath
+
+        process_all_exceptions(inputName, dirName)
+        inputName, dirName = convert_to_ascii(inputName, dirName)
+
+        if not listMediaFiles(dirName, media=True, audio=False, meta=False, archives=False) and listMediaFiles(dirName, media=False, audio=False, meta=False, archives=True) and extract:
+            logger.debug('Checking for archives to extract in directory: %s' % (dirName))
+            core.extractFiles(dirName)
+            inputName, dirName = convert_to_ascii(inputName, dirName)
+
+        good_files = 0
+        num_files = 0
+        # Check video files for corruption
+        status = int(status)
+        for video in listMediaFiles(dirName, media=True, audio=False, meta=False, archives=False):
+            num_files += 1
+            if transcoder.isVideoGood(video, status):
+                import_subs(video)
+                good_files += 1
+        if num_files > 0 and good_files == num_files:
+            if status:
+                logger.info("Status shown as failed from Downloader, but %s valid video files found. Setting as success." % (str(good_files)), section)
+                status = 0
+        elif num_files > 0 and good_files < num_files:
+            logger.info("Status shown as success from Downloader, but corrupt video files found. Setting as failed.", section)
+            if os.environ.has_key('NZBOP_VERSION') and os.environ['NZBOP_VERSION'][0:5] >= '14.0':
+                print('[NZB] MARK=BAD')
+            if failureLink:
+                failureLink = failureLink + '&corrupt=true'
+            status = 1
+        elif clientAgent == "manual":
+            logger.warning("No media files found in directory %s to manually process." % (dirName), section)
+            return [0, ""]  # Success (as far as this script is concerned)
+        else:
+            logger.warning("No media files found in directory %s. Processing this as a failed download" % (dirName), section)
+            status = 1
+
+        if status == 0:
+            if core.TRANSCODE == 1:
+                result, newDirName = transcoder.Transcode_directory(dirName)
+                if result == 0:
+                    logger.debug("Transcoding succeeded for files in %s" % (dirName), section)
+                    dirName = newDirName
+                else:
+                    logger.error("Transcoding failed for files in %s" % (dirName), section)
+                    return [1, "%s: Failed to post-process - Transcoding failed" % (section) ]
+            for video in listMediaFiles(dirName, media=True, audio=False, meta=False, archives=False): 
+                if not release and not ".cp(tt" in video and imdbid:
+                    videoName, videoExt = os.path.splitext(video)
+                    video2 = "%s.cp(%s)%s" % (videoName, imdbid, videoExt)
+                    logger.debug('Renaming: %s to: %s' % (video, video2))
+                    os.rename(video, video2)        
+
+            params = {}
+            if download_id:
+                params['downloader'] = downloader or clientAgent
+                params['download_id'] = download_id
+
+            params['media_folder'] = dirName
+            if remote_path:
+                params['media_folder'] = remoteDir(dirName)
+
+            if method == "manage":
+                command = "/manage.update"
+                params = {}
+            else:
+                command = "/renamer.scan"
+
+            url = "%s%s" % (baseURL, command)
+
+            logger.debug("Opening URL: %s with PARAMS: %s" % (url, params), section)
+
+            logger.postprocess("Starting %s scan for %s" % (method, inputName), section)
+
+            try:
+                r = requests.get(url, params=params, verify=False, timeout=(30, 1800))
+            except requests.ConnectionError:
+                logger.error("Unable to open URL", section)
+                return [1, "%s: Failed to post-process - Unable to connect to %s" % (section, section) ]
+
+            result = r.json()
+            if not r.status_code in [requests.codes.ok, requests.codes.created, requests.codes.accepted]:
+                logger.error("Server returned status %s" % (str(r.status_code)), section)
+                return [1, "%s: Failed to post-process - Server returned status %s" % (section, str(r.status_code)) ]
+            elif result['success']:
+                logger.postprocess("SUCCESS: Finished %s scan for folder %s" % (method, dirName), section)
+                if method == "manage":
+                    return [0, "%s: Successfully post-processed %s" % (section, inputName) ]
+            else:
+                logger.error("FAILED: %s scan was unable to finish for folder %s. exiting!" % (method, dirName),
+                             section)
+                return [1, "%s: Failed to post-process - Server did not return success" % (section) ]
+
+        else:
+            logger.postprocess("FAILED DOWNLOAD DETECTED FOR %s" % (inputName), section)
+            if failureLink:
+                reportNzb(failureLink, clientAgent)
+
+            if delete_failed and os.path.isdir(dirName) and not os.path.dirname(dirName) == dirName:
+                logger.postprocess("Deleting failed files and folder %s" % dirName, section)
+                rmDir(dirName)
+
+            if not release_id and not media_id:
+                logger.error("Could not find a downloaded movie in the database matching %s, exiting!" % inputName,
+                             section)
+                return [1, "%s: Failed to post-process - Failed download not found in %s" % (section, section) ]
+
+            if release_id:
+                logger.postprocess("Setting failed release %s to ignored ..." % (inputName), section)
+
+                url = baseURL + "/release.ignore"
+                params = {'id': release_id}
+
+                logger.debug("Opening URL: %s with PARAMS: %s" % (url, params), section)
+
+                try:
+                    r = requests.get(url, params=params, verify=False, timeout=(30, 120))
+                except requests.ConnectionError:
+                    logger.error("Unable to open URL %s" % (url), section)
+                    return [1, "%s: Failed to post-process - Unable to connect to %s" % (section, section) ]
+
+                result = r.json()
+                if not r.status_code in [requests.codes.ok, requests.codes.created, requests.codes.accepted]:
+                    logger.error("Server returned status %s" % (str(r.status_code)), section)
+                    return [1, "%s: Failed to post-process - Server returned status %s" % (section, str(r.status_code)) ]
+                elif result['success']:
+                    logger.postprocess("SUCCESS: %s has been set to ignored ..." % (inputName), section)
+                else:
+                    logger.warning("FAILED: Unable to set %s to ignored!" % (inputName), section)
+                    return [1, "%s: Failed to post-process - Unable to set %s to ignored" % (section, inputName) ]
+
+            logger.postprocess("Trying to snatch the next highest ranked release.", section)
+
+            url = "%s/movie.searcher.try_next" % (baseURL)
+            logger.debug("Opening URL: %s" % (url), section)
+
+            try:
+                r = requests.get(url, params={'media_id': media_id}, verify=False, timeout=(30, 600))
+            except requests.ConnectionError:
+                logger.error("Unable to open URL %s" % (url), section)
+                return [1, "%s: Failed to post-process - Unable to connect to %s" % (section, section) ]
+
+            result = r.json()
+            if not r.status_code in [requests.codes.ok, requests.codes.created, requests.codes.accepted]:
+                logger.error("Server returned status %s" % (str(r.status_code)), section)
+                return [1, "%s: Failed to post-process - Server returned status %s" % (section, str(r.status_code)) ]
+            elif result['success']:
+                logger.postprocess("SUCCESS: Snatched the next highest release ...", section)
+                return [0, "%s: Successfully snatched next highest release" % (section) ]
+            else:
+                logger.postprocess("SUCCESS: Unable to find a new release to snatch now. CP will keep searching!", section)
+                return [0, "%s: No new release found now. %s will keep searching" % (section, section) ]
+
+        # Added a releease that was not in the wanted list so confirm rename successful by finding this movie media.list.
+        if not release:
+            download_id = None  # we don't want to filter new releases based on this.
+
+        # we will now check to see if CPS has finished renaming before returning to TorrentToMedia and unpausing.
+        timeout = time.time() + 60 * wait_for
+        while (time.time() < timeout):  # only wait 2 (default) minutes, then return.
+            logger.postprocess("Checking for status change, please stand by ...", section)
+            release = self.get_release(baseURL, imdbid, download_id, release_id)
+            if release:
+                try:
+                    if release_id is None and release_status_old is None:  # we didn't have a release before, but now we do.
+                        logger.postprocess("SUCCESS: Movie %s has now been added to CouchPotato" % (imdbid), section)
+                        return [0, "%s: Successfully post-processed %s" % (section, inputName) ]
+
+                    release_status_new = release[release_id]['status']
+                    if release_status_new != release_status_old:
+                        logger.postprocess("SUCCESS: Release %s has now been marked with a status of [%s]" % (
+                            inputName, str(release_status_new).upper()), section)
+                        return [0, "%s: Successfully post-processed %s" % (section, inputName) ]
+                except:
+                    pass
+            if not os.path.isdir(dirName):
+                logger.postprocess("SUCCESS: Input Directory [%s] has been processed and removed" % (
+                    dirName), section)
+                return [0, "%s: Successfully post-processed %s" % (section, inputName) ]
+
+            elif not listMediaFiles(dirName, media=True, audio=False, meta=False, archives=True):
+                logger.postprocess("SUCCESS: Input Directory [%s] has no remaining media files. This has been fully processed." % (
+                    dirName), section)
+                return [0, "%s: Successfully post-processed %s" % (section, inputName) ]
+
+            # pause and let CouchPotatoServer catch its breath
+            time.sleep(10 * wait_for)
+
+        # The status hasn't changed. we have waited 2 minutes which is more than enough. uTorrent can resule seeding now.
+        logger.warning(
+            "%s does not appear to have changed status after %s minutes, Please check your logs." % (inputName, wait_for),
+            section)
+        return [1, "%s: Failed to post-process - No change in status" % (section) ]

core/autoProcess/autoProcessMusic.py

@@ -0,0 +1,143 @@
+import os
+import time
+import requests
+import core
+
+from core.nzbToMediaUtil import convert_to_ascii, remoteDir, listMediaFiles, server_responding
+from core.nzbToMediaSceneExceptions import process_all_exceptions
+from core import logger
+
+class autoProcessMusic:
+    def get_status(self, url, apikey, dirName):
+        logger.debug("Attempting to get current status for release:%s" % (os.path.basename(dirName)))
+
+        params = {}
+        params['apikey'] = apikey
+        params['cmd'] = "getHistory"
+
+        logger.debug("Opening URL: %s with PARAMS: %s" % (url, params))
+
+        try:
+            r = requests.get(url, params=params, verify=False, timeout=(30, 120))
+        except Exception, e:
+            logger.error("Unable to open URL")
+            return None
+
+        try:
+            result = r.json()
+            for album in result:
+                if os.path.basename(dirName) == album['FolderName']:
+                     return album["Status"].lower()
+        except:
+            return None
+
+    def process(self, section, dirName, inputName=None, status=0, clientAgent="manual", inputCategory=None):
+        status = int(status)
+
+        host = core.CFG[section][inputCategory]["host"]
+        port = core.CFG[section][inputCategory]["port"]
+        apikey = core.CFG[section][inputCategory]["apikey"]
+        wait_for = int(core.CFG[section][inputCategory]["wait_for"])
+
+        try:
+            ssl = int(core.CFG[section][inputCategory]["ssl"])
+        except:
+            ssl = 0
+        try:
+            web_root = core.CFG[section][inputCategory]["web_root"]
+        except:
+            web_root = ""
+        try:
+            remote_path = int(core.CFG[section][inputCategory]["remote_path"])
+        except:
+            remote_path = 0
+        try:
+            extract = int(section[inputCategory]["extract"])
+        except:
+            extract = 0
+
+        if ssl:
+            protocol = "https://"
+        else:
+            protocol = "http://"
+
+
+        url = "%s%s:%s%s/api" % (protocol,host,port,web_root)
+        if not server_responding(url):
+            logger.error("Server did not respond. Exiting", section)
+            return [1, "%s: Failed to post-process - %s did not respond." % (section, section) ]
+
+        if not os.path.isdir(dirName) and os.path.isfile(dirName): # If the input directory is a file, assume single file download and split dir/name.
+            dirName = os.path.split(os.path.normpath(dirName))[0]
+
+        SpecificPath = os.path.join(dirName, str(inputName))
+        cleanName = os.path.splitext(SpecificPath)
+        if cleanName[1] == ".nzb":
+            SpecificPath = cleanName[0]
+        if os.path.isdir(SpecificPath):
+            dirName = SpecificPath
+
+        process_all_exceptions(inputName, dirName)
+        inputName, dirName = convert_to_ascii(inputName, dirName)
+
+        if not listMediaFiles(dirName, media=False, audio=True, meta=False, archives=False) and listMediaFiles(dirName, media=False, audio=False, meta=False, archives=True) and extract:
+            logger.debug('Checking for archives to extract in directory: %s' % (dirName))
+            core.extractFiles(dirName)
+            inputName, dirName = convert_to_ascii(inputName, dirName)
+
+        if listMediaFiles(dirName, media=False, audio=True, meta=False, archives=False) and status:
+            logger.info("Status shown as failed from Downloader, but %s valid video files found. Setting as successful." % (str(good_files)), section)
+            status = 0
+
+        if status == 0:
+
+            params = {}
+            params['apikey'] = apikey
+            params['cmd'] = "forceProcess"
+
+            params['dir'] = os.path.dirname(dirName)
+            if remote_path:
+                params['dir'] = remoteDir(os.path.dirname(dirName))
+
+            release_status = self.get_status(url, apikey, dirName)
+            if not release_status:
+                logger.error("Could not find a status for %s, is it in the wanted list ?" % (inputName),section)
+
+            logger.debug("Opening URL: %s with PARAMS: %s" % (url, params), section)
+
+            try:
+                r = requests.get(url, params=params, verify=False, timeout=(30, 300))
+            except requests.ConnectionError:
+                logger.error("Unable to open URL %s" % (url) ,section)
+                return [1, "%s: Failed to post-process - Unable to connect to %s" % (section, section) ]
+
+            logger.debug("Result: %s" % (r.text),section)
+
+            if not r.status_code in [requests.codes.ok, requests.codes.created, requests.codes.accepted]:
+                logger.error("Server returned status %s" % (str(r.status_code)), section)
+                return [1, "%s: Failed to post-process - Server returned status %s" % (section, str(r.status_code)) ]
+            elif r.text == "OK":
+                logger.postprocess("SUCCESS: Post-Processing started for %s in folder %s ..." % (inputName, dirName),section) 
+            else:
+                logger.error("FAILED: Post-Processing has NOT started for %s in folder %s. exiting!" % (inputName, dirName),section)
+                return [1, "%s: Failed to post-process - Returned log from %s was not as expected." % (section, section) ]
+
+        else:
+            logger.warning("FAILED DOWNLOAD DETECTED", section)
+            return [1, "%s: Failed to post-process. %s does not support failed downloads" % (section, section) ]
+
+        # we will now wait for this album to be processed before returning to TorrentToMedia and unpausing.
+        timeout = time.time() + 60 * wait_for
+        while (time.time() < timeout):
+            current_status = self.get_status(url, apikey, dirName)
+            if current_status is not None and current_status != release_status:  # Something has changed. CPS must have processed this movie.
+                logger.postprocess("SUCCESS: This release is now marked as status [%s]" % (current_status),section)
+                return [0, "%s: Successfully post-processed %s" % (section, inputName) ]
+            if not os.path.isdir(dirName):
+                logger.postprocess("SUCCESS: The input directory %s has been removed Processing must have finished." % (dirName),section)
+                return [0, "%s: Successfully post-processed %s" % (section, inputName) ]
+            time.sleep(10 * wait_for)
+
+        # The status hasn't changed. uTorrent can resume seeding now.
+        logger.warning("The music album does not appear to have changed status after %s minutes. Please check your Logs" % (wait_for),section)
+        return [1, "%s: Failed to post-process - No change in wanted status" % (section) ]

core/autoProcess/autoProcessTV.py

@@ -0,0 +1,339 @@
+import copy
+import os
+import time
+import errno
+import requests
+import json
+import core
+
+from core.nzbToMediaAutoFork import autoFork
+from core.nzbToMediaSceneExceptions import process_all_exceptions
+from core.nzbToMediaUtil import convert_to_ascii, flatten, rmDir, listMediaFiles, remoteDir, import_subs, server_responding, reportNzb
+from core import logger
+from core.transcoder import transcoder
+
+class autoProcessTV:
+    def command_complete(self, url, params, headers, section):
+        r = None
+        try:
+            r = requests.get(url, params=params, headers=headers, stream=True, verify=False, timeout=(30, 60))
+        except requests.ConnectionError:
+            logger.error("Unable to open URL: %s" % (url1), section)
+            return None
+        if not r.status_code in [requests.codes.ok, requests.codes.created, requests.codes.accepted]:
+            logger.error("Server returned status %s" % (str(r.status_code)), section)
+            return None
+        else:
+            try:
+                res = json.loads(r.content)
+                return res['state']
+            except:
+                logger.error("%s did not return expected json data." % section, section)
+                return None
+
+    def CDH(self, url2, headers):
+        r = None
+        try:
+            r = requests.get(url2, params={}, headers=headers, stream=True, verify=False, timeout=(30, 60))
+        except requests.ConnectionError:
+            logger.error("Unable to open URL: %s" % (url2), section)
+            return False
+        if not r.status_code in [requests.codes.ok, requests.codes.created, requests.codes.accepted]:
+            logger.error("Server returned status %s" % (str(r.status_code)), section)
+            return False
+        else:
+            try:
+                res = json.loads(r.content)
+                return res["enableCompletedDownloadHandling"]
+            except:
+                return False
+
+    def processEpisode(self, section, dirName, inputName=None, failed=False, clientAgent = "manual", download_id=None, inputCategory=None, failureLink=None):
+        host = core.CFG[section][inputCategory]["host"]
+        port = core.CFG[section][inputCategory]["port"]
+        try:
+            ssl = int(core.CFG[section][inputCategory]["ssl"])
+        except:
+            ssl = 0
+        if ssl:
+            protocol = "https://"
+        else:
+            protocol = "http://"
+        try:
+            web_root = core.CFG[section][inputCategory]["web_root"]
+        except:
+            web_root = ""
+        if not server_responding("%s%s:%s%s" % (protocol,host,port,web_root)):
+            logger.error("Server did not respond. Exiting", section)
+            return [1, "%s: Failed to post-process - %s did not respond." % (section, section) ]
+
+        # auto-detect correct fork
+        fork, fork_params = autoFork(section, inputCategory)
+
+        try:
+            username = core.CFG[section][inputCategory]["username"]
+            password = core.CFG[section][inputCategory]["password"]
+        except:
+            username = ""
+            password = ""
+        try:
+            apikey = core.CFG[section][inputCategory]["apikey"]
+        except:
+            apikey = ""
+        try:
+            delete_failed = int(core.CFG[section][inputCategory]["delete_failed"])
+        except:
+            delete_failed = 0
+        try:
+            nzbExtractionBy = core.CFG[section][inputCategory]["nzbExtractionBy"]
+        except:
+            nzbExtractionBy = "Downloader"
+        try:
+            process_method = core.CFG[section][inputCategory]["process_method"]
+        except:
+            process_method = None
+        try:
+            remote_path = int(core.CFG[section][inputCategory]["remote_path"])
+        except:
+            remote_path = 0
+        try:
+            wait_for = int(core.CFG[section][inputCategory]["wait_for"])
+        except:
+            wait_for = 2
+        try:
+            force = int(core.CFG[section][inputCategory]["force"])
+        except:
+            force = 0
+        try:
+            extract = int(section[inputCategory]["extract"])
+        except:
+            extract = 0
+
+        if not os.path.isdir(dirName) and os.path.isfile(dirName): # If the input directory is a file, assume single file download and split dir/name.
+            dirName = os.path.split(os.path.normpath(dirName))[0]
+
+        SpecificPath = os.path.join(dirName, str(inputName))
+        cleanName = os.path.splitext(SpecificPath)
+        if cleanName[1] == ".nzb":
+            SpecificPath = cleanName[0]
+        if os.path.isdir(SpecificPath):
+            dirName = SpecificPath
+
+        # Attempt to create the directory if it doesn't exist and ignore any
+        # error stating that it already exists. This fixes a bug where SickRage
+        # won't process the directory because it doesn't exist.
+        try:
+            os.makedirs(dirName)  # Attempt to create the directory
+        except OSError, e:
+            # Re-raise the error if it wasn't about the directory not existing
+            if e.errno != errno.EEXIST:
+                raise
+
+        # Check video files for corruption
+        status = int(failed)
+        good_files = 0
+        num_files = 0
+        for video in listMediaFiles(dirName, media=True, audio=False, meta=False, archives=False):
+            num_files += 1
+            if transcoder.isVideoGood(video, status):
+                good_files += 1
+                import_subs(video)
+        if num_files > 0: 
+            if good_files == num_files and not status == 0:
+                logger.info('Found Valid Videos. Setting status Success')
+                status = 0
+                failed = 0
+            if good_files < num_files and status == 0:
+                logger.info('Found corrupt videos. Setting status Failed')
+                status = 1
+                failed = 1
+                if os.environ.has_key('NZBOP_VERSION') and os.environ['NZBOP_VERSION'][0:5] >= '14.0':
+                    print('[NZB] MARK=BAD')
+                if failureLink:
+                    failureLink = failureLink + '&corrupt=true'
+        elif clientAgent == "manual" and not listMediaFiles(dirName, media=True, audio=False, meta=False, archives=True):
+                logger.warning("No media files found in directory %s to manually process." % (dirName), section)
+                return [0, ""]   # Success (as far as this script is concerned)
+
+        if fork not in core.SICKBEARD_TORRENT or (clientAgent in ['nzbget','sabnzbd'] and nzbExtractionBy != "Destination"):
+            if inputName:
+                process_all_exceptions(inputName, dirName)
+                inputName, dirName = convert_to_ascii(inputName, dirName)
+
+            # Now check if tv files exist in destination. 
+            if listMediaFiles(dirName, media=True, audio=False, meta=False, archives=False):  # Check that a video exists. if not, assume failed.
+                flatten(dirName) # to make sure SickBeard can find the video (not in sub-folder)
+            elif listMediaFiles(dirName, media=False, audio=False, meta=False, archives=True) and extract:
+                logger.debug('Checking for archives to extract in directory: %s' % (dirName))
+                core.extractFiles(dirName)
+                inputName, dirName = convert_to_ascii(inputName, dirName)
+                good_files = 0
+                num_files = 0
+                for video in listMediaFiles(dirName, media=True, audio=False, meta=False, archives=False):
+                    num_files += 1
+                    if transcoder.isVideoGood(video, status):
+                        good_files += 1
+                        import_subs(video)
+                if num_files > 0 and good_files == num_files:
+                    logger.info('Found Valid Videos. Setting status Success')
+                    status = 0
+                    failed = 0
+
+            if listMediaFiles(dirName, media=True, audio=False, meta=False, archives=False):  # Check that a video exists. if not, assume failed.
+                flatten(dirName) 
+            elif clientAgent == "manual":
+                logger.warning("No media files found in directory %s to manually process." % (dirName), section)
+                return [0, ""]   # Success (as far as this script is concerned)
+            else:
+                logger.warning("No media files found in directory %s. Processing this as a failed download" % (dirName), section)
+                status = 1
+                failed = 1
+
+        if status == 0 and core.TRANSCODE == 1: # only transcode successful downlaods
+            result, newDirName = transcoder.Transcode_directory(dirName)
+            if result == 0:
+                logger.debug("SUCCESS: Transcoding succeeded for files in %s" % (dirName), section)
+                dirName = newDirName
+            else:
+                logger.error("FAILED: Transcoding failed for files in %s" % (dirName), section)
+                return [1, "%s: Failed to post-process - Transcoding failed" % (section) ]
+
+        # configure SB params to pass
+        fork_params['quiet'] = 1
+        if inputName is not None:
+            fork_params['nzbName'] = inputName
+
+        for param in copy.copy(fork_params):
+            if param == "failed":
+                fork_params[param] = failed
+
+            if param in ["dirName", "dir"]:
+                fork_params[param] = dirName
+                if remote_path:
+                    fork_params[param] = remoteDir(dirName)
+
+            if param == "process_method":
+                if process_method:
+                    fork_params[param] = process_method
+                else:
+                    del fork_params[param]
+
+            if param == "force":
+                if force:
+                    fork_params[param] = force
+                else:
+                    del fork_params[param]
+
+        # delete any unused params so we don't pass them to SB by mistake
+        [fork_params.pop(k) for k,v in fork_params.items() if v is None]
+
+        if status == 0:
+            logger.postprocess("SUCCESS: The download succeeded, sending a post-process request", section)
+        else:
+            if failureLink:
+                reportNzb(failureLink, clientAgent)
+            if fork in core.SICKBEARD_FAILED:
+                logger.postprocess("FAILED: The download failed. Sending 'failed' process request to %s branch" % (fork), section)
+            elif section == "NzbDrone":
+                logger.postprocess("FAILED: The download failed. Sending failed download to %s for CDH processing" % (fork), section)
+                return [1, "%s: Downlaod Failed. Sending back to %s" % (section, section) ] # Return as failed to flag this in the downloader.
+            else:
+                logger.postprocess("FAILED: The download failed. %s branch does not handle failed downloads. Nothing to process" % (fork), section)
+                if delete_failed and os.path.isdir(dirName) and not os.path.dirname(dirName) == dirName:
+                    logger.postprocess("Deleting failed files and folder %s" % (dirName), section)
+                    rmDir(dirName)
+                return [1, "%s: Failed to post-process. %s does not support failed downloads" % (section, section) ] # Return as failed to flag this in the downloader.
+
+        url = None
+        if section == "SickBeard":
+            url = "%s%s:%s%s/home/postprocess/processEpisode" % (protocol,host,port,web_root)
+        elif section == "NzbDrone":
+            url = "%s%s:%s%s/api/command" % (protocol, host, port, web_root)
+            url2 = "%s%s:%s%s/api/config/downloadClient" % (protocol, host, port, web_root)
+            headers = {"X-Api-Key": apikey}
+            params = {'sortKey': 'series.title', 'page': 1, 'pageSize': 1, 'sortDir': 'asc'}
+            if remote_path:
+                logger.debug("remote_path: %s" % (remoteDir(dirName)),section)
+                data = {"name": "DownloadedEpisodesScan", "path": remoteDir(dirName), "downloadClientId": download_id}
+            else:
+                logger.debug("path: %s" % (dirName),section)
+                data = {"name": "DownloadedEpisodesScan", "path": dirName, "downloadClientId": download_id}
+            if not download_id:
+                data.pop("downloadClientId")
+            data = json.dumps(data)
+                
+        try:
+            if section == "SickBeard":
+                logger.debug("Opening URL: %s with params: %s" % (url, str(fork_params)), section)
+                r = None
+                s = requests.Session()
+                login = "%s%s:%s%s/login" % (protocol,host,port,web_root)
+                login_params = {'username': username, 'password': password}
+                s.post(login, data=login_params, stream=True, verify=False, timeout=(30, 60))
+                r = s.get(url, auth=(username, password), params=fork_params, stream=True, verify=False, timeout=(30, 1800))
+            elif section == "NzbDrone":
+                logger.debug("Opening URL: %s with data: %s" % (url, str(data)), section)
+                r = None
+                r = requests.post(url, data=data, headers=headers, stream=True, verify=False, timeout=(30, 1800))
+        except requests.ConnectionError:
+            logger.error("Unable to open URL: %s" % (url), section)
+            return [1, "%s: Failed to post-process - Unable to connect to %s" % (section, section) ]
+
+        if not r.status_code in [requests.codes.ok, requests.codes.created, requests.codes.accepted]:
+            logger.error("Server returned status %s" % (str(r.status_code)), section)
+            return [1, "%s: Failed to post-process - Server returned status %s" % (section, str(r.status_code)) ]
+
+        Success = False
+        Started = False
+        if section == "SickBeard":
+            for line in r.iter_lines():
+                if line: 
+                    logger.postprocess("%s" % (line), section)
+                    if "Processing succeeded" in line or "Successfully processed" in line:
+                        Success = True
+        elif section == "NzbDrone":
+            try:
+                res = json.loads(r.content)
+                scan_id = int(res['id'])
+                logger.debug("Scan started with id: %s" % (str(scan_id)), section)
+                Started = True
+            except Exception as e:
+                logger.warning("No scan id was returned due to: %s" % (e), section)
+                scan_id = None
+                Started = False
+
+        if status != 0 and delete_failed and not os.path.dirname(dirName) == dirName:
+            logger.postprocess("Deleting failed files and folder %s" % (dirName),section)
+            rmDir(dirName)
+
+        if Success:
+            return [0, "%s: Successfully post-processed %s" % (section, inputName) ]
+        elif section == "NzbDrone" and Started:
+            n = 0
+            params = {}
+            url = url + "/" + str(scan_id)
+            while n < 6:  # set up wait_for minutes to see if command completes..
+                time.sleep(10 * wait_for)
+                command_status = self.command_complete(url, params, headers, section)
+                if command_status and command_status in ['completed', 'failed']:    
+                     break
+                n += 1
+            if command_status:
+                logger.debug("The Scan command return status: %s" % (command_status), section)
+            if not os.path.exists(dirName):
+                logger.debug("The directory %s has been removed. Renaming was successful." % (dirName), section)
+                return [0, "%s: Successfully post-processed %s" % (section, inputName) ]
+            elif command_status and command_status in ['completed']:
+                logger.debug("The Scan command has completed successfully. Renaming was successful.", section)
+                return [0, "%s: Successfully post-processed %s" % (section, inputName) ]
+            elif command_status and command_status in ['failed']:
+                logger.debug("The Scan command has failed. Renaming was not successful.", section)
+                #return [1, "%s: Failed to post-process %s" % (section, inputName) ]
+            if self.CDH(url2, headers):
+                logger.debug("The Scan command did not return status completed, but complete Download Handling is enabled. Passing back to %s." % (section), section)
+                return [status, "%s: Complete DownLoad Handling is enabled. Passing back to %s" % (section, section) ] 
+            else:
+                logger.warning("The Scan command did not return a valid status. Renaming was not successful.", section)
+                return [1, "%s: Failed to post-process %s" % (section, inputName) ]
+        else:
+            return [1, "%s: Failed to post-process - Returned log from %s was not as expected." % (section, section) ]  # We did not receive Success confirmation.