vofik/Plex Movie Scanner.py

## Plex Movie Scanner.py
#
# Copyright (c) 2010 Plex Development Team. All rights reserved.
#
import re, os, os.path
import Media, VideoFiles, Stack, Utils

SeriesScanner = __import__('Plex Series Scanner')

nice_match = '(.+) [\(\[]([1-2][0-9]{3})[\)\]]'
standalone_tv_regexs = [ '(.*?)( \(([0-9]+)\))? - ([0-9])+x([0-9]+)(-[0-9]+[Xx]([0-9]+))? - (.*)' ]

# Scans through files, and add to the media list.
def Scan(path, files, mediaList, subdirs, language=None, **kwargs):

  # Scan for video files.
  VideoFiles.Scan(path, files, mediaList, subdirs)

  # Check for DVD rips.
  paths = Utils.SplitPath(path)
  video_ts = ContainsFile(files, 'video_ts.ifo')
  if video_ts is None:
    video_ts = ContainsFile(files, 'video_ts.bup')

  if len(paths) >= 1 and len(paths[0]) > 0 and video_ts is not None:
    print "Found a DVD"
    name = year = None

    # Now find the name.
    if paths[-1].lower() == 'video_ts' and len(paths) >= 2:
      # Easiest case.
      (name, year) = VideoFiles.CleanName(paths[-2])
    else:
      # Work up until we find a viable candidate.
      backwardsPaths = paths
      backwardsPaths.reverse()
      for p in backwardsPaths:
        if re.match(nice_match, p):
          (name, year) = VideoFiles.CleanName(p)
          break

      if name is None:
        # Use the topmost path.
        (name, year) = VideoFiles.CleanName(paths[0])

    movie = Media.Movie(name, year)

    # Add the video_ts file first.
    movie.parts.append(video_ts)

    biggestFile = None
    biggestSize = 0

    for i in files:
      if os.path.splitext(i)[1].lower() == '.vob' and os.path.getsize(i) > biggestSize:
        biggestSize = os.path.getsize(i)
        biggestFile = i

    # Add the biggest part so that we can get thumbnail/art/analysis from it.
    if biggestFile is not None:
      movie.parts.append(biggestFile)

    if len(movie.parts) > 0:
      movie.guid = checkNfoFile(movie.parts[0], 1)
      mediaList.append(movie)

  # Check for Bluray rips.
  elif len(paths) >= 3 and paths[-1].lower() == 'stream' and paths[-2].lower() == 'bdmv':
    (name, year) = VideoFiles.CleanName(paths[-3])
    movie = Media.Movie(name, year)
    for i in files:
      movie.parts.append(i)
    mediaList.append(movie)

  else:

    # Make movies!
    for i in files:
      file = os.path.basename(i)
      (name, year) = VideoFiles.CleanName(os.path.splitext(file)[0])

      # If it matches a TV show, don't scan it as a movie.
      tv = False
      for rx in SeriesScanner.episode_regexps[0:-1]:
        if re.match(rx, name):
          print "The file", file, "looked like a TV show so we're skipping it (", rx, ")"
          tv = True

      if tv == False:
        # OK, it's a movie
        movie = Media.Movie(name, year)
        movie.source = VideoFiles.RetrieveSource(file)
        movie.parts.append(i)
        mediaList.append(movie)

    # Stack the results.
    Stack.Scan(path, files, mediaList, subdirs)

    # Clean the folder name and try a match on the folder.
    if len(path) > 0:
      folderName = os.path.basename(path).replace(' ', ' ').replace(' ','.')
      (cleanName, year) = VideoFiles.CleanName(folderName)
      if len(mediaList) == 1 and re.match(nice_match, cleanName):
        res = re.findall(nice_match, cleanName)
        mediaList[0].name = res[0][0]
        mediaList[0].year = res[0][1]
      elif len(mediaList) == 1 and (len(cleanName) > 1 or year is not None):
        mediaList[0].name = cleanName
        mediaList[0].year = year

    # Check for a folder with multiple 'CD' subfolders and massage
    foundCDsubdirs = {}
    for s in subdirs:
      m = re.search(r'(?:cd|dvd|part|pt|disk|disc)[ \\.-]*([0-9]+)', os.path.basename(s).lower())
      if m:
        foundSubSubDirs = False
        for subsubdir in os.listdir(s):
          if os.path.isdir(os.path.join(s, subsubdir)):
            subm = re.search(r'(?:cd|dvd|part|pt|disk|disc)[ \\.-]*([0-9]+)', subsubdir.lower())
            if subm:
              foundSubSubDirs = True
              foundCDsubdirs[m.groups(1)[0] + '-' + subm.groups(1)[0]] = os.path.join(s, subsubdir)

        if foundSubSubDirs == False:
          foundCDsubdirs['0-' + m.groups(1)[0]] = s

    # More than one cd subdir, let's stack and whack subdirs.
    if len(foundCDsubdirs) > 1:
      name, year = VideoFiles.CleanName(os.path.basename(path))
      movie = Media.Movie(name, year)
      movie.guid = checkNfoFile(os.path.dirname(foundCDsubdirs.values()[0]), 1)

      keys = foundCDsubdirs.keys()
      keys.sort()
      for key in keys:
        d = foundCDsubdirs[key]
        subFiles = []
        for f in os.listdir(d):
          subFiles.append(os.path.join(d,f))
        VideoFiles.Scan(d, subFiles, mediaList, [])

        if foundSubSubDirs:
          if os.path.dirname(d) in subdirs:
            subdirs.remove(os.path.dirname(d))
        else:
          subdirs.remove(d)

        movie.parts += subFiles

      if len(movie.parts) > 0:
        mediaList.append(movie)

    # See if we can find a GUID.
    for mediaItem in mediaList:
      if mediaItem.guid is None:
        mediaItem.guid = checkNfoFile(mediaItem.parts[0], len(mediaList))

    if len(mediaList) == 1:
      if mediaList[0].source is None:
        mediaList[0].source = VideoFiles.RetrieveSource(path)

  # If the subdirectories indicate that we're inside a DVD, when whack things other than audio and video.
  whack = []
  if 'video_ts' in [Utils.SplitPath(s)[-1].lower() for s in subdirs]:
    for dir in subdirs:
      d = os.path.basename(dir).lower()
      if d not in ['video_ts', 'audio_ts']:
        whack.append(dir)

  # Finally, if any of the subdirectories match a TV show, don't enter!
  for dir in subdirs:
    for rx in standalone_tv_regexs:
      res = re.findall(rx, dir)
      if len(res):
        whack.append(dir)

  for w in whack:
    subdirs.remove(w)

def ContainsFile(files, file):
  for i in files:
    if os.path.basename(i).lower() == file.lower():
      return i
  return None

def checkNfoFile(file, fileCount):
  try:
    path = None

    # Depending on how many media files we have, check differently.
    if fileCount == 1:
      # Look for any NFO file.
      for f in os.listdir(os.path.dirname(file)):
        if f[-4:].lower() == '.nfo':
          path = os.path.join(os.path.dirname(file), f)
          break
    else:
      # Look for a sidecar NFO file.
      path = os.path.splitext(file)[0] + '.nfo'

    if path is not None and os.path.exists(path):
      nfoText = open(path).read()
      m = re.search('(tt[0-9]+)', nfoText)
      if m:
        return m.groups(1)[0]
  except:
    print "Warning, couldn't read NFO file."

  return None

## Stack.py
import Media, VideoFiles
import os.path, difflib
import re

def compareFilenames(elem):
  return elem.parts[0].lower()

def Scan(dir, files, mediaList, subdirs):

  # Go through the files and see if any of them need to be stacked.
  stack_dict = {}
  stackDiffs = r'[\da-n]' # These are the characters we are looking for being different across stackable filenames
  stackSuffixes = r'(?:cd|dvd|part|pt|disk|disc|scene)\.?(?:\d+)?$'
  scenePrefixes = r'(?:^scene.\d+|scene.\d+$)'

  # Sort the mediaList by filename, so we can do our compares properly
  mediaList[:] = sorted(mediaList, key=compareFilenames)

  # check for monotonically increasing numeric or alphabetic filenames
  count = 0
  monotonicSeries = False
  for mediaItem in mediaList[:-1]:
    # if it didn't start as a monotonic series, it's not going to become one
    if count > 0 and monotonicSeries == False:
      break

    # if items were already stacked by other method, skip this attempt
    if hasattr(mediaItem, 'stacked') and mediaItem.stacked == True:
      continue

    m1 = mediaList[count]
    m2 = mediaList[count + 1]
    f1 = os.path.basename(os.path.splitext(m1.parts[0])[0]).strip().lower()
    f2 = os.path.basename(os.path.splitext(m2.parts[0])[0]).strip().lower()

    initialA = re.search(r'(^\d+)', f1)
    initialB = re.search(r'(^\d+)', f2)
    terminalA = re.search(r'(\d+)$', f1)
    terminalB = re.search(r'(\d+)$', f2)

    # if the filenames both start, or both end with a digit,
    # and the digit of the second filename is 1 larger than the one of the first filename, it's a series
    if(((initialA and initialB) and (int(initialA.group(0)) == int(initialB.group(0)) - 1)) or
      ((terminalA and terminalB) and (int(terminalA.group(0)) == int(terminalB.group(0)) - 1))):
      monotonicSeries = True

    # if the filenames both start, or both end with a letter,
    # and the letter seems to the correct one for this iteration if we started from "a",
    # and the letter of the second filename is 1 larger than the one of the first filename, it's a series
    if(monotonicSeries == False):
      initialA = re.search(r'(^[a-y])', f1)
      initialB = re.search(r'(^[a-y])', f2)
      terminalA = re.search(r'([a-y])$', f1)
      terminalB = re.search(r'([a-y])$', f2)
      if(((initialA and initialB) and (ord(initialA.group(0)) == ord('a') + count and ord(initialA.group(0)) == ord(initialB.group(0)) - 1)) or
        ((terminalA and terminalB) and (ord(terminalA.group(0)) == ord('a') + count and ord(terminalA.group(0)) == ord(terminalB.group(0)) - 1))):
        monotonicSeries = True

    if monotonicSeries:

      m1.name = dir
      root = '_monotonic'

      m1.stacked = True
      if stack_dict.has_key(root):
        stack_dict[root].append(m2)
        # only mark the second item as stacked on last iteration, otherwise it'll break out of the loop in the start
        if count == len(mediaList) - 1:
          m2.stacked = True
      else:
        stack_dict[root] = [m1]
        stack_dict[root].append(m2)

    count += 1

  # group scene-based movie splits into a stack
  for mediaItem in mediaList:
    # if items were already stacked by other method, skip this attempt
    if hasattr(mediaItem, 'stacked') and mediaItem.stacked == True:
      continue

    f1 = os.path.basename(os.path.splitext(mediaItem.parts[0])[0]).lower()
    if re.match(scenePrefixes, f1):
      (name, year) = VideoFiles.CleanName(re.sub(scenePrefixes, '', f1))
      root = '_scene'
      mediaItem.name = name

      if stack_dict.has_key(root):
        stack_dict[root].append(mediaItem)
        mediaItem.stacked = True
      else:
        stack_dict[root] = [mediaItem]
        mediaItem.stacked = True

  # Search for prefix-based part names.
  count = 0
  for mediaItem in mediaList[:-1]:
    m1 = mediaList[count]
    m2 = mediaList[count + 1]

    # if items were already stacked by other method, skip this attempt
    if hasattr(m1, 'stacked') and m1.stacked == True:
      continue

    f1 = os.path.basename(m1.parts[0])
    f2 = os.path.basename(m2.parts[0])

    opcodes = difflib.SequenceMatcher(None, f1, f2).get_opcodes()

    if len(opcodes) == 3: # We only have one transform
      (tag, i1, i2, j1, j2) = opcodes[1]
      if tag == 'replace': # The transform is a replace
        if (i2-i1 <= 2) and (j2-j1 <= 2): # The transform is only one character
          if re.search(stackDiffs, f1[i1:i2].lower()): # That one character is 1-4 or a-n
            root = f1[:i1].strip(' _-')
            xOfy = False

            if f1[i1+1:].lower().strip().startswith('of'): #check to see if this an x of y style stack, if so flag it
              xOfy = True
            #prefix = f1[:i1] + f1[i2:]
            #(root, ext) = os.path.splitext(prefix)

            # This is a special case for folders with multiple Volumes of a series (not a stacked movie) [e.g, Kill Bill Vol 1 / 2]
            if not root.lower().strip().endswith('vol') and not root.lower().strip().endswith('volume'):

              # Strip any suffixes like CD, DVD.
              foundSuffix = False
              suffixMatch = re.search(stackSuffixes, root.lower().strip())

              if suffixMatch:
                root = root[0:-len(suffixMatch.group(0))].strip(' _-')
                foundSuffix = True

              if foundSuffix or xOfy:
                # Replace the name, which probably had the suffix.
                (name, year) = VideoFiles.CleanName(root)
                # pdb.set_trace()

                mediaItem.name = name
                m1.stacked = True
                if stack_dict.has_key(root):
                  stack_dict[root].append(m2)
                  # only mark the second item as stacked on last iteration, otherwise it'll break out of the loop in the start
                  if count == len(mediaList) - 1:
                    m2.stacked = True
                else:
                  stack_dict[root] = [m1]
                  stack_dict[root].append(m2)
    count += 1

  # combine stacks if possible
  count = 0
  stacks = stack_dict.keys()
  for stack in stacks[:-1]:
    s1 = stacks[count]
    s2 = stacks[count + 1]
    opcodes = difflib.SequenceMatcher(None, s1, s2).get_opcodes()

    if len(opcodes) == 2: # We only have one transform
      (tag, i1, i2, j1, j2) = opcodes[1]
      if tag == 'replace': # The transform is a replace
        if (i2-i1 == 1) and (j2-j1 == 1): # The transform is only one character
          if re.search(stackDiffs, s1): # That one character is 1-4 or a-n
            root = s1.lower().strip()
            suffixMatch = re.search(stackSuffixes, root)
            if suffixMatch:
              root = root[0:-len(suffixMatch.group(0))].strip(' -')

              (name, year) = VideoFiles.CleanName(root)

              # merge existing two stacks into new root
              for oldstack in [s1, s2]:
                for media in stack_dict[oldstack]:
                  media.name = name

                if stack_dict.has_key(root):
                  for media in stack_dict[oldstack]:
                    stack_dict[root].append(media)
                else:
                  stack_dict[root] = stack_dict[oldstack]
                del stack_dict[oldstack]

    count += 1

  # Now combine stacked parts
  for stack in stack_dict.keys():
    for media in stack_dict[stack][1:]:
      stack_dict[stack][0].parts.append(media.parts[0])
      mediaList.remove(media)
	#
	# Copyright (c) 2010 Plex Development Team. All rights reserved.
	#
	import re, os, os.path
	import Media, VideoFiles, Stack, Utils

	SeriesScanner = __import__('Plex Series Scanner')

	nice_match = '(.+) [\(\[]([1-2][0-9]{3})[\)\]]'
	standalone_tv_regexs = [ '(.?)( \(([0-9]+)\))? - ([0-9])+x([0-9]+)(-[0-9]+[Xx]([0-9]+))? - (.)' ]

	# Scans through files, and add to the media list.
	def Scan(path, files, mediaList, subdirs, language=None, **kwargs):

	# Scan for video files.
	VideoFiles.Scan(path, files, mediaList, subdirs)

	# Check for DVD rips.
	paths = Utils.SplitPath(path)
	video_ts = ContainsFile(files, 'video_ts.ifo')
	if video_ts is None:
	video_ts = ContainsFile(files, 'video_ts.bup')

	if len(paths) >= 1 and len(paths[0]) > 0 and video_ts is not None:
	print "Found a DVD"
	name = year = None

	# Now find the name.
	if paths[-1].lower() == 'video_ts' and len(paths) >= 2:
	# Easiest case.
	(name, year) = VideoFiles.CleanName(paths[-2])
	else:
	# Work up until we find a viable candidate.
	backwardsPaths = paths
	backwardsPaths.reverse()
	for p in backwardsPaths:
	if re.match(nice_match, p):
	(name, year) = VideoFiles.CleanName(p)
	break

	if name is None:
	# Use the topmost path.
	(name, year) = VideoFiles.CleanName(paths[0])

	movie = Media.Movie(name, year)

	# Add the video_ts file first.
	movie.parts.append(video_ts)

	biggestFile = None
	biggestSize = 0

	for i in files:
	if os.path.splitext(i)[1].lower() == '.vob' and os.path.getsize(i) > biggestSize:
	biggestSize = os.path.getsize(i)
	biggestFile = i

	# Add the biggest part so that we can get thumbnail/art/analysis from it.
	if biggestFile is not None:
	movie.parts.append(biggestFile)

	if len(movie.parts) > 0:
	movie.guid = checkNfoFile(movie.parts[0], 1)
	mediaList.append(movie)

	# Check for Bluray rips.
	elif len(paths) >= 3 and paths[-1].lower() == 'stream' and paths[-2].lower() == 'bdmv':
	(name, year) = VideoFiles.CleanName(paths[-3])
	movie = Media.Movie(name, year)
	for i in files:
	movie.parts.append(i)
	mediaList.append(movie)

	else:

	# Make movies!
	for i in files:
	file = os.path.basename(i)
	(name, year) = VideoFiles.CleanName(os.path.splitext(file)[0])

	# If it matches a TV show, don't scan it as a movie.
	tv = False
	for rx in SeriesScanner.episode_regexps[0:-1]:
	if re.match(rx, name):
	print "The file", file, "looked like a TV show so we're skipping it (", rx, ")"
	tv = True

	if tv == False:
	# OK, it's a movie
	movie = Media.Movie(name, year)
	movie.source = VideoFiles.RetrieveSource(file)
	movie.parts.append(i)
	mediaList.append(movie)

	# Stack the results.
	Stack.Scan(path, files, mediaList, subdirs)

	# Clean the folder name and try a match on the folder.
	if len(path) > 0:
	folderName = os.path.basename(path).replace(' ', ' ').replace(' ','.')
	(cleanName, year) = VideoFiles.CleanName(folderName)
	if len(mediaList) == 1 and re.match(nice_match, cleanName):
	res = re.findall(nice_match, cleanName)
	mediaList[0].name = res[0][0]
	mediaList[0].year = res[0][1]
	elif len(mediaList) == 1 and (len(cleanName) > 1 or year is not None):
	mediaList[0].name = cleanName
	mediaList[0].year = year

	# Check for a folder with multiple 'CD' subfolders and massage
	foundCDsubdirs = {}
	for s in subdirs:
	m = re.search(r'(?:cd\|dvd\|part\|pt\|disk\|disc)[ \\.-]*([0-9]+)', os.path.basename(s).lower())
	if m:
	foundSubSubDirs = False
	for subsubdir in os.listdir(s):
	if os.path.isdir(os.path.join(s, subsubdir)):
	subm = re.search(r'(?:cd\|dvd\|part\|pt\|disk\|disc)[ \\.-]*([0-9]+)', subsubdir.lower())
	if subm:
	foundSubSubDirs = True
	foundCDsubdirs[m.groups(1)[0] + '-' + subm.groups(1)[0]] = os.path.join(s, subsubdir)

	if foundSubSubDirs == False:
	foundCDsubdirs['0-' + m.groups(1)[0]] = s

	# More than one cd subdir, let's stack and whack subdirs.
	if len(foundCDsubdirs) > 1:
	name, year = VideoFiles.CleanName(os.path.basename(path))
	movie = Media.Movie(name, year)
	movie.guid = checkNfoFile(os.path.dirname(foundCDsubdirs.values()[0]), 1)

	keys = foundCDsubdirs.keys()
	keys.sort()
	for key in keys:
	d = foundCDsubdirs[key]
	subFiles = []
	for f in os.listdir(d):
	subFiles.append(os.path.join(d,f))
	VideoFiles.Scan(d, subFiles, mediaList, [])

	if foundSubSubDirs:
	if os.path.dirname(d) in subdirs:
	subdirs.remove(os.path.dirname(d))
	else:
	subdirs.remove(d)

	movie.parts += subFiles

	if len(movie.parts) > 0:
	mediaList.append(movie)

	# See if we can find a GUID.
	for mediaItem in mediaList:
	if mediaItem.guid is None:
	mediaItem.guid = checkNfoFile(mediaItem.parts[0], len(mediaList))

	if len(mediaList) == 1:
	if mediaList[0].source is None:
	mediaList[0].source = VideoFiles.RetrieveSource(path)

	# If the subdirectories indicate that we're inside a DVD, when whack things other than audio and video.
	whack = []
	if 'video_ts' in [Utils.SplitPath(s)[-1].lower() for s in subdirs]:
	for dir in subdirs:
	d = os.path.basename(dir).lower()
	if d not in ['video_ts', 'audio_ts']:
	whack.append(dir)

	# Finally, if any of the subdirectories match a TV show, don't enter!
	for dir in subdirs:
	for rx in standalone_tv_regexs:
	res = re.findall(rx, dir)
	if len(res):
	whack.append(dir)

	for w in whack:
	subdirs.remove(w)

	def ContainsFile(files, file):
	for i in files:
	if os.path.basename(i).lower() == file.lower():
	return i
	return None

	def checkNfoFile(file, fileCount):
	try:
	path = None

	# Depending on how many media files we have, check differently.
	if fileCount == 1:
	# Look for any NFO file.
	for f in os.listdir(os.path.dirname(file)):
	if f[-4:].lower() == '.nfo':
	path = os.path.join(os.path.dirname(file), f)
	break
	else:
	# Look for a sidecar NFO file.
	path = os.path.splitext(file)[0] + '.nfo'

	if path is not None and os.path.exists(path):
	nfoText = open(path).read()
	m = re.search('(tt[0-9]+)', nfoText)
	if m:
	return m.groups(1)[0]
	except:
	print "Warning, couldn't read NFO file."

	return None
	import Media, VideoFiles
	import os.path, difflib
	import re

	def compareFilenames(elem):
	return elem.parts[0].lower()

	def Scan(dir, files, mediaList, subdirs):

	# Go through the files and see if any of them need to be stacked.
	stack_dict = {}
	stackDiffs = r'[\da-n]' # These are the characters we are looking for being different across stackable filenames
	stackSuffixes = r'(?:cd\|dvd\|part\|pt\|disk\|disc\|scene)\.?(?:\d+)?$'
	scenePrefixes = r'(?:^scene.\d+\|scene.\d+$)'

	# Sort the mediaList by filename, so we can do our compares properly
	mediaList[:] = sorted(mediaList, key=compareFilenames)

	# check for monotonically increasing numeric or alphabetic filenames
	count = 0
	monotonicSeries = False
	for mediaItem in mediaList[:-1]:
	# if it didn't start as a monotonic series, it's not going to become one
	if count > 0 and monotonicSeries == False:
	break

	# if items were already stacked by other method, skip this attempt
	if hasattr(mediaItem, 'stacked') and mediaItem.stacked == True:
	continue

	m1 = mediaList[count]
	m2 = mediaList[count + 1]
	f1 = os.path.basename(os.path.splitext(m1.parts[0])[0]).strip().lower()
	f2 = os.path.basename(os.path.splitext(m2.parts[0])[0]).strip().lower()

	initialA = re.search(r'(^\d+)', f1)
	initialB = re.search(r'(^\d+)', f2)
	terminalA = re.search(r'(\d+)$', f1)
	terminalB = re.search(r'(\d+)$', f2)

	# if the filenames both start, or both end with a digit,
	# and the digit of the second filename is 1 larger than the one of the first filename, it's a series
	if(((initialA and initialB) and (int(initialA.group(0)) == int(initialB.group(0)) - 1)) or
	((terminalA and terminalB) and (int(terminalA.group(0)) == int(terminalB.group(0)) - 1))):
	monotonicSeries = True

	# if the filenames both start, or both end with a letter,
	# and the letter seems to the correct one for this iteration if we started from "a",
	# and the letter of the second filename is 1 larger than the one of the first filename, it's a series
	if(monotonicSeries == False):
	initialA = re.search(r'(^[a-y])', f1)
	initialB = re.search(r'(^[a-y])', f2)
	terminalA = re.search(r'([a-y])$', f1)
	terminalB = re.search(r'([a-y])$', f2)
	if(((initialA and initialB) and (ord(initialA.group(0)) == ord('a') + count and ord(initialA.group(0)) == ord(initialB.group(0)) - 1)) or
	((terminalA and terminalB) and (ord(terminalA.group(0)) == ord('a') + count and ord(terminalA.group(0)) == ord(terminalB.group(0)) - 1))):
	monotonicSeries = True

	if monotonicSeries:

	m1.name = dir
	root = '_monotonic'

	m1.stacked = True
	if stack_dict.has_key(root):
	stack_dict[root].append(m2)
	# only mark the second item as stacked on last iteration, otherwise it'll break out of the loop in the start
	if count == len(mediaList) - 1:
	m2.stacked = True
	else:
	stack_dict[root] = [m1]
	stack_dict[root].append(m2)

	count += 1

	# group scene-based movie splits into a stack
	for mediaItem in mediaList:
	# if items were already stacked by other method, skip this attempt
	if hasattr(mediaItem, 'stacked') and mediaItem.stacked == True:
	continue

	f1 = os.path.basename(os.path.splitext(mediaItem.parts[0])[0]).lower()
	if re.match(scenePrefixes, f1):
	(name, year) = VideoFiles.CleanName(re.sub(scenePrefixes, '', f1))
	root = '_scene'
	mediaItem.name = name

	if stack_dict.has_key(root):
	stack_dict[root].append(mediaItem)
	mediaItem.stacked = True
	else:
	stack_dict[root] = [mediaItem]
	mediaItem.stacked = True

	# Search for prefix-based part names.
	count = 0
	for mediaItem in mediaList[:-1]:
	m1 = mediaList[count]
	m2 = mediaList[count + 1]

	# if items were already stacked by other method, skip this attempt
	if hasattr(m1, 'stacked') and m1.stacked == True:
	continue

	f1 = os.path.basename(m1.parts[0])
	f2 = os.path.basename(m2.parts[0])

	opcodes = difflib.SequenceMatcher(None, f1, f2).get_opcodes()

	if len(opcodes) == 3: # We only have one transform
	(tag, i1, i2, j1, j2) = opcodes[1]
	if tag == 'replace': # The transform is a replace
	if (i2-i1 <= 2) and (j2-j1 <= 2): # The transform is only one character
	if re.search(stackDiffs, f1[i1:i2].lower()): # That one character is 1-4 or a-n
	root = f1[:i1].strip(' _-')
	xOfy = False

	if f1[i1+1:].lower().strip().startswith('of'): #check to see if this an x of y style stack, if so flag it
	xOfy = True
	#prefix = f1[:i1] + f1[i2:]
	#(root, ext) = os.path.splitext(prefix)

	# This is a special case for folders with multiple Volumes of a series (not a stacked movie) [e.g, Kill Bill Vol 1 / 2]
	if not root.lower().strip().endswith('vol') and not root.lower().strip().endswith('volume'):

	# Strip any suffixes like CD, DVD.
	foundSuffix = False
	suffixMatch = re.search(stackSuffixes, root.lower().strip())

	if suffixMatch:
	root = root[0:-len(suffixMatch.group(0))].strip(' _-')
	foundSuffix = True

	if foundSuffix or xOfy:
	# Replace the name, which probably had the suffix.
	(name, year) = VideoFiles.CleanName(root)
	# pdb.set_trace()

	mediaItem.name = name
	m1.stacked = True
	if stack_dict.has_key(root):
	stack_dict[root].append(m2)
	# only mark the second item as stacked on last iteration, otherwise it'll break out of the loop in the start
	if count == len(mediaList) - 1:
	m2.stacked = True
	else:
	stack_dict[root] = [m1]
	stack_dict[root].append(m2)
	count += 1

	# combine stacks if possible
	count = 0
	stacks = stack_dict.keys()
	for stack in stacks[:-1]:
	s1 = stacks[count]
	s2 = stacks[count + 1]
	opcodes = difflib.SequenceMatcher(None, s1, s2).get_opcodes()

	if len(opcodes) == 2: # We only have one transform
	(tag, i1, i2, j1, j2) = opcodes[1]
	if tag == 'replace': # The transform is a replace
	if (i2-i1 == 1) and (j2-j1 == 1): # The transform is only one character
	if re.search(stackDiffs, s1): # That one character is 1-4 or a-n
	root = s1.lower().strip()
	suffixMatch = re.search(stackSuffixes, root)
	if suffixMatch:
	root = root[0:-len(suffixMatch.group(0))].strip(' -')

	(name, year) = VideoFiles.CleanName(root)

	# merge existing two stacks into new root
	for oldstack in [s1, s2]:
	for media in stack_dict[oldstack]:
	media.name = name

	if stack_dict.has_key(root):
	for media in stack_dict[oldstack]:
	stack_dict[root].append(media)
	else:
	stack_dict[root] = stack_dict[oldstack]
	del stack_dict[oldstack]

	count += 1

	# Now combine stacked parts
	for stack in stack_dict.keys():
	for media in stack_dict[stack][1:]:
	stack_dict[stack][0].parts.append(media.parts[0])
	mediaList.remove(media)