def __init__(self, _device):
gtk.ListStore.__init__(self, gobject.TYPE_STRING, gobject.TYPE_STRING,
gobject.TYPE_UINT, gobject.TYPE_STRING,
gobject.TYPE_STRING, gobject.TYPE_STRING,
gobject.TYPE_STRING, gobject.TYPE_STRING,
gobject.TYPE_STRING, gobject.TYPE_UINT,
gobject.TYPE_STRING, gobject.TYPE_STRING,
gobject.TYPE_STRING, gobject.TYPE_PYOBJECT)
self.__filter_tracks = self.filter_new()
self.__filter_tracks.set_visible_func(self.__filter_type,
Metadata.TYPE_TRACK)
self.__filter_folders = self.filter_new()
self.__filter_folders.set_visible_func(self.__filter_folder)
self.__current_folder_id = None
tracks = []
# add all tracks
tracks_list = _device.get_track_listing()
for track_metadata in tracks_list:
assert type(track_metadata) is type(Metadata.Metadata())
self.append(track_metadata)
tracks.append(track_metadata.id)
# add other files (the ones which are not already registered as tracks)
file_list = _device.get_file_listing()
for file_metadata in file_list:
assert type(file_metadata) is type(Metadata.Metadata())
if not file_metadata.id in tracks:
self.append(file_metadata)
def fill(self):
# add playlists
for playlist in self._device.get_playlist_listing():
assert type(playlist) is type(Metadata.Metadata())
self.append(playlist)
for track in self._device.get_tracks_for_playlist(playlist):
assert type(track) is type(Metadata.Metadata())
track.parent_id = playlist.id
self.append(track)
def fill(self):
# add folder list
#FIXME: sort item so that parent is alway created before its childs
folder_list = self._device.get_folder_listing()
for dir in folder_list:
assert type(dir) is type(Metadata.Metadata())
self.append(dir)
def render_leftColumn(self, context):
return [
Metadata.Info(self.target),
LinksSection(self.target),
Graph.RelatedSection(self.target),
Info.Clock(),
]
def on_drag_data_received(self, treeview, drag_context, x, y, data, info, time):
if info == DND_EXTERN:
if DEBUG: debug_trace("extern drag and drop detected with data %s" % data.data, sender=self)
if data and data.format == 8: # 8 = type string
# find the row where data was dropped
selrow_metadata = None
drop_info = treeview.get_dest_row_at_pos(x, y)
if drop_info:
selrow_metadata = treeview.get_model().get_model().get_model().get_metadata(drop_info[0])
# process the list containing dropped objects
for uri in data.data.split('\r\n')[:-1]:
self.__gui.transfer_manager.send_file(uri, self.__gui.get_current_folder())
drag_context.drop_finish(success=True, time=time)
else:
drag_context.drop_finish(success=False, time=time)
elif info == DND_INTERN:
for m in data.data.split("&&"):
metadata = Metadata.decode_from_string(m)
if DEBUG: debug_trace("intern drag and drop detected with data %s" % metadata.to_string(), sender=self)
drag_context.drop_finish(success=True, time=time)
else:
drag_context.drop_finish(success=False, time=time)
if DEBUG: debug_trace("on_drag_data_received(): Unknow info value passed: %i" % info, sender=self)
assert False
def main(metadatafile):
""" Write a test metadata.xml file"""
# Create a Metadata Writer once with Tool Name and Version
mWriter = Metadata.MetadataWriter("Test Tool Name", "0.0")
## You can loop the following for a batch mode, or just once for a single tool run
# Create a "run", and start the processing clock
mWriter.createRun()
# Add Parameter Name and value for each Input
mWriter.currentRun.addParameter("Parameter Name 1", "Parameter Value 1")
mWriter.currentRun.addParameter("Parameter Name 2", "Parameter Value 2")
# Add Output Name and Value for each output
mWriter.currentRun.addOutput("Output Name 1", "Output Value 1")
mWriter.currentRun.addOutput("Output Name 2", "Output Value 2")
# Use addMessage to write messages to the file.
mWriter.currentRun.addMessage("Info", "Info Message Text")
mWriter.currentRun.addMessage("Warning", "Warning Message Text")
mWriter.currentRun.addMessage("Error", "Error Message Text")
# Use addCustomNode to write custom node tags to Information Node
mWriter.currentRun.addResult("CustomNode1", "CustomValue1")
mWriter.currentRun.addResult("CustomNode2", "CustomValue2")
# When Processing is complete, stop the clock
strToolStatus = "Success" # Optional status for the run
mWriter.finalizeRun(strToolStatus)
## Repeat this block for each run if in batch mode.
# At the very end, write the file. (Only do this at the very end if batching!)
mWriter.writeMetadataFile(metadatafile)
def append(self, metadata):
assert type(metadata) is type(Metadata.Metadata())
m = metadata
if DEBUG_LOCK: debug_trace("Requesting lock", sender=self)
self.__lock.acquire()
if DEBUG_LOCK: debug_trace("Lock acquired", sender=self)
parent = 0
if m.parent_id <> 0:
parent = self.__get_iter(m.parent_id)
if m.type == Metadata.TYPE_FOLDER:
row = [m.id, m.parent_id, m.title, "", 0, "folder", m]
else:
icon = "gtk-file"
if Metadata.TYPE_TRACK:
icon = "audio-x-generic"
row = [
m.id, m.parent_id, m.title,
util.format_filesize(m.filesize), m.filesize, icon, m
]
iter = gtk.TreeStore.append(self, parent, row)
self.__cache[m.id] = gtk.TreeRowReference(self, self.get_path(iter))
self.__lock.release()
if DEBUG_LOCK: debug_trace("Lock released", sender=self)
return iter
def create_playlist(self, playlist_name):
metadata = Metadata.Metadata()
metadata.id = playlist_name
metadata.title = playlist_name
metadata.filename = playlist_name
metadata.parent_id = 0
metadata.type = Metadata.TYPE_PLAYLIST
self.__queue_job(self.ACTION_CREATE_PLAYLIST, metadata)
def __init__(self, statements, database):
self.statementList = statements
self.data = []
global meta
meta = Metadata()
self.qlength = len(statements)
self.database = database
def __init__(self, object_id, action, status, metadata):
assert type(metadata) is type(Metadata.Metadata())
self.object_id = object_id
self.action = action
self.status = status
self.exception = None
self.progress = 0
self.metadata = metadata
def create_folder(self, folder_name, parent_id):
metadata = Metadata.Metadata()
metadata.id = folder_name
metadata.title = folder_name
metadata.filename = folder_name
metadata.parent_id = parent_id
metadata.type = Metadata.TYPE_FOLDER
self.__queue_job(self.ACTION_CREATE_FOLDER, metadata)
def on_drag_data_received(self, treeview, drag_context, x, y, data, info, time):
# find the row where data was dropped
selrow_metadata = None
drop_info = treeview.get_dest_row_at_pos(x, y)
if drop_info:
selrow_metadata = treeview.get_model().get_metadata(drop_info[0])
parent = selrow_metadata.id
if selrow_metadata.type != Metadata.TYPE_FOLDER and selrow_metadata.type != Metadata.TYPE_PLAYLIST:
parent = selrow_metadata.parent_id
if info == DND_EXTERN:
if DEBUG: debug_trace("extern drag and drop detected with data %s" % data.data, sender=self)
if data and data.format == 8: # 8 = type string
# process the list containing dropped objects
for uri in data.data.split('\r\n')[:-1]:
if self.__mode == MODE_PLAYLIST_VIEW:
next = None
if selrow_metadata.type == Metadata.TYPE_PLAYLIST_ITEM:
next = selrow_metadata.id
self.__gui.transfer_manager.send_extern_file_to_playlist(parent, uri, next)
else:
self.__gui.transfer_manager.send_file(uri, parent)
drag_context.drop_finish(success=True, time=time)
else:
drag_context.drop_finish(success=False, time=time)
return
if info == DND_INTERN:
for m in data.data.split("&&"):
metadata = Metadata.decode_from_string(m)
if DEBUG: debug_trace("intern drag and drop detected with data %s" % metadata.to_string(), sender=self)
if self.__mode == MODE_PLAYLIST_VIEW:
next = None
if selrow_metadata.type == Metadata.TYPE_PLAYLIST_ITEM:
next = selrow_metadata.id
if metadata.type == Metadata.TYPE_TRACK:
self.__gui.transfer_manager.add_track_to_playlist(parent, metadata, next)
elif metadata.type == Metadata.TYPE_PLAYLIST_ITEM:
if metadata.parent_id == selrow_metadata.id or metadata.parent_id == selrow_metadata.parent_id:
# move within playlist
self.__gui.transfer_manager.move_track_within_playlist(parent, metadata, next)
else:
# move between playlist
debug_trace("NOT IMPLEMENTED YET")
pass
else:
drag_context.drop_finish(success=False, time=time)
if DEBUG: debug_trace("An invalid object type was dropped: %i" % i, sender=self)
return
else:
pass #TODO: move file to dir
drag_context.drop_finish(success=True, time=time)
return
else:
drag_context.drop_finish(success=False, time=time)
if DEBUG: debug_trace("on_drag_data_received(): Unknow info value passed: %i" % info, sender=self)
assert False
def set_metadata(self, mid='tmd_id', src_tbl= '', title='metadata', kind='workbook', msg="Mapping Target to Metadata for "):
"""
Function to set metadata that maps source data elements to target data elements.
:param mid: name of metadata id to reference in the source MDE metadata dictionary.
:type mid: str
:param kind: Type of source in which the catalog (data to map) resides in.
:type kind: str
:param src_tbl: name of the table where the source-target data resides in.
:type src_tbl: str
:param title: name of the target file to map data elements from/to.
:type title: str
:return Boolean: True/False
:rtype Boolean: Boolean
"""
try:
if not src_tbl: src_tbl = self.attrs['mde']['crawler']['tbl'].lower()
if self.attrs['log']: print(msg, src_tbl, " in ", self.attrs['mdd'])
if re.search(str(title), self.objs[kind].attrs['title']):
self.objs['workbook'].set_workbook()
self.objs['df'] = self.objs[kind].get_sheet_body(src_tbl.lower())
if self.objs['df'].empty: print(" No Context found to Metadata in ", src_tbl)
else: self.attrs['dict'] = self.objs['df'].set_index('sde',drop=False).T.to_dict('dict')
else: print(' ', title, ' does not exists or it is not a ', kind)
if not self.objs['df'].empty:
des = self.objs['df']["tde"].tolist()
des.sort()
self.attrs['mde']['src'][mid] = int(hashlib.md5("".join(des).encode('utf-8')).hexdigest(), 16)
self.attrs['id'] = self.attrs['mde']['src'][mid]
print(self.objs['df'].head(10), '\n Target Data Elements: ', len(des), '\n ID: ', self.attrs['id'])
self.objs['src_map_metadata'] = Metadata(name=self.attrs['src_mdd'],mid=str(self.get('src', 'smd_id')))
self.objs['metadata'] = Metadata(name=self.attrs['mdd'], mid=str(self.attrs['id']))
else: print("\t", "ERROR! MISSING DATA!")
except Exception as e: print(e, "\n\t", "ERROR! ", msg, src_tbl)
return len(self.attrs['dict']) > 0
def from_path(cls, path):
'''
Create new sample object from audio file path by retrieving metadata.
:param path:
:return:
'''
sr, channels, duration = Metadata.get_audio_metadata(path)
return cls(path, sr, channels, duration)
def __init__(self, tbldata, tblname):
global md
md = Metadata()
self.database = {}
self.tbldata = tbldata
self.tblname = tblname
self.clean_data = {}
self.getPrimary()
self.addToHash()
def __queue_job(self, job_type, metadata):
assert type(metadata) is type(Metadata.Metadata())
job = Job(metadata.id, job_type, self.STATUS_QUEUED, metadata)
self.__queue.put_nowait(job)
self.__model.append(job.get_list())
trace("queued file %s for %s" % (job.object_id, job.action), sender=self)
self.__notebook.set_current_page(1)
def send_file(self, file_url):
if DEBUG: debug_trace("request for sending %s" % file_url, sender=self)
url = urlparse(file_url)
if url.scheme == "file":
path = url2pathname(url.path)
metadata = Metadata.get_from_file(path)
self.__queue_job(path, self.ACTION_SEND, metadata)
else:
notify_warning("%s is not a file" % file_url)
def __convert_file_url_to_metadata(self, file_url):
url = urlparse(file_url)
if url.scheme == "file":
path = url2pathname(url.path)
metadata = Metadata.get_from_file(path)
return metadata
else:
notify_warning("%s is not a file" % file_url)
return None
def __convert_file_url_to_metadata(self, file_url):
url = urlparse(file_url)
if url.scheme == "file":
path = url2pathname(url.path)
metadata = Metadata.get_from_file(path)
return metadata
else:
notify_warning("%s is not a file" % file_url)
return None
def __get_file_metadata(self, file_id):
file = self.FILE_LISTING[file_id]
m = Metadata()
m.id = str(file_id)
m.type = TYPE_FILE
m.parent_id = str(file[1])
m.filename = file[2]
m.title = file[2]
return m
def init_elements(self, metadataFile, csvFile, ncOutput):
self.ncOutput = ncOutput
self.ncOutput = Checker().check_source(metadataFile, csvFile, ncOutput)
self.metadata = Metadata(metadataFile)
self.metadataData = self.metadata.get_metadata()
self.data = Data(csvFile)
self.ncOutput = self.ncOutput + self.metadata.get_global_attributes(
).get_id() + ".nc"
self.version = self.metadata.get_global_attributes(
).get_netcdf_version()
self.temporalAppendPosition = {}
self.globalAttributes = Metadata(metadataFile).get_global_attributes()
self.dimensions = self.metadata.get_dimensions()
self.naming_authority = self.globalAttributes.attributesList[
'naming_authority']
if self.naming_authority == 'EGO':
self.data_ego = Data_ego(csvFile)
self.ego_standard_metadata = EgoReaderStandardMetadata()
self.dimensionsEgo = self.ego_standard_metadata.get_dimensions()
self.metadata.change_variable()
def get_file_listing(self):
listing = []
try:
listing = self.__MTPDevice.get_filelisting()
files = []
for file in listing:
m = Metadata.get_from_MTPFile(file)
files.append(m)
return files
except pymtp.CommandFailed:
raise DeviceEngine.UnknowError(ERRMSG_UNKNOW)
return None
def __init__(self, _device):
gtk.TreeStore.__init__(self, gobject.TYPE_STRING, gobject.TYPE_STRING,
gobject.TYPE_STRING, gobject.TYPE_STRING,
gobject.TYPE_UINT, gobject.TYPE_STRING,
gobject.TYPE_PYOBJECT)
self.__cache = {}
# lock to prevent more thread for updating the model at the same time
self.__lock = Lock()
# add folder list
#FIXME: sort item so that parent is alway created before its childs
folder_list = _device.get_folder_list()
for dir in folder_list:
assert type(dir) is type(Metadata.Metadata())
self.append(dir)
# add file list
file_list = _device.get_filelisting()
for file_metadata in file_list:
assert type(file_metadata) is type(Metadata.Metadata())
self.append(file_metadata)
def get_file_listing(self):
listing = []
try:
listing = self.__MTPDevice.get_filelisting()
files = []
for file in listing:
m = Metadata.get_from_MTPFile(file)
files.append(m)
return files
except pymtp.CommandFailed:
raise DeviceEngine.UnknowError(ERRMSG_UNKNOW)
return None
def get_playlist_listing(self):
listing = []
#FIXME: Cache listing
try:
listing = self.__MTPDevice.get_playlists()
playlists = []
for playlist in listing:
m = Metadata.get_from_MTPPlaylist(playlist)
playlists.append(m)
return playlists
except pymtp.CommandFailed:
raise DeviceEngine.UnknowError(ERRMSG_UNKNOW)
return None
def append(self, metadata):
assert type(metadata) is type(Metadata.Metadata())
parent = self.__get_iter(metadata.parent_id)
row = [
metadata.id, metadata.parent_id, metadata.title,
metadata.get_icon(), metadata
]
next_object = self.__get_iter(metadata.next_object)
if next_object:
iter = gtk.TreeStore.insert_before(self, parent, next_object, row)
else:
iter = gtk.TreeStore.append(self, parent, row)
return False # needed by idle_add
def get_track_listing(self):
listing = []
#FIXME: Cache listing
try:
listing = self.__MTPDevice.get_tracklisting()
tracks = []
for track in listing:
m = Metadata.get_from_MTPTrack(track)
tracks.append(m)
return tracks
except pymtp.CommandFailed:
raise DeviceEngine.UnknowError(ERRMSG_UNKNOW)
return None
def get_filelisting(self):
listing = []
try:
listing = self.__MTPDevice.get_filelisting()
files = []
for file in listing:
m = Metadata.get_from_MTPFile(file)
files.append(m)
return files
except pymtp.CommandFailed:
raise DeviceEngine.UnknowError("The device returned an unknow error") #TRANSLATE
except Exception, exc:
raise exc
def get_folder_list(self):
listing = []
try:
listing = self.__MTPDevice.get_folder_list().values()
folders = []
for folder in listing:
m = Metadata.get_from_MTPFolder(folder)
folders.append(m)
return folders
except pymtp.CommandFailed:
raise DeviceEngine.UnknowError("The device returned an unknow error") #TRANSLATE
except Exception, exc:
raise exc
def get_tracklisting(self):
listing = []
try:
listing = self.__MTPDevice.get_tracklisting()
tracks = []
for track in listing:
m = Metadata.get_from_MTPTrack(track)
tracks.append(m)
return tracks
except pymtp.CommandFailed:
raise DeviceEngine.UnknowError("The device returned an unknow error") #TRANSLATE
except Exception, exc:
raise exc
def get_folder_listing(self):
listing = []
#FIXME: Cache listing
try:
listing = self.__MTPDevice.get_folder_list().values()
folders = []
for folder in listing:
m = Metadata.get_from_MTPFolder(folder)
folders.append(m)
return folders
except pymtp.CommandFailed:
raise DeviceEngine.UnknowError(ERRMSG_UNKNOW)
return None
def get_playlist_listing(self):
listing = []
#FIXME: Cache listing
try:
listing = self.__MTPDevice.get_playlists()
playlists = []
for playlist in listing:
m = Metadata.get_from_MTPPlaylist(playlist)
playlists.append(m)
return playlists
except pymtp.CommandFailed:
raise DeviceEngine.UnknowError(ERRMSG_UNKNOW)
return None
def get_track_listing(self):
listing = []
#FIXME: Cache listing
try:
listing = self.__MTPDevice.get_tracklisting()
tracks = []
for track in listing:
m = Metadata.get_from_MTPTrack(track)
tracks.append(m)
return tracks
except pymtp.CommandFailed:
raise DeviceEngine.UnknowError(ERRMSG_UNKNOW)
return None
def get_folder_listing(self):
listing = []
#FIXME: Cache listing
try:
listing = self.__MTPDevice.get_folder_list().values()
folders = []
for folder in listing:
m = Metadata.get_from_MTPFolder(folder)
folders.append(m)
return folders
except pymtp.CommandFailed:
raise DeviceEngine.UnknowError(ERRMSG_UNKNOW)
return None
def get_playlist_listing(self):
playlists = []
for id in self.PLAYLIST_LISTING.keys():
playlist = self.PLAYLIST_LISTING[id]
m = Metadata()
m.id = str(id)
m.parent_id = str(playlist[0])
m.type = TYPE_PLAYLIST
m.filename = str(playlist[1])
m.title = str(playlist[1])
playlists.append(m)
return playlists
def get_folder_listing(self):
folders = []
for id in self.FOLDER_LISTING.keys():
folder = self.FOLDER_LISTING[id]
m = Metadata()
m.id = str(id)
m.parent_id = str(folder[0])
m.type = TYPE_FOLDER
m.filename = folder[1]
m.title = folder[1]
folders.append(m)
return folders
def loop(dataset, id_file, id_list, results, window_data):
""" Main loop og the program. Takes an input from the user and produces the result. """
n = raw_input('Enter command: ').split(' ', 1)
if n[0] == 'statistic':
try:
Results.process_result_request(n[1], results)
except IndexError:
print 'Enter a statistic to request. (\'help\' for more details)'
elif n[0] == 'generate':
try:
Graph.process_graph_request(n[1], results, window_data)
except IndexError:
print 'Enter a graph to request. (\'help\' for more details)'
elif n[0] == 'load':
id_list = LoadData.load_ids(dataset + '/' + id_file)
results = LoadData.calculate_results(id_list, dataset, LoadData.calculate_times(id_list, dataset))
elif n[0] == 'subset_startend':
results = LoadData.calculate_results(id_list, dataset, LoadData.parse_subset(n[1]))
elif n[0] == 'subset_ids':
id_list = LoadData.parse_ids(n[1])
results = LoadData.calculate_results(id_list, dataset, LoadData.calculate_times(id_list, dataset))
elif n[0] == 'dataset':
try:
dataset = 'datasets/' + n[1]
id_list = LoadData.load_ids(dataset + '/' + id_file)
except IndexError:
print 'Enter a new dataset. (\'help\' for more details)'
elif n[0] == 'file':
try:
id_file = n[1]
id_list = LoadData.load_ids(dataset + '/' + id_file)
except IndexError:
print 'Enter a new starting file. (\'help\' for more details)'
elif n[0] == 'meta':
try:
Metadata.process_meta(n[1])
except IndexError, IOError:
print 'Enter a crawdad_xml_file. (\'help\' for more details)'
def __get_file_metadata(self, file_id):
file=self.FILE_LISTING[file_id]
m = Metadata()
m.id = str(file_id)
m.type = TYPE_FILE
m.parent_id = str(file[1])
m.filename = file[2]
m.title = file[2]
return m
def send_track(self, metadata=None, callback=None):
parent = metadata.parent_id
try:
new_id =self.__MTPDevice.send_track_from_file( metadata.path, metadata.filename, metadata.to_MTPTrack(), int(parent), callback=callback)
# read metadata again, because they can be changed by the device (i.e. parent_id or paraneter not handled)
metadata = Metadata.get_from_MTPTrack(self.__MTPDevice.get_track_metadata(new_id))
except IOError:
raise IOError("Failed to process the file from the filesystem") #TRANSLATE
except pymtp.CommandFailed:
if not self.__check_free_space(metadata.filesize):
raise DeviceEngine.DeviceFullError(ERRMSG_DEVICE_FULL)
if self.__file_exist(metadata.filename):
raise DeviceEngine.AlreadyOnDeviceError(ERRMSG_ALREADY_EXIST)
else:
raise DeviceEngine.UnknowError(ERRMSG_UNKNOW)
return metadata
def send_track(self, metadata=None, callback=None):
parent = int(metadata.parent_id)
try:
new_id =self.__MTPDevice.send_track_from_file( metadata.path, metadata.filename, metadata.to_MTPTrack(), parent, callback=callback)
# read metadata again, because they can be changed by the device (i.e. parent_id or paraneter not handled)
metadata = Metadata.get_from_MTPTrack(self.__MTPDevice.get_track_metadata(new_id))
except IOError:
raise IOError("Failed to process the file from the filesystem") #TRANSLATE
except pymtp.CommandFailed:
if not self.__check_free_space(metadata.filesize):
raise DeviceEngine.DeviceFullError("Not enought free space on device") #TRANSLATE
if self.__file_exist(metadata.filename):
raise DeviceEngine.AlreadyOnDeviceError("Already exists on the device") #TRANSLATE
else:
raise DeviceEngine.UnknowError("The device returned an unknow error") #TRANSLATE
except Exception, exc:
raise exc
def get_tracks_for_playlist(self, playlist):
tracks = []
#FIXME: Cache listing
try:
playlist = self.__MTPDevice.get_playlist(int(playlist.id))
for track_id in playlist:
track = self.__MTPDevice.get_track_metadata(track_id) #FIXME: Cache file listing and get from ther
m = Metadata.get_from_MTPTrack(track)
m.type = Metadata.TYPE_PLAYLIST_ITEM
m.parent = playlist
tracks.append(m)
return tracks
except pymtp.CommandFailed:
raise DeviceEngine.UnknowError(ERRMSG_UNKNOW)
except pymtp.ObjectNotFound:
if DEBUG: debug_trace("WARNING: a track is referenced in playlist but does not exist!", sender=self)
return tracks
def get_folder_listing(self):
folders=[]
for id in self.FOLDER_LISTING.keys():
folder = self.FOLDER_LISTING[id]
m = Metadata()
m.id = str(id)
m.parent_id = str(folder[0])
m.type = TYPE_FOLDER
m.filename = folder[1]
m.title = folder[1]
folders.append(m)
return folders
def get_playlist_listing(self):
playlists=[]
for id in self.PLAYLIST_LISTING.keys():
playlist=self.PLAYLIST_LISTING[id]
m = Metadata()
m.id = str(id)
m.parent_id = str(playlist[0])
m.type = TYPE_PLAYLIST
m.filename = str(playlist[1])
m.title = str(playlist[1])
playlists.append(m)
return playlists
def checkMatch(tblname,typeop,column,data,datahash,index):
results=[]
#meta.getAllColumns(tblname)
meta=Metadata()
columns=[]
fcol=[]
datatypes=[]
fdatatypes=[]
for i in range(0,len(tblname)):
columns=meta.getAllColumns(tblname[i])
fcol=fcol+columns
datatypes=meta.getAllDatatypes(tblname[i])
fdatatypes=fdatatypes+datatypes
if typeop == 1:
for i in range(0,len(datahash)):
index1=fcol.index(column)
if fdatatypes[index1] == "int":
if datahash[i][index1] < int(data):
results.append(datahash[i])
elif fdatatypes[index1] == "numeric":
if datahash[i][index1] < float(data):
results.append(datahash[i])
elif fdatatypes[index1] == 'varchar':
print("Can't compare strings!")
elif fdatatypes[index1] == 'date':
date1=str(datahash[i][index1])
date2=str(data);
newdate1 = time.strptime(date1,'%d-%m-%Y')
newdate2 = time.strptime(date2,'%d-%m-%Y')
if newdate1 < newdate2:
results.append(datahash[i])
elif typeop == 2:
for i in range(0,len(datahash)):
index1=fcol.index(column)
if fdatatypes[index1] == "int":
if datahash[i][index1] > int(data):
results.append(datahash[i])
elif fdatatypes[index1] == "numeric":
if datahash[i][index1] > float(data):
results.append(datahash[i])
elif fdatatypes[index1] == 'varchar':
print("Can't compare strings!")
elif fdatatypes[index1] == 'date':
date1=str(datahash[i][index1])
date2=str(data);
newdate1 = time.strptime(date1,'%d-%m-%Y')
newdate2 = time.strptime(date2,'%d-%m-%Y')
if newdate1 > newdate2:
results.append(datahash[i])
elif typeop == 3:
for i in range(0,len(datahash)):
index1=fcol.index(column)
if fdatatypes[index1] == "int":
if datahash[i][index1] == int(data):
results.append(datahash[i])
elif fdatatypes[index1] == "numeric":
if datahash[i][index1] == float(data):
results.append(datahash[i])
elif fdatatypes[index1] == 'varchar':
if datahash[i][index] == str(data):
results.append(datahash[i])
elif fdatatypes[index1] == 'date':
date1=str(datahash[i][index1])
date2=str(data);
newdate1 = time.strptime(date1,'%d-%m-%Y')
newdate2 = time.strptime(date2,'%d-%m-%Y')
if newdate1 == newdate2:
results.append(datahash[i])
elif typeop == 4:
for i in range(0,len(datahash)):
index1=fcol.index(column)
if fdatatypes[index1] == "int":
if datahash[i][index1] != int(data):
results.append(datahash[i])
elif fdatatypes[index1] == "numeric":
if datahash[i][index1] != float(data):
results.append(datahash[i])
elif fdatatypes[index1] == 'varchar':
if datahash[i][index] != str(data):
results.append(datahash[i])
elif fdatatypes[index1] == 'date':
date1=str(datahash[i][index1])
date2=str(data);
newdate1 = time.strptime(date1,'%d-%m-%Y')
newdate2 = time.strptime(date2,'%d-%m-%Y')
if newdate1 != newdate2:
results.append(datahash[i])
return results
def printData(self,tblname): md = Metadata() self.no_columns = md.no_getColumns(tblname)
def remove_track(self, track_id):
t = int(track_id)
return str(self.__MTPDevice.delete_object(t))
def get_tracklisting(self):
listing = []
try:
listing = self.__MTPDevice.get_tracklisting(callback=self.__callback)
except Exception, exc:
pass
# log('unable to get file listing %s (%s)', exc, sender=self)
tracks = []
for track in listing:
m = Metadata.get_from_MTPTrack(track)
tracks.append(m)
return tracks
def get_diskusage(self):
return [self.__MTPDevice.get_usedspace(), self.__MTPDevice.get_totalspace()]
def get_batterylevel(self):
return self.__MTPDevice.get_batterylevel()
def get_information(self):
info = []
info.append(["Owner name", self.__MTPDevice.get_devicename()])
info.append(["Manufacturer", self.__MTPDevice.get_manufacturer()])
info.append(["Model name", self.__MTPDevice.get_modelname()])
info.append(["Serial number", self.__MTPDevice.get_serialnumber()])
def __get_track_metadata(self, track_id):
track=self.FILE_LISTING[track_id]
m = Metadata()
m.id = str(track_id)
m.type = TYPE_TRACK
m.parent_id = str(track[1])
m.filename = track[2]
m.title = track[3]
m.artist = track[4]
m.album = track[5]
m.genre = track[6]
m.filesize = track[7]
m.date = track[8]
return m
