def downloadKWorbSpotifyYouTubeArtists(self, update=False):
url = "https://kworb.net/youtube/archive.html"
savename = "kworb_youtubeartists.p"
if update is True:
self.dutils.downloadArtistURL(url=url,
savename=savename,
force=True)
bsdata = getHTML(savename)
data = []
artistDir = self.disc.getArtistsDir()
saveDir = setDir(artistDir, "youtube")
print(artistDir)
for table in bsdata.findAll("table"):
ths = [th.text for th in table.findAll("th")]
for tr in table.findAll("tr")[1:]:
item = dict(zip(ths, tr.findAll("td")))
data.append(item)
print(data)
if False:
bsdata = getHTML(savename)
artistDir = self.disc.getArtistsDir()
saveDir = setDir(artistDir, "youtube")
for div in bsdata.findAll("div", {"class": "subcontainer"}):
if div.find("span", {"class": "pagetitle"}) is None:
continue
for ref in div.findAll("a"):
href = ref.attrs['href']
url = "{0}/{1}".format(self.youtubeURL, href)
savename = "{0}/{1}".format(saveDir,
href.replace(".html", ".p"))
if isFile(savename):
print("Y\t", savename, '\t', url)
else:
print("-\t", savename, '\t', url)
#dbArtistsKWorb().dutils.downloadArtistURL(url=fullURL, savename=savename, force=True)
for ifile in findExt(saveDir, ".p"):
bsdata = getHTML(ifile)
for table in bsdata.findAll("table"):
trs = table.findAll("tr")
for tr in trs[1:]:
ref = tr.find("a")
href = ref.attrs['href']
name = ref.text
url = "{0}/{1}".format(self.youtubeURL, href)
savename = "{0}/{1}".format(
setDir(saveDir, "artist"),
href.replace(".html", ".p"))
print(url, savename)
if isFile(savename) is False:
data, code = downloadURL(url)
from ioUtils import getFile, saveFile
saveFile(idata=data, ifile=savename)
sleep(3)
break
def findMyMusic(self, primeDir=None, artistName=None):
artistAlbums = {}
if primeDir is None and artistName is None:
ts = timestat("Find PrimeDir Artist Paths")
pdPaths = {
pd: pdpath
for pd, pdpath in
{pd: setDir(self.musicDir, pd)
for pd in self.pdDirs}.items() if dirUtil(pdpath).isDir()
}
pdArtistPaths = {
pd: findDirs(pdpath)
for pd, pdpath in pdPaths.items()
}
artistPaths = {
fsap.name: fsap.path
for fsap in
[dirUtil(ap) for ap in getFlatList(pdArtistPaths.values())]
}
artistAlbums = {
artistName: self.getArtistPathData(artistName, artistPath)
for artistName, artistPath in artistPaths.items()
}
print(" Found {0} Artists From {1} Prime Directories".format(
len(artistAlbums), len(pdArtistPaths)))
ts.stop()
elif primeDir is not None:
ts = timestat(
"Finding All Artist Albums From [{0}] Prime Directory".format(
primeDir))
pdPaths = {
pd: pdpath
for pd, pdpath in
{pd: setDir(self.musicDir, pd)
for pd in [primeDir]}.items() if dirUtil(pdpath).isDir()
}
pdArtistPaths = {
pd: findDirs(pdpath)
for pd, pdpath in pdPaths.items()
}
artistPaths = {
fsap.name: fsap.path
for fsap in
[dirUtil(ap) for ap in getFlatList(pdArtistPaths.values())]
}
artistAlbums = {
artistName: self.getArtistPathData(artistName, artistPath)
for artistName, artistPath in artistPaths.items()
}
print(" Found {0} Artists From [{1}] Prime Directory".format(
len(artistAlbums), primeDir))
ts.stop()
elif artistName is not None:
ts = timestat("Finding [{0}] Artist Albums".format(artistName))
artistAlbums = self.getArtistPathData(artistName)
ts.stop()
self.artistAlbums = artistAlbums
return artistAlbums
def getArtistNameDirvalsMap(artistName):
primeDir = getPrimeDirectory(artistName)
dirvals = []
for matchedDir in getMatchedDirs():
primeDirVal = setDir(matchedDir, primeDir)
possibleDir = setDir(primeDirVal, normalize('NFC', artistName), forceExist=False)
if isDir(possibleDir):
dirvals.append(possibleDir)
return dirvals
def getArtistMusicDir(self, artistName):
primeDirs = [setDir(musicDir, self.getPrimeDirectory(artistName)) for musicDir in self.musicDirs]
artistMusicDirs = [setDir(primeDir, artistName) for primeDir in primeDirs]
artistMusicDirs = [x for x in artistMusicDirs if isDir(x)]
if len(artistMusicDirs) > 1:
raise ValueError("Found more than one artist music directories...")
elif len(artistMusicDirs) == 1:
return artistMusicDirs[0]
else:
return None
def moveMyMatchedMusicAlbums(self, show=False):
rename = True
albumsToMove = getFile(ifile=self.moveFilename)
print("Found {0} music <-> discogs albums maps".format(
len(albumsToMove)))
for db, dbValues in albumsToMove.items():
if dbValues is None:
continue
for artistName, artistAlbums in dbValues.items():
print("==>", artistName)
for myAlbumName, albumVals in artistAlbums.items():
dirval = albumVals["Dir"]
albumVal = albumVals["Album"]
ratio = albumVals["Ratio"]
dbAlbumName = albumVal["Name"]
dbAlbumCode = albumVal["Code"]
mediaType = albumVal["MediaType"]
matchedDir = setDir(dirval, "Match")
mkDir(matchedDir)
srcName = myAlbumName
srcDir = setDir(dirval, srcName)
if not isDir(srcDir):
print("{0} does not exist".format(srcDir))
continue
mediaDir = setDir(matchedDir, self.discConv(mediaType))
mkDir(mediaDir)
if rename is True:
dstName = self.getMatchedDirName(
self.discConv(dbAlbumName), dbAlbumCode, db)
else:
dstName = self.getMatchedDirName(
myAlbumName, dbAlbumCode, db)
if show is True:
print('\t{0}'.format(mediaDir))
print("\t\t[{0}]".format(srcName))
print("\t\t[{0}]".format(dstName))
continue
dstDir = setDir(mediaDir, dstName)
if isDir(dstDir):
print("{0} already exists".format(dstDir))
continue
print("\tMoving {0} ---> {1}".format(srcDir, dstDir))
moveDir(srcDir, dstDir, debug=True)
def main(args):
cwd = getcwd()
albumSegments = {}
discSegments = {}
for ifile in findPattern("./", pattern="."):
mid = mp3ID(ifile)
try:
mid = mp3ID(ifile)
except:
print("Error reading file {0}".format(ifile))
continue
album = mid.getAlbum()
print("Album: {0}".format(album))
if album is not None:
album = album[0]
if albumSegments.get(album) is None:
albumSegments[album] = []
albumSegments[album].append(ifile)
disc = mid.getDiscNumber()
if disc is not None:
disc = disc[0]
if discSegments.get(disc) is None:
discSegments[disc] = []
discSegments[disc].append(ifile)
if args.album is True:
print("Album Segments: {0}".format(albumSegments.keys()))
for album, albumFiles in albumSegments.items():
albumDir = setDir(cwd, album)
mkDir(albumDir)
for ifile in albumFiles:
src = ifile
dst = setFile(albumDir, getBasename(ifile))
print("Moving [{0}] to [{1}]".format(src, dst))
moveFile(src, dst, debug=True)
if args.disc is True:
print("Disc Segments: {0}".format(discSegments.keys()))
for disc, discFiles in discSegments.items():
discDir = setDir(cwd, "Disc {0}".format(disc))
mkDir(discDir)
for ifile in discFiles:
src = ifile
dst = setFile(discDir, getBasename(ifile))
#print("Moving [{0}] to [{1}]".format(src, dst))
moveFile(src, dst, debug=True)
def getArtistModValFiles(self, modVal, previousDays=5, force=False):
artistDir = self.disc.getArtistsDir()
maxModVal = self.disc.getMaxModVal()
artistDBDir = self.disc.getArtistsDBDir()
dirVal = setDir(artistDir, str(modVal))
files = findExt(dirVal, ext='.p')
dbname = setFile(artistDBDir, "{0}-DB.p".format(modVal))
now = datetime.now()
if isFile(dbname):
lastModified = datetime.fromtimestamp(path.getmtime(dbname))
if force is True:
lastModified = None
else:
lastModified = None
newFiles = None
if lastModified is None:
newFiles = files
print(" ===> Parsing all {0} files for modval {1}".format(len(newFiles), modVal))
else:
numNew = [ifile for ifile in files if (now-datetime.fromtimestamp(path.getmtime(ifile))).days < previousDays]
numRecent = [ifile for ifile in files if datetime.fromtimestamp(path.getmtime(ifile)) > lastModified]
newFiles = list(set(numNew).union(set(numRecent)))
print(" ===> Found new {0} files (< {1} days) to parse for modval {2}".format(len(newFiles), previousDays, modVal))
return newFiles
def __init__(self, debug=False):
self.db = "DatPiff"
self.disc = dbBase(self.db.lower())
self.artist = artistDP(self.disc)
self.dutils = datpiffUtils()
self.dutils.setDiscogs(self.disc)
self.debug = debug
## MultiArtist
self.mulArts = multiartist()
print("DatPiff ArtistsDir: {0}".format(self.disc.getArtistsDir()))
if not isDir(self.disc.getArtistsDir()):
raise ValueError("Could not find artist dir for DatPiff")
self.knownDir = setDir(self.disc.getArtistsDir(), "known")
if not isDir(self.knownDir):
print("Make sure that Piggy is loaded!!!")
raise ValueError("Could not find known [{0}] dir for DatPiff".format(self.knownDir))
self.knownFile = setFile(self.knownDir, "datPiffKnown.p")
if not isFile(self.knownFile):
raise ValueError("Known File [{0}] does not exist".format(self.knownFile))
self.baseURL = "https://www.datpiff.com/"
self.searchURL = "https://www.datpiff.com/mixtapes-search?"
super().__init__(self.db, self.disc, self.artist, self.dutils, debug=debug)
def actionOnAlbum(albumDir, artistDir, retval):
if any([retval["Skip"], retval["Extra"]]):
return
## Set Needed Directories
todoDir = setDir(artistDir, "Todo", forceExist=False)
multiDir = setDir(artistDir, "Multi", forceExist=False)
titleDir = setDir(artistDir, "Title", forceExist=False)
randomDir = setDir(artistDir, "Random", forceExist=False)
mixDir = setDir(artistDir, "Mix", forceExist=False)
testTitle = retval["Title"]
testTitle = False
testTrackNo = retval["Track"]
testMulti = retval["Multi"]
testMix = retval["Mix"]
#print(testTitle,testTrackNo,testMulti)
if testTitle is True:
if not isDir(titleDir):
mkDir(titleDir)
srcdir = albumDir
dstdir = setDir(titleDir, getDirBasics(albumDir)[-1])
print("!!! Moving {0} ==> {1}".format(srcdir, dstdir))
sleep(1)
moveDir(srcdir, dstdir)
elif testMix is True:
if not isDir(mixDir):
mkDir(mixDir)
srcdir = albumDir
dstdir = setDir(mixDir, getDirBasics(albumDir)[-1])
print("!!! Moving {0} ==> {1}".format(srcdir, dstdir))
sleep(1)
moveDir(srcdir, dstdir)
elif testTrackNo is True:
if not isDir(todoDir):
mkDir(todoDir)
srcdir = albumDir
dstdir = setDir(todoDir, getDirBasics(albumDir)[-1])
print("!!! Moving {0} ==> {1}".format(srcdir, dstdir))
sleep(1)
moveDir(srcdir, dstdir)
elif testMulti is True:
if not isDir(multiDir):
mkDir(multiDir)
srcdir = albumDir
dstdir = setDir(multiDir, getDirBasics(albumDir)[-1])
print("!!! Moving {0} ==> {1}".format(srcdir, dstdir))
sleep(1)
moveDir(srcdir, dstdir)
def __init__(self, install=False, debug=False):
self.debug = debug
print("{0} masterMultiArtistDB() {1}".format("=" * 25, "=" * 25))
self.debug = debug
self.io = fileIO()
self.multiArtistDir = setDir(prefix, 'multiartist')
self.initializeData() if install is False else self.installData()
def __init__(self, db, debug=False):
if debug:
print("=" * 25, " {0} ".format(db), "=" * 25)
self.base = db
self.debug = debug
self.dbsavepath = setDir("/Users/tgadfort/Music",
"Discog",
forceExist=False)
self.metasavepath = setDir("/Users/tgadfort/Music",
"Discog",
forceExist=False)
self.rawsavepath = setDir("/Volumes/Piggy", "Discog", forceExist=False)
self.maxModVal = 100
self.io = fileIO()
self.createDirectories()
def getArtistModValExtraFiles(self, modVal, previousDays=5, force=False):
artistDir = self.disc.getArtistsDir()
maxModVal = self.disc.getMaxModVal()
artistDBDir = self.disc.getArtistsDBDir()
dirVal = setDir(artistDir, str(modVal))
dirVal = setDir(dirVal, "extra")
files = findExt(dirVal, ext='.p')
dbname = setFile(artistDBDir, "{0}-DB.p".format(modVal))
now = datetime.now()
newFiles = None
if lastModified is None:
newFiles = files
print(" ===> Parsing all {0} extra files for modval {1}".format(len(newFiles), modVal))
else:
numFiles = [ifile for ifile in files if (now-datetime.fromtimestamp(path.getmtime(ifile))).days < previousDays]
print(" ===> Found new {0} extra files (< {1} days) to parse for modval {2}".format(len(newFiles), previousDays, modVal))
return newFiles
def downloadRottenTomatoesTop100Data(self, genre, outdir, debug=False):
baseurl = "https://www.rottentomatoes.com"
outdir = setDir(self.getDataDir())
if not isDir(outdir): mkDir(outdir)
url = "/top/bestofrt/top_100_" + genre + "_movies/"
url = baseurl + url
savename = setFile(outdir, genre + ".p")
if isFile(savename): return
if debug:
print("Downloading/Saving {0}".format(savename))
getWebData(base=url, savename=savename, useSafari=False, dtime=10)
sleep(2)
def parseDownloadedFiles(self):
artistDir = self.disc.getArtistsDir()
dataDir = setDir(artistDir, "data")
files = findPatternExt(dataDir,
pattern="Discography and Albums",
ext=".htm")
for ifile in files:
htmldata = getFile(ifile)
retval = self.getData(ifile)
artistID = retval.ID.ID
savename = self.getArtistSavename(artistID)
saveFile(idata=htmldata, ifile=savename, debug=True)
def parseDownloadedFiles(self, previousDays=None, force=False):
artistDir = self.disc.getArtistsDir()
files = self.getArtistRawHTMLFiles(previousDays=None, force=False)
return
dataDir = setDir(artistDir, "data")
files = findPatternExt(dataDir, pattern="Rate Your Music", ext=".html")
for ifile in files:
htmldata = getFile(ifile)
retval = self.artist.getData(ifile)
artistID = retval.ID.ID
savename = self.dutils.getArtistSavename(artistID)
saveFile(idata=htmldata, ifile=savename, debug=False)
def createDirnameDirectories(self, savedir, dirnames):
localdirnames = dict(
zip(dirnames, [setDir(savedir, x) for x in dirnames]))
for name, dirname in localdirnames.items():
if not isDir(dirname):
print("Creating {0}".format(dirname))
try:
mkDir(dirname, debug=True)
except:
print("Cannot create {0}".format(dirname))
else:
if self.debug:
print("{0} exists".format(dirname))
return localdirnames
def __init__(self,
musicDir="/Volumes/Piggy/Music/Matched",
install=False,
debug=False):
self.debug = debug
self.musicDir = musicDir
print("=" * 25, "myMusicPathData({0})".format(musicDir), "=" * 25)
### My Music Directory Names
self.artistAlbums = None
self.pd = primeDirectory()
self.pdDirs = self.pd.getPrimeDirectories()
self.musicDataDir = setDir(prefix, 'music')
self.initializeData() if install is False else self.installData()
def getModValDir(self, modVal):
artistDir = self.disc.getArtistsDir()
maxModVal = self.disc.getMaxModVal()
artistDBDir = self.disc.getArtistsDBDir()
dirVal = setDir(artistDir, str(modVal))
if self.credit is True:
dirVal = setDir(dirVal, "credit")
elif self.song is True:
dirVal = setDir(dirVal, "song")
elif self.composition is True:
dirVal = setDir(dirVal, "composition")
elif self.extra is True:
dirVal = setDir(dirVal, "extra")
elif self.unofficial is True:
dirVal = setDir(dirVal, "unofficial")
return dirVal
def main(args):
if args.dir is None:
args.dir = getcwd()
#retval = testAlbum(albumDir, artistDir, files=filevals)
albumDirs = findDirs(args.dir)
for albumDir in albumDirs:
if getDirBasics(albumDir)[-1] != "Album":
continue
pb = pathBasics(albumDir=albumDir)
files = pb.getFiles()
print("\n")
print("=" * 60)
print("===", albumDir, "===")
print("=" * 60)
for subalbumDir, filevals in files.items():
#print(subalbumDir,len(filevals))
albumName = Counter()
for ifile in filevals:
results = MusicID(ifile, debug=args.debug)
if results.skip is True:
continue
tags = results.getInfo()
albumVal = tags["Album"][0]
albumName[albumVal] += 1
if len(albumName) != 1:
continue
albumName = albumName.most_common(1)[0][0]
albumName = albumName.replace("/", " ")
srcDir = subalbumDir
dstDir = setDir(albumDir, albumName)
if isDir(dstDir):
continue
#print("Moving {0} ==> {1}\n\n".format(srcDir, dstDir))
print("\nmv \"{0}\" \"{1}\"\n".format(srcDir, dstDir))
def downloadKWorbSpotifyArtists(self, update=False):
url = "https://kworb.net/spotify/artists.html"
savename = "kworb_spotifyartists.p"
if update is True:
self.dutils.downloadArtistURL(url=url,
savename=savename,
force=True)
bsdata = getHTML(savename)
data = []
artistDir = self.disc.getArtistsDir()
saveDir = setDir(artistDir, "data")
print(artistDir)
for table in bsdata.findAll("table"):
ths = [th.text for th in table.findAll("th")]
for tr in table.findAll("tr")[1:]:
item = dict(zip(ths, tr.findAll("td")))
data.append(item)
print("Found {0} Spotify Artists".format(len(data)))
for i, item in enumerate(data):
info = item["Artist"]
url = info.find('a').attrs['href']
name = info.find('a').text
savename = setFile(saveDir, "{0}.p".format(getBaseFilename(url)))
if isFile(savename):
continue
print("Y\t", savename, '\t', url, '\t', name)
else:
fullURL = "{0}/{1}".format(self.spotifyURL, url)
print("{0}/{1}".format(i, len(data)), "\t-\t", savename, '\t',
fullURL, '\t', name)
try:
self.dutils.downloadArtistURL(url=fullURL,
savename=savename,
force=True)
except:
print(" ---> Error")
sleep(1)
def getMyOtherMusicAlbums(self, dirval, mname):
return getFlatList([[p for p in findDirs(setDir(dirval, mdirval))]
for mdirval in self.mdirmap.getMapping(mname)])
def getResultsDir(self):
dirname = setDir(self.getMovieDBDir(), self.resultsdir)
if not isDir(dirname): mkDir(dirname)
return dirname
def getDataDir(self):
dirname = setDir(self.getMovieDBDir(), self.datadir)
if not isDir(dirname): mkDir(dirname)
return dirname
def parseArtistModValFiles(self, modVal, previousDays=5, force=False, debug=False, doExtra=False):
print("-"*100)
print("Parsing Artist Files For ModVal {0}".format(modVal))
artistInfo = self.artist
artistDir = self.disc.getArtistsDir()
maxModVal = self.disc.getMaxModVal()
artistDBDir = self.disc.getArtistsDBDir()
dirVal = setDir(artistDir, str(modVal))
dbname = setFile(artistDBDir, "{0}-DB.p".format(modVal))
newFiles = self.getArtistModValFiles(modVal, previousDays=previousDays, force=force)
if force is False:
dbdata = getFile(dbname, version=3)
else:
print("Forcing Reloads of ModVal={0}".format(modVal))
print(" Processing {0} files.".format(len(newFiles)))
dbdata = {}
saveIt = 0
for j,ifile in enumerate(newFiles):
if force is True:
if j % 100 == 0:
print("\tProcessed {0}/{1} files.".format(j,len(newFiles)))
artistID = getBaseFilename(ifile)
isKnown = dbdata.get(artistID)
info = artistInfo.getData(ifile)
if info.ID.ID != artistID:
print("File: {0}".format(ifile))
print(info.show())
1/0
# Check Profile
try:
artistName = info.profile.search
if artistName is not None:
self.creditToDownload[artistID] = [artistName,self.getArtistSavename(artistID, credit=True)]
except:
pass
if debug is False:
continue
print("ID From Name: {0}".format(artistID))
print("ID From File: {0}".format(info.ID.ID))
print("File: {0}".format(ifile))
print("Info: {0}".format(info.url.get()))
continue
#1/0
saveIt += 1
dbdata[artistID] = info
forceSave = False
if saveIt > 0 and doExtra is True:
print("\tCalling Extra Parsing")
dbdata = self.parseArtistModValExtraFiles(modVal, dbdata=dbdata, force=force, debug=debug)
forceSave = True
saveIt = len(dbdata)
if len(self.creditToDownload) > 0:
print("Found {0} artists that need new downloads.".format(len(self.creditToDownload)))
if saveIt > 0 or forceSave is True:
savename = setFile(artistDBDir, "{0}-DB.p".format(modVal))
print("Saving {0} new artist IDs to {1}".format(saveIt, savename))
dbNumAlbums = sum([self.getArtistNumAlbums(artistData) for artistData in dbdata.values()])
print("Saving {0} total artist media".format(dbNumAlbums))
saveFile(idata=dbdata, ifile=savename)
self.createArtistModValMetadata(modVal=modVal, db=dbdata, debug=debug)
self.createArtistAlbumModValMetadata(modVal=modVal, db=dbdata, debug=debug)
return saveIt
def getArtistPrimeDir(self, artistName):
return setDir(self.musicDir, self.pd.getPrimeDirectory(artistName))
def main(args):
args = addDefault(args)
print('Artist = {!r}'.format(args.artist))
print('Album = {!r}'.format(args.album))
print('Class = {!r}'.format(args.cls))
print('Dir = {!r}'.format(args.dir))
if args.artist is True:
pb = pathBasics(artistDir=args.dir)
elif args.album is True:
pb = pathBasics(albumDir=args.dir)
elif args.cls is True:
pb = pathBasics(classDir=args.dir)
else:
raise ValueError("Can only run with -artist, -album, or -class!")
actions = {}
files = pb.getFiles()
for i, (dirval, filevals) in enumerate(files.items()):
print("\nDirectory: {0}".format(dirval))
header()
j = 0
errs = {}
for jf, ifile in enumerate(filevals):
results = MusicID(ifile, debug=args.debug)
if results.skip is True:
continue
tags = results.getInfo()
r = tags
pbc = pb.getPaths(ifile).getDict()
errs[ifile] = {}
j += 1
p([
j, r["DiscNo"], r["TrackNo"], r["AlbumArtist"], r["Artist"],
r["Album"], r["Title"], r["Size"]
])
if args.showpath is True:
p([
j, pbc["pbDisc"], None, pbc["pbArtist"], pbc["pbArtist"],
pbc["pbAlbum"], pbc["pbFile"], None
])
#print(pbc)
if r["AlbumArtist"][0] == pbc["pbArtist"]:
pass
else:
if pbc["pbAlbum"] in skipDirs():
pass
elif tags["AlbumArtist"][0].replace("/",
"-") == pbc["pbArtist"]:
pass
else:
errs[ifile]["Artist"] = {
"Tag": r["Artist"][0],
"Path": pbc["pbArtist"]
}
if r["Album"][0] == pbc["pbAlbum"]:
pass
else:
if pbc["pbAlbum"] in skipDirs():
pass
else:
errs[ifile]["Album"] = {
"Tag": r["Album"][0],
"Path": pbc["pbAlbum"]
}
if args.force is not None:
for ifile, fileData in errs.items():
if actions.get(dirval) is not None:
continue
if not isFile(ifile):
continue
for category, errData in fileData.items():
if args.force.title() == category:
print("Mismatch: {0}".format(args.force.title()))
print("File: {0}".format(ifile))
print("Tag: [{0}]".format(errData["Tag"]))
print("Path: [{0}]".format(errData["Path"]))
if args.usetag is True:
srcdir = dirval
if "/" in errData["Tag"]:
print("Found / in Tag. Converting to -")
errData["Tag"] = errData["Tag"].replace(
"/", "-")
if "\"" in errData["Tag"]:
print("Found \" in Tag. Converting to -")
errData["Tag"] = errData["Tag"].replace(
"\"", "")
dstdir = setDir(getDirname(dirval), errData["Tag"])
print(
"Set option to move directory based on the {0} tag"
.format(category))
print("Moving {0}".format(srcdir))
if isDir(dstdir):
print("=" * 40)
print(
"== Not moving because there is already a directory with that name..."
)
print("=" * 40)
break
print(" to {0}".format(dstdir))
if "/" in errData["Path"]:
print("=" * 40)
print(
"== Not moving because there is a sub directory..."
)
print("=" * 40)
break
if args.script is False:
print("Sleeping for 3 seconds")
for i in range(3):
print(".", end="")
sys.stdout.flush()
sleep(1)
print("\n")
moveDir(srcdir, dstdir)
break
else:
actions[srcdir] = dstdir
break
else:
return
if args.script is False:
print("\n", "=" * 60, "\n")
print("Looks Good")
print("\n\n")
else:
if len(actions) > 0:
print("#!/bin/sh\n", file=open("actions.sh", "w"))
for srcdir, dstdir in actions.items():
print("mv \"{0}\" \"{1}\"".format(srcdir, dstdir),
file=open("actions.sh", "a"))
from os import chmod
import stat
chmod("actions.sh", stat.S_IRWXU)
print("\n", "=" * 60, "\n")
print("Looks Good")
print("\n\n")
def getArtistMusicPath(self, artistName):
artistPrimeDir = self.getArtistPrimeDir(artistName)
artistMusicDir = setDir(artistPrimeDir, artistName)
artistMusicDir = artistMusicDir if dirUtil(
artistMusicDir).isDir() else None
return artistMusicDir
def getCorrectionsDir(self):
dirname = setDir(self.getMovieDBDir(), "corrections")
if not isDir(dirname): mkDir(dirname)
return dirname
def getModValDirs(self):
modVals = self.getModVals()
retval = [setDir(self.getArtistsDir(), str(modVal)) for modVal in modVals]
return retval
def parseArtistModValCreditFiles(self, modVal, dbdata=None, debug=False, force=False):
print("\t","="*100)
print("\t","Parsing Artist Credit Files For ModVal {0}".format(modVal))
artistInfo = self.artist
artistDir = self.disc.getArtistsDir()
maxModVal = self.disc.getMaxModVal()
artistDBDir = self.disc.getArtistsDBDir()
dirVal = setDir(artistDir, str(modVal))
dirVal = setDir(dirVal, "credit")
files = findExt(dirVal, ext='.p')
if len(files) == 0:
return dbdata
print("\t"," Found {0} credit files for ModVal {1}".format(len(files), modVal))
dbname = setFile(artistDBDir, "{0}-DB.p".format(modVal))
retdbdata = False
if dbdata is None:
print("\t"," Loaded ", end="")
dbdata = getFile(dbname, version=3)
print("\t","{0} artist IDs.".format(len(dbdata)))
else:
retdbdata = True
saveIt = 0
nArtistMedia = {}
print("\t","{0} artist IDs.".format(len(dbdata)))
for j,ifile in enumerate(files):
if force is True:
if j % 500 == 0:
print("\t","\tProcessed {0}/{1} files.".format(j,len(files)))
if debug:
print("\t","{0}/{1} -- {2}.".format(j,len(files),ifile))
info = artistInfo.getData(ifile)
artistID = info.ID.ID
#currentMedia = sum([len(x) for x in dbdata[artistID].media.media.values()])
#print(artistID,'\t',sum([len(x) for x in dbdata[artistID].media.media.values()]),end="\t")
currentKeys = []
if dbdata.get(artistID) is not None:
currentKeys = list(dbdata[artistID].media.media.keys())
else:
dbdata[artistID] = info
saveIt += 1
continue
keys = list(set(list(info.media.media.keys()) + currentKeys))
for k in keys:
v = info.media.media.get(k)
if v is None:
continue
iVal = {v2.code: v2 for v2 in v}
dVal = dbdata[artistID].media.media.get(k)
if dVal is None:
Tretval = iVal
saveIt += len(iVal)
else:
Tretval = {v2.code: v2 for v2 in dVal}
Tretval.update(iVal)
saveIt += len(iVal)
dbdata[artistID].media.media[k] = list(Tretval.values())
if debug:
print("\t","File:",j," \tArtist:",artistID,'-->',currentMedia,'to',sum([len(x) for x in dbdata[artistID].media.media.values()]))
if retdbdata is True:
return dbdata
#if saveAll is False:
# return saveIt
if saveIt > 0:
savename = setFile(artistDBDir, "{0}-DB.p".format(modVal))
print("\t","Saving {0} artists to {1}".format(len(dbdata), savename))
print("\t","Saving {0} new (credit) artist media to {1}".format(saveIt, savename))
dbNumAlbums = sum([self.getArtistNumAlbums(artistData) for artistData in dbdata.values()])
print("\t","Saving {0} total (credit) artist media".format(dbNumAlbums))
saveFile(idata=dbdata, ifile=savename)
self.createArtistModValMetadata(modVal=modVal, db=dbdata, debug=debug)
self.createArtistAlbumModValMetadata(modVal=modVal, db=dbdata, debug=debug)
return saveIt
