def hachm(filename):
# using this example http://archive.org/details/WorkToFishtestwmv
try:
filename, realname = unicodeFilename(filename), filename
except TypeError:
filename,realname=filename,filename
parser = createParser(filename)
# See what keys you can extract
tmp = metadata.extractMetadata(parser)
if tmp is None: return {}
else: tmp = tmp._Metadata__data.iteritems()
for k,v in tmp:
if v.values:
print v.key, v.values[0].value
# Turn the tags into a defaultdict
metalist = metadata.extractMetadata(parser).exportPlaintext()
meta = defaultdict(defaultdict)
if not metalist:
return meta
for item in metalist[1:]:
item = [x.strip() for x in item.split('-') if x.strip()][0]
item = [ x.strip().lower().replace(' ','_') for x in item.split(':') ]
k,v = item.pop(0),':'.join(item)
meta[k]=v
return meta
def parse_metadata(cls, full_path, db_conn):
file_ext = os.path.splitext(full_path)[1][1:].lower()
if(file_ext in ['mp3','bzip2','gzip','zip','tar','wav','midi','bmp','gif','jpeg','jpg','png','tiff','exe','wmv','mkv','mov']):
# full_path = self._full_path(orig_path)
# print(full_path)
parser = createParser(full_path)
metalist = metadata.extractMetadata(parser).exportPlaintext()
for item in metalist:
x = item.split(':')[0]
if item.split(':')[0][2:].lower() in ["author","album","music genre"]:
# print(item.split(':')[1][1:])
item1 = item.split(':')[1][1:]
new_item = str(item1.decode('utf-8'))
print new_item
new_item = string.replace(new_item, ";", ",")
new_item = string.replace(new_item, "|", ",")
tag_name = new_item.split(',')
print(tag_name)
for names in tag_name:
# inode = os.stat(full_path)[ST_INO
tagname = names.strip()
MiscFunctions.storeTagInDB(full_path, tagname, db_conn, is_system_tag=1)
print("Database storage successful")
elif file_ext in ["docx", "doc", "txt"]:
tags = MiscFunctions.handleTextFiles(full_path)
for tagname in tags:
print "txt file tag: %s" % tagname
MiscFunctions.storeTagInDB(full_path, tagname, db_conn, is_system_tag=1)
def Downloadfile(url):
infoMeta = []
file_name = url.split('/')[-1]
infoMeta.append(file_name)
u = urllib2.urlopen(url)
meta = u.info()
infoMeta.append(meta.headers)
doc = u.read()
f = open(file_name, 'wb')
f.write(doc)
with open(file_name, 'rb') as p:
# Slurp the whole file and efficiently convert it to hex all at once
hexdata = binascii.hexlify(p.read())
# use hachoir to add the standard metadata
filename = './' + file_name
print filename
filename, realname = unicodeFilename(filename), filename
parser = createParser(filename)
try:
metalist = metadata.extractMetadata(parser).exportPlaintext()
infoMeta.append(metalist[1:4])
except Exception:
infoMeta.append(["none", "none", "none"])
p.close()
# print "Done", file_name, " Info is ", infoMeta
return file_name, hexdata
def extract_metadata(parser):
if not parser:
logger.error("Unable to create parser.\n")
return None
try:
metadata = extractMetadata(parser)
except HachoirError, err:
logger.error("stream error! %s\n" % unicode(err))
return None
def extract_metadata(parser):
if not parser:
logger.error("Unable to create parser.\n")
return None
try:
metadata = extractMetadata(parser)
except HachoirError, err:
logger.error("stream error! %s\n" % unicode(err))
return None
def metadata_map(filename):
filename, realname = filename, filename
test= filename.split('/')
if test[-1][0]==u'.' or test[-1][0] == '.':
return None
parser = createParser(filename)
# See what keys you can extract
if parser:
return metadata.extractMetadata(parser)._Metadata__data
return None
def metadata(objeto, key):
uid = objeto.UID()
registry = getUtility(IRegistry)
global_settings = registry.forInterface(IStreamingSettings)
path = global_settings.path
file = path + uid + "_video.flv"
parser = createParser(unicode(file))
if parser is not None:
metadata = extractMetadata(parser)
if metadata is not None:
if metadata.has(key):
return metadata.get(key)
return None
def GetSongName(self,songDir):
parser = createParser(songDir)
print parser
meta=""
# See what keys you can extract
for k,v in metadata.extractMetadata(parser)._Metadata__data.iteritems():
if v.values:
print v.key, v.values[0].value
if v.key=="title":
return v.values[0].value
def Create_Albums(self,path):
print path
print "Sucess!!"
mypath=path
self.music_List.DeleteAllItems()
self.music_il.RemoveAll()
dAlbums={}
dArtists={}
f = []
for (dirpath, dirnames, filenames) in walk(mypath):
for i in filenames:
f.append(dirpath+"\\"+i)
filename=dirpath+"\\"+i
#filename, realname = unicodeFilename(filename), filename
if filename[-3:]=="mp3":
parser = createParser(filename)
print parser
meta=""
# See what keys you can extract
for k,v in metadata.extractMetadata(parser)._Metadata__data.iteritems():
if v.values:
print v.key, v.values[0].value
if v.key=="album":
if not (dAlbums.has_key(v.values[0].value)):
dAlbums[v.values[0].value]=[]
dAlbums[v.values[0].value].append(filename)
#meta=meta+str(v.key)+":"+str(v.values[0].value)+"\n"
"""
if v.key=="author":
if not (dArtists.has_key(v.values[0].value)):
dArtists[v.values[0].value]=[]
dArtists[v.values[0].value].append(filename)
"""
print dAlbums
#print dArtists
self.dAlbums=dAlbums
#self.dArtists=dArtists
jsonarray1 = json.dumps(dAlbums)
#jsonarray2 = json.dumps(dArtists)
f=open("Jsonfile.json",'wb')
f.write(jsonarray1)
#f.write(jsonarray2)
self.Create_Albums_List(dAlbums)
self.music_player_panel.Refresh()
self.music_player_panel.Layout()
def file_metadata(filename):
if filename and filename != "":
parser = createParser(unicodeFilename(filename), filename)
meta = metadata.extractMetadata(parser) if parser else None
metalist = meta.exportPlaintext() if meta else []
meta = collections.defaultdict(collections.defaultdict)
for item in metalist:
if item.endswith(":"):
k = item[:-1]
else:
tag, value = item.split(": ", 1)
tag = tag[2:]
meta[k][tag] = value
return unicode_to_string(
default_to_regular(meta))["Metadata"] if meta else {}
def downloadBINARY(url):
###########################################################
# USE TO DOWNLOAD A BINARY FILE LIKE DOC OR XLS #
# INPUT: the url of the file. #
# OUTPUT: the hex of the file, and list of some metadata, #
# from the server and from a hachoir_metadata scan #
# SAVES FILE TO: downloaded_docs/doc, or xls/filename #
###########################################################
infoMeta=[]
file_name = url.split('/')[-1]
file_type = file_name.split(".")[-1]
base_dir = os.path.abspath("../../../downloaded_docs/")
download_dir = os.path.join(base_dir, file_type)
infoMeta.append(file_type)
infoMeta.append(file_name)
u = urllib2.urlopen(url)
meta = u.info()
infoMeta.append(meta.headers)
doc= u.read()
f = open(os.path.join(download_dir,file_name), 'wb')
f.write(doc)
with open(os.path.join(download_dir,file_name), 'rb') as p:
# Slurp the whole file and convert it to hex all at once
hexdata = binascii.hexlify(p.read())
# use hachoir to add the standard metadata
filename = download_dir+ '/'+file_name
print filename
# filename = unicodeFilename(filename), filename
filename, realname = unicodeFilename(filename), filename
parser = createParser(filename)
try:
metalist = metadata.extractMetadata(parser).exportPlaintext()
infoMeta.append(metalist[1:4])
except Exception:
infoMeta.append(["none","none","none"])
p.close()
print "Done", file_name, " Saved to: ", download_dir
return hexdata, infoMeta
def Downloadfile(url):
#INPUT: the url of the file
#OUTPUT: file written to disk and the server metadata
infoMeta = []
file_name = url.split('/')[-1]
infoMeta.append(file_name)
u = urllib2.urlopen(url)
meta = u.info()
infoMeta.append(meta.headers)
doc = u.read()
f = open(file_name, 'wb')
f.write(doc)
# use hachoir to add the standard metadata
filename = './' + file_name
filename, realname = unicodeFilename(filename), filename
parser = createParser(filename)
try:
metalist = metadata.extractMetadata(parser).exportPlaintext()
infoMeta.append(metalist[1:4])
except Exception:
infoMeta.append(["none", "none", "none"])
p.close()
return file_name, infoMeta
# from collections import defaultdict # from pprint import pprint from hachoir_metadata import metadata from hachoir_core.cmd_line import unicodeFilename from hachoir_parser import createParser filename = './hsu-contributions.xls' filename, realname = unicodeFilename(filename), filename parser = createParser(filename) metalist = metadata.extractMetadata(parser).exportPlaintext() print metalist[1:4]
def extract(filename):
"""Extract the metadata from the media file"""
from hachoir_parser.guess import createParser
from hachoir_metadata.metadata import extractMetadata
from hachoir_core.error import HachoirError
from hachoir_core.stream import InputStreamError
filename = unicode(filename)
try:
parser = createParser(filename)
except InputStreamError, err:
logger.warning("Stream error! %s" % unicode(err))
return None
if not parser:
logger.warning("Unable to create parser.")
return None
try:
metadata = extractMetadata(parser)
except HachoirError, err:
logger.warning("Stream error! %s" % unicode(err))
return None
if metadata is None:
logger.warning("unable to extract metadata.")
return None
return metadata
from collections import defaultdict
from pprint import pprint
from hachoir_metadata import metadata
from hachoir_core.cmd_line import unicodeFilename
from hachoir_parser import createParser
# using this example http://archive.org/details/WorkToFishtestwmv
filename = 'YouKnowMyName-ChrisCornell-JamesBondCasinoRoyale.mp3'
filename, realname = unicodeFilename(filename), filename
parser = createParser(filename)
# See what keys you can extract
for k,v in metadata.extractMetadata(parser)._Metadata__data.iteritems():
if v.values:
print v.key, v.values[0].value
# Turn the tags into a defaultdict
#metalist = metadata.extractMetadata(parser).exportPlaintext()
#meta = defaultdict(defaultdict)
#for item in metalist:
# if item.endswith(':'):
# k = item[:-1]
# else:
# tag, value = item.split(':')
# tag = tag[2:]
# meta[k][tag] = value
#print meta['Video stream #1']['Image width'] # 320 pixels
def fs_walk(cwd, fs):
global FLIST
try:
directory = fs.open_dir(cwd)
except IOError as e:
print "ERROR: Unable to open directory, path not found - %s" % cwd
return
for f in directory:
if f.info.name.name != '.' and f.info.name.name != '..':
ftype = f.info.meta.type
fname = os.path.join(cwd,f.info.name.name)
# The file is just a regular file, as opposed to a directory
if ftype == pytsk3.TSK_FS_META_TYPE_REG:
# Sample of how to carve a file with pytsk3 is at the link
# below. I walked through that example and adapted my own
# file carver.
#
# https://code.google.com/p/pytsk/wiki/OverView
fi = fs.open_meta(f.info.meta.addr)
data = ''
offs = 0
size = fi.info.meta.size
BUFF_SIZE = 1024*1024
# Recunstruct the file from the inodes
while offs < size:
atr = min(BUFF_SIZE, size - offs)
d = fi.read_random(offs, atr)
if not d: break
offs += len(d)
data += d
# Write the file out to ./recovered/
fname = os.path.join("./recovered",fname.split('/')[-1])
fout = open(fname, 'w')
fout.write(data)
fout.close()
# Get the metadata for the file
meta_dict = {}
fmime = set()
try:
parser = createParser(unicode(fname, errors='replace'), fname)
fmime = fmime.union(parser.mime_type.split('/'))
except Exception as e:
pass
# File was a "PDF"
#
# Code was taken from Marc Budofsky's pdf.py file.
if 'pdf' in fmime:
try:
pdf = pyPdf.PdfFileReader(file(fname, 'rb'))
info = pdf.getDocumentInfo()
for item, dat in info.items():
try: meta_dict[item] = pdf.resolvedObjects[0][1][item]
except:meta_dict[item] = dat
except: pass
# File was a type of image
elif 'image' in fmime:
plain = metadata.extractMetadata(parser).exportPlaintext()
for p in plain:
meta_dict[p.split(":")[0]] = p.split(":")[1]
# If the file was specifically a PNG, JPG, or GIF, get the exif data
#
# This code segment was more or less taken from Marc Budofsky's exif.py
# example. It was modified to fit my setting, but the concept is the same.
if fmime.intersection(EXIF_IMG) != set():
try:
info = Image.open(fname)._getexif()
for t, v in info.items():
dec = TAGS.get(t, t)
meta_dict[dec] = v
except Exception as e: pass
# File was neither of these, so delete it and continue
else:
os.remove(fname)
continue
# Append all of the file information to our global list
meta = json.dumps(meta_dict)
FLIST.append((fname.split('/')[-1], hashlib.md5(data).hexdigest(), meta))
elif ftype == pytsk3.TSK_FS_META_TYPE_DIR: fs_walk(fname, fs)
else: pass
from collections import defaultdict
from pprint import pprint
from hachoir_metadata import metadata
from hachoir_core.cmd_line import unicodeFilename
from hachoir_parser import createParser
import re
# using this example
filename = 'Bobs.Burgers.s03e01.Ear-sy.Rider.mkv'
filename, realname = unicodeFilename(filename), filename
parser = createParser(filename)
# See what keys you can extract
for k, v in metadata.extractMetadata(parser)._Metadata__data.iteritems():
if v.values:
print v.key, v.values[0].value
#else:
# print k, v.key, v.values
# Turn the tags into a defaultdict
metalist = metadata.extractMetadata(parser).exportPlaintext()
meta = defaultdict(defaultdict)
for item in metalist:
if item.endswith(':'):
k = item[:-1]
else:
tag, value = item.split(': ', 1)
tag = tag[2:]
meta[k][tag] = value
def extract(filename):
"""Extract the metadata from the media file"""
from hachoir_parser.guess import createParser
from hachoir_metadata.metadata import extractMetadata
from hachoir_core.error import HachoirError
from hachoir_core.stream import InputStreamError
filename = unicode(filename)
try:
parser = createParser(filename)
except InputStreamError, err:
logger.warning("Stream error! %s" % unicode(err))
return None
if not parser:
logger.warning("Unable to create parser.")
return None
try:
metadata = extractMetadata(parser)
except HachoirError, err:
logger.warning("Stream error! %s" % unicode(err))
return None
if metadata is None:
logger.warning("unable to extract metadata.")
return None
return metadata
def extract(self):
self.textbox.delete(1.0, Tkinter.END)
self.textbox.update_idletasks()
file_type=file_path.split('.')[1] #splits the file path to determine what type of file was selected
for case in switch(file_type): #python version of case statement that switch class - created above - allows
#if the file is a pdf do the following
if case('pdf'):
print "You chose to retrieve PDF metadata."
fileName=file_path
pdfFile = PdfFileReader(file(fileName, 'rb')) #opens the pdf file
docInfo = pdfFile.getDocumentInfo() #extracts document info for the pdf
pdfMeta='[*] PDF MetaData For: ' + str(fileName)+"\n"
for metaItem in docInfo:
pdfMeta+="[+] "+metaItem+": "+docInfo[metaItem]+"\n"
#inserts the metadata into the text box
self.textbox.insert(END, pdfMeta)
self.textbox.update_idletasks()
break
#if the file is a mp4 do the following
if case('mp4'):
print "You chose to retrieve Video File metadata."
filename = file_path
filename, realname = unicodeFilename(filename), filename
parser = createParser(filename) #creates a parser for the mp4 file
vidMeta="[*] Video MetaData For: "+file_path+"\n"
for k,v in metadata.extractMetadata(parser)._Metadata__data.iteritems(): #extracts and iterates through the metadata of the mp4
if v.values:
vidMeta+="[+] "+str(v.key)+": "+str(v.values[0].value)+"\n"
#inserts the metadata into the text box
self.textbox.insert(END, vidMeta)
self.textbox.update_idletasks()
break
#if file is a jpeg do the following
if case('jpg') or case('JPG'):
print "You chose to retrieve Image File metadata."
imgFileName=file_path
immetfile=open("imageMetadata.txt", "w+") #creates file to hold image metadata
for (k,v) in Image.open(imgFileName)._getexif().iteritems(): #extracts metadata and iterates through the metadata
immet='%s = %s'%(TAGS.get(k), v)
immetfile.write(immet+'\n') #writes metadata to the file created above
self.textbox.insert(END, "The metadata for this file can be found in: imageMetadata.txt")
self.textbox.update_idletasks()
break
#if file is a mp3 do the following
if case('mp3'):
print "You chose to retrieve Audio File metadata."
afile=file_path
audiofile=open(afile, "rb") #open mp3 in raw binary format
mdfile=open("audioMetadata.txt", "w+") #create a file to hold audio metadata
print "Decoding mp3 file"
md=audiofile.read(1500) #reads in first 1500 bytes in audio file
metad=repr(md) #creates a string representation of the raw binary
audMeta="[*] Audio MetaData For: "+file_path+"\n"
#specifies the mp3 metadata tags and their meaning and list of bytes to be removed
mp3TagList={"AENC":"Audio Encryption", "APIC":"Attached Picture", "COMM":"Comments", "COMR":"Commercial Frame", "ENCR":"Encryption method registration", "EQUA":"Equalisation", "ETCO":"Event timing codes", "GEOB":"General Encapsulated Object", "GRID":"Group Identification Registration", "IPLS":"Involoved People list", "LINK":"Linked Information", "MCDI":"Music CD Identifier", "MLLT":"MPEG Location Lookup Table", "OWNE":"Ownership Frame", "PRIV":"Private Frame", "PCNT":"Play COunter", "POPM":"Popularimeter", "POSS":"Position Synchronisation Frame", "RBUF":"Recommended Buffer Size", "RVAD":"Relative Volume Adjustment", "RVRB":"Reverb", "SYLT":"Synchronised Lyric/Text", "SYTC":"Synchronised Tempo Codes", "TALB":"Album", "TBPM":"Beats Per Minute", "TCOM":"Composer", "TCON":"Content Type", "TCOP":"Copyright Message", "TDAT":"Date", "TDLY":"Playlist Delay", "TENC":"Encoded By", "TEXT":"Lyricist/Text Writer", "TFLT":"File Type", "TIME":"Time", "TIT1":"Content Group Description", "TIT2":"Title", "TIT3":"Subtitle", "TKEY":"Initial Key", "TLAN":"Language", "TLEN":"Length", "TMED":"Media Type", "TOAL":"Original Album", "TOFN":"Original Filename", "TOLY":"Original Lyricist/Text Writer", "TOPE":"Original Artist", "TORY":"Original Release Year", "TOWN":"File Owner", "TPE1":"Lead Performer", "TPE2":"Band Accompaniment", "TPE3":"Conductor", "TPE4":"Interpreted By", "TPOS":"Part of a Set", "TPUB":"Publisher", "TRCK":"Track Number", "TRDA":"Recording Dates", "TRSN":"Internet Radio Station Name", "TRSO":"Internet Radio Station Owner", "TSIZ":"Size", "TSRC":"International Standard Recording Code", "TSSE":"Software/Hardware and settings used for encoding", "TYER":"Year", "TXXX":"User defined test information frame", "UFID":"Unique File Indentifier", "USER":"******", "USLT":"Unsynchronised Lyric Transcription", "WCOM":"Commercial Information", "WCOP":"Copyright Information", "WOAF":"Official audio file webpage", "WOAR":"Official artist/performer webpage", "WOAS":"Official audio source webpage", "WORS":"Official internet radio station homepage", "WPAY":"Payment", "WPUB":"Publishers official webpage", "WXXX":"User defined URL link frame"}
byteList=["\\x00","\\x01","\\x02","\\x03","\\x04","\\x05","\\x06","\\x07",
"\\x08","\\x09","\\x0a","\\x0b","\\x0c","\\x0d","\\x0e","\\x0f"]
#iterates through metadata removing the bytes specified above
for byte in byteList:
metad=metad.replace(byte, '')
#iterates through list of tags specified above
for tag,meaning in mp3TagList.iteritems():
tagPos=metad.find(tag) #looks for tags specified above
if tagPos>0: #if tag is found
metad=metad[:tagPos]+'\n'+metad[tagPos:] #places a new line just before the tag's position in file
metad=metad.replace(tag, meaning) #replaces the tag with it's associated meaning
mdfile.write(metad) #writes metadata to the file created above
#inserts metadata into text box
self.textbox.insert(END, metad)
self.textbox.update_idletasks()
break
#if file is a microsoft office document do the following
if case('docx') or case('pptx') or case('xlsx'):
print "You chose to retrieve Microsoft Office Documents metadata."
docfile=file_path
zfile=zipfile.ZipFile(docfile) #open document as a zip file
xml=ET.XML(zfile.read('docProps/core.xml')) #convert the contents of core.xml into xml
xml=ET.tostring(xml) #turn xml into a string
#pretty print the xml i.e. each tag on a new line and tabbed in
xml=xmlDOM.parseString(xml)
docMeta=xml.toprettyxml()
#insert metadata into text box
self.textbox.insert(END, docMeta)
self.textbox.update_idletasks()
break
from collections import defaultdict
from pprint import pprint
from hachoir_metadata import metadata
from hachoir_core.cmd_line import unicodeFilename
from hachoir_parser import createParser
import re
# using this example
filename = 'Bobs.Burgers.s03e01.Ear-sy.Rider.mkv'
filename, realname = unicodeFilename(filename), filename
parser = createParser(filename)
# See what keys you can extract
for k,v in metadata.extractMetadata(parser)._Metadata__data.iteritems():
if v.values:
print v.key, v.values[0].value
#else:
# print k, v.key, v.values
# Turn the tags into a defaultdict
metalist = metadata.extractMetadata(parser).exportPlaintext()
meta = defaultdict(defaultdict)
for item in metalist:
if item.endswith(':'):
k = item[:-1]
else:
tag, value = item.split(': ',1)
tag = tag[2:]
meta[k][tag] = value
def extract(self):
file_type=file_path.split('.')[1]
for case in switch(file_type):
if case('pdf'):
print "You chose to retrieve PDF metadata."
fileName=file_path
pdfFile = PdfFileReader(file(fileName, 'rb'))
docInfo = pdfFile.getDocumentInfo()
pdfMeta='[*] PDF MetaData For: ' + str(fileName)+"\n"
for metaItem in docInfo:
pdfMeta+="[+] "+metaItem+": "+docInfo[metaItem]+"\n"
self.labelVariable.set(pdfMeta)
break
if case('mp4'):
print "You chose to retrieve Video File metadata."
filename = file_path
filename, realname = unicodeFilename(filename), filename
parser = createParser(filename)
vidMeta="[*] Video MetaData For: "+file_path+"\n"
for k,v in metadata.extractMetadata(parser)._Metadata__data.iteritems():
if v.values:
#print v.key, v.values[0].value
vidMeta+="[+] "+str(v.key)+": "+str(v.values[0].value)+"\n"
self.labelVariable.set(vidMeta)
break
if case('jpg') or case('JPG'):
print "You chose to retrieve Image File metadata."
imgFileName=file_path
immetfile=open("imageMetadata.txt", "w+")
for (k,v) in Image.open(imgFileName)._getexif().iteritems():
immet='%s = %s'%(TAGS.get(k), v)
immetfile.write(immet+'\n')
self.labelVariable.set("The metadata for this file can be found in: imageMetadata.txt")
break
if case('mp3'):
print "You chose to retrieve Audio File metadata."
afile=file_path
audiofile=open(afile, "rb")
mdfile=open("audioMetadata.txt", "w+")
print "Decoding mp3 file"
md=audiofile.read(1500)
metad=repr(md)
audMeta="[*] Audio MetaData For: "+file_path+"\n"
mp3TagList={"AENC":"Audio Encryption", "APIC":"Attached Picture", "COMM":"Comments", "COMR":"Commercial Frame", "ENCR":"Encryption method registration", "EQUA":"Equalisation", "ETCO":"Event timing codes", "GEOB":"General Encapsulated Object", "GRID":"Group Identification Registration", "IPLS":"Involoved People list", "LINK":"Linked Information", "MCDI":"Music CD Identifier", "MLLT":"MPEG Location Lookup Table", "OWNE":"Ownership Frame", "PRIV":"Private Frame", "PCNT":"Play COunter", "POPM":"Popularimeter", "POSS":"Position Synchronisation Frame", "RBUF":"Recommended Buffer Size", "RVAD":"Relative Volume Adjustment", "RVRB":"Reverb", "SYLT":"Synchronised Lyric/Text", "SYTC":"Synchronised Tempo Codes", "TALB":"Album", "TBPM":"Beats Per Minute", "TCOM":"Composer", "TCON":"Content Type", "TCOP":"Copyright Message", "TDAT":"Date", "TDLY":"Playlist Delay", "TENC":"Encoded By", "TEXT":"Lyricist/Text Writer", "TFLT":"File Type", "TIME":"Time", "TIT1":"Content Group Description", "TIT2":"Title", "TIT3":"Subtitle", "TKEY":"Initial Key", "TLAN":"Language", "TLEN":"Length", "TMED":"Media Type", "TOAL":"Original Album", "TOFN":"Original Filename", "TOLY":"Original Lyricist/Text Writer", "TOPE":"Original Artist", "TORY":"Original Release Year", "TOWN":"File Owner", "TPE1":"Lead Performer", "TPE2":"Band Accompaniment", "TPE3":"Conductor", "TPE4":"Interpreted By", "TPOS":"Part of a Set", "TPUB":"Publisher", "TRCK":"Track Number", "TRDA":"Recording Dates", "TRSN":"Internet Radio Station Name", "TRSO":"Internet Radio Station Owner", "TSIZ":"Size", "TSRC":"International Standard Recording Code", "TSSE":"Software/Hardware and settings used for encoding", "TYER":"Year", "TXXX":"User defined test information frame", "UFID":"Unique File Indentifier", "USER":"******", "USLT":"Unsynchronised Lyric Transcription", "WCOM":"Commercial Information", "WCOP":"Copyright Information", "WOAF":"Official audio file webpage", "WOAR":"Official artist/performer webpage", "WOAS":"Official audio source webpage", "WORS":"Official internet radio station homepage", "WPAY":"Payment", "WPUB":"Publishers official webpage", "WXXX":"User defined URL link frame"}
byteList=["\\x00","\\x01","\\x02","\\x03","\\x04","\\x05","\\x06","\\x07",
"\\x08","\\x09","\\x0a","\\x0b","\\x0c","\\x0d","\\x0e","\\x0f"]
for byte in byteList:
metad=metad.replace(byte, '')
for tag,meaning in mp3TagList.iteritems():
tagPos=metad.find(tag)
if tagPos>0:
metad=metad[:tagPos]+'\n'+metad[tagPos:]
metad=metad.replace(tag, meaning)
mdfile.write(metad)
self.labelVariable.set("The metadata for this file can be found in: audioMetadata.txt")
break
if case('docx') or case('pptx') or case('xlsx'):
print "You chose to retrieve Microsoft Office Documents metadata."
docfile=file_path
zfile=zipfile.ZipFile(docfile)
xml=ET.XML(zfile.read('docProps/core.xml'))
xml=ET.tostring(xml)
xml=xmlDOM.parseString(xml)
docMeta=xml.toprettyxml()
self.labelVariable.set(docMeta)
break
