def __init__(self, upnp_service, name, implementation, instance,
send_events, data_type, allowed_values):
log.Loggable.__init__(self)
self.service = upnp_service
self.name = name
self.implementation = implementation
self.instance = instance
self.send_events = utils.means_true(send_events)
self.never_evented = False
self.data_type = data_type
self.allowed_values = allowed_values
if self.allowed_values == None:
self.allowed_values = []
self.has_vendor_values = False
self.allowed_value_range = None
self.dependant_variable = None
self.default_value = ''
self.old_value = ''
self.value = ''
self.last_time_touched = None
self._callbacks = []
if isinstance(self.service, service.ServiceServer):
self.moderated = self.service.is_variable_moderated(name)
self.updated = False
def __init__(self, upnp_service, name, implementation, instance, send_events,
data_type, allowed_values):
self.service = upnp_service
self.name = name
self.implementation = implementation
self.instance = instance
self.send_events = utils.means_true(send_events)
self.never_evented = False
self.data_type = data_type
self.allowed_values = allowed_values
if self.allowed_values == None:
self.allowed_values = []
self.has_vendor_values = False
self.allowed_value_range = None
self.dependant_variable = None
self.default_value = ''
self.old_value = ''
self.value = ''
self.last_time_touched = None
self._callbacks = []
if isinstance( self.service, service.ServiceServer):
self.moderated = self.service.is_variable_moderated(name)
self.updated = False
def mute(self, w):
service = self.device.get_service_by_type('RenderingControl')
action = service.get_action('SetMute')
mute_variable = service.get_state_variable('Mute')
if means_true(mute_variable.value) == False:
new_mute = '1'
else:
new_mute = '0'
d = action.call(InstanceID=0, Channel='Master', DesiredMute=new_mute)
d.addCallback(self.handle_result)
d.addErrback(self.handle_error)
return d
def populate(result, entries):
self.info("result %r" % result)
self.info("entries %r" % entries)
status_bar.pop(context_id)
status_bar.push(context_id, "%s - ok" % time.strftime("%H:%M:%S"))
for argument, value in result.items():
type, method = entries[argument]
if type == "boolean":
value = means_true(value)
if type == "text":
method.get_buffer().set_text(value)
continue
method(value)
def populate(result, entries):
self.info("result %r" % result)
self.info("entries %r" % entries)
status_bar.pop(context_id)
status_bar.push(context_id, "%s - ok" % time.strftime("%H:%M:%S"))
for argument, value in result.items():
type, method = entries[argument]
if type == 'boolean':
value = means_true(value)
if type == 'text':
method.get_buffer().set_text(value)
continue
method(value)
def start(self,name):
self.canvas.set_title(name)
try:
self.content = self.config['content']
except:
self.content = []
if not isinstance( self.content, list):
self.content = [self.content]
tmp_l = []
for path in self.content:
if path.startswith('http://'):
tmp_l.append(path)
else:
tmp_l.append(os.path.abspath(path))
self.content = tmp_l
self.items = []
self.playlist = []
self.warning("checking for items...")
for path in self.content:
if path.startswith('http://'):
self.items.append(path)
else:
self.walk(path)
self.warning("done")
self.renderer.av_transport_server.get_variable('AVTransportURI').subscribe(self.state_variable_change)
self.renderer.av_transport_server.get_variable('NextAVTransportURI').subscribe(self.state_variable_change)
#self.renderer.av_transport_server.get_variable('TransportState').subscribe(self.state_variable_change)
#self.renderer.av_transport_server.get_variable('AVTransportURI').subscribe(self.state_variable_change)
#self.renderer.av_transport_server.get_variable('LastChange').subscribe(self.state_variable_change)
try:
if means_true(self.config['autostart']):
d = defer.maybeDeferred(self.get_next_item)
d.addCallback(lambda result: self.set_renderer_uri(self.renderer,result[0],result[1]))
d.addErrback(self.got_error)
def get_next():
d = defer.maybeDeferred(self.get_next_item)
d.addCallback(lambda result: self.set_renderer_next_uri(self.renderer,result[0],result[1]))
d.addErrback(self.got_error)
d.addCallback(lambda result: get_next())
d.addErrback(self.got_error)
except KeyError:
pass
except:
traceback.print_exc()
def mute(self,w):
service = self.device.get_service_by_type('RenderingControl')
action = service.get_action('SetMute')
mute_variable = service.get_state_variable('Mute')
if means_true(mute_variable.value) == False:
new_mute = '1'
else:
new_mute = '0'
d = action.call(InstanceID=0,
Channel='Master',
DesiredMute=new_mute)
d.addCallback(self.handle_result)
d.addErrback(self.handle_error)
return d
def __init__(
self,
upnp_service,
name,
implementation,
instance,
send_events,
data_type,
allowed_values,
):
log.LogAble.__init__(self)
EventDispatcher.__init__(self)
self.service = upnp_service
self.dispatch_events = [
f'state_variable_{name}_changed',
'state_variable_changed',
]
self.dispatch_targets = [self]
if isinstance(self.service, EventDispatcher):
self.dispatch_targets.append(self.service)
for target in self.dispatch_targets:
for evt in self.dispatch_events:
if evt not in target.event_dispatcher_event_callbacks:
target.register_event(evt)
self.name = name
self.implementation = implementation
self.instance = instance
self.send_events = utils.means_true(send_events)
self.never_evented = False
self.data_type = data_type
self.allowed_values = allowed_values
if self.allowed_values is None:
self.allowed_values = []
self.has_vendor_values = False
self.allowed_value_range = None
self.dependant_variable = None
self.default_value = ''
self.old_value = ''
self.value = ''
self.last_time_touched = None
self._callbacks = []
if isinstance(self.service, service.ServiceServer):
self.moderated = self.service.is_variable_moderated(name)
self.updated = False
def get_next_item(self):
try:
uri = self.playlist.pop()
except IndexError:
self.playlist = self.items[:]
if means_true(self.config['shuffle']):
random.shuffle(self.playlist)
uri = self.playlist.pop()
try:
uri = "file://" + uri.path
return uri,''
except:
if uri.startswith('http://'):
pass
raise
def state_variable_change(self,variable):
print "%s %r" % (variable.name, variable.value)
if variable.name == 'CurrentTrackMetaData':
if variable.value != None and len(variable.value)>0:
try:
from coherence.upnp.core import DIDLLite
elt = DIDLLite.DIDLElement.fromString(variable.value)
for item in elt.getItems():
print "now playing: %r - %r (%s/%r)" % (item.artist, item.title, item.id, item.upnp_class)
self.title_text.set_markup("<b>%s</b>" % item.title)
if item.album != None:
self.album_text.set_markup(item.album)
else:
self.album_text.set_markup('')
if item.artist != None:
self.artist_text.set_markup("<i>%s</i>" % item.artist)
else:
self.artist_text.set_markup("")
if item.albumArtURI != None:
def got_icon(icon):
icon = icon[0]
icon_loader = gtk.gdk.PixbufLoader()
icon_loader.write(icon)
icon_loader.close()
icon = icon_loader.get_pixbuf()
icon = icon.scale_simple(128,128,gtk.gdk.INTERP_BILINEAR)
self.album_art_image.set_from_pixbuf(icon)
d = getPage(item.albumArtURI)
d.addCallback(got_icon)
else:
self.album_art_image.set_from_pixbuf(self.blank_icon)
except SyntaxError:
#print "seems we haven't got an XML string"
return
else:
self.title_text.set_markup('')
self.album_text.set_markup('')
self.artist_text.set_markup('')
self.album_art_image.set_from_pixbuf(self.blank_icon)
elif variable.name == 'TransportState':
print variable.name, 'changed from', variable.old_value, 'to', variable.value
if variable.value == 'PLAYING':
self.start_button.set_image(self.pause_button_image)
try:
self.position_loop.start(1.0, now=True)
except:
pass
elif variable.value != 'TRANSITIONING':
self.start_button.set_image(self.start_button_image)
try:
self.position_loop.stop()
except:
pass
if variable.value == 'STOPPED':
self.get_position()
context_id = self.status_bar.get_context_id("Statusbar")
self.status_bar.pop(context_id)
self.status_bar.push(context_id,"%s" % variable.value)
elif variable.name == 'CurrentTransportActions':
try:
actions = map(lambda x: x.upper(),variable.value.split(','))
if 'SEEK' in actions:
self.position_scale.set_sensitive(True)
self.seek_forward_button.set_sensitive(True)
self.seek_backward_button.set_sensitive(True)
else:
self.position_scale.set_sensitive(False)
self.seek_forward_button.set_sensitive(False)
self.seek_backward_button.set_sensitive(False)
self.start_button.set_sensitive('PLAY' in actions)
self.stop_button.set_sensitive('STOP' in actions)
self.prev_button.set_sensitive('PREVIOUS' in actions)
self.next_button.set_sensitive('NEXT' in actions)
except:
#very unlikely to happen
import traceback
print traceback.format_exc()
elif variable.name == 'AVTransportURI':
print variable.name, 'changed from', variable.old_value, 'to', variable.value
if variable.value != '':
pass
#self.seek_backward_button.set_sensitive(True)
#self.stop_button.set_sensitive(True)
#self.start_button.set_sensitive(True)
#self.seek_forward_button.set_sensitive(True)
else:
#self.seek_backward_button.set_sensitive(False)
#self.stop_button.set_sensitive(False)
#self.start_button.set_sensitive(False)
#self.seek_forward_button.set_sensitive(False)
self.album_art_image.set_from_pixbuf(self.blank_icon)
self.title_text.set_markup('')
self.album_text.set_markup('')
self.artist_text.set_markup('')
elif variable.name == 'Volume':
try:
volume = int(variable.value)
print "volume value", volume
if int(self.volume_scale.get_value()) != volume:
self.volume_scale.set_value(volume)
service = self.device.get_service_by_type('RenderingControl')
mute_variable = service.get_state_variable('Mute')
if means_true(mute_variable.value) == True:
self.volume_image.set_from_pixbuf(self.volume_muted_icon)
elif volume < 34:
self.volume_image.set_from_pixbuf(self.volume_low_icon)
elif volume < 67:
self.volume_image.set_from_pixbuf(self.volume_medium_icon)
else:
self.volume_image.set_from_pixbuf(self.volume_high_icon)
except:
import traceback
print traceback.format_exc()
pass
elif variable.name == 'Mute':
service = self.device.get_service_by_type('RenderingControl')
volume_variable = service.get_state_variable('Volume')
volume = volume_variable.value
if means_true(variable.value) == True:
self.volume_image.set_from_pixbuf(self.volume_muted_icon)
elif volume < 34:
self.volume_image.set_from_pixbuf(self.volume_low_icon)
elif volume < 67:
self.volume_image.set_from_pixbuf(self.volume_medium_icon)
else:
self.volume_image.set_from_pixbuf(self.volume_high_icon)
def state_variable_change(self,variable):
if variable.name == 'CurrentTrackMetaData':
if variable.value != None and len(variable.value)>0:
try:
elt = DIDLLite.DIDLElement.fromString(variable.value)
except SyntaxError:
print "seems we haven't got an XML string", repr(variable.value)
else:
for item in elt.getItems():
self.title_text.set_markup("<b>%s</b>" % item.title)
if item.album != None:
self.album_text.set_markup(item.album)
else:
self.album_text.set_markup('')
if item.artist != None:
self.artist_text.set_markup("<i>%s</i>" % item.artist)
else:
self.artist_text.set_markup("")
def got_icon(icon):
icon = icon[0]
icon_loader = GdkPixbuf.PixbufLoader()
icon_loader.write(icon)
icon_loader.close()
icon = icon_loader.get_pixbuf()
icon = icon.scale_simple(300, 300, GdkPixbuf.InterpType.BILINEAR)
self.album_art_image.set_from_pixbuf(icon)
if item.upnp_class.startswith('object.item.audioItem') and item.albumArtURI != None:
d = getPage(item.albumArtURI)
d.addCallback(got_icon)
elif item.upnp_class.startswith('object.item.imageItem'):
res = item.res.get_matching('http-get:*:image/:*')
if len(res) > 0:
res = res[0]
d = getPage(res.data)
d.addCallback(got_icon)
else:
self.album_art_image.set_from_pixbuf(self.blank_icon)
else:
self.album_art_image.set_from_pixbuf(self.blank_icon)
else:
self.title_text.set_markup('')
self.album_text.set_markup('')
self.artist_text.set_markup('')
self.album_art_image.set_from_pixbuf(self.blank_icon)
elif variable.name == 'TransportState':
if variable.value == 'PLAYING':
service = self.device.get_service_by_type('AVTransport')
if 'Pause' in service.get_actions():
self.start_button.set_image(self.pause_button_image)
try:
self.position_loop.start(1.0, now=True)
except:
pass
elif variable.value != 'TRANSITIONING':
self.start_button.set_image(self.start_button_image)
try:
self.position_loop.stop()
except:
pass
if variable.value == 'STOPPED':
self.get_position()
context_id = self.status_bar.get_context_id("Statusbar")
self.status_bar.pop(context_id)
self.status_bar.push(context_id,"%s" % variable.value)
elif variable.name == 'CurrentTransportActions':
try:
actions = map(lambda x: x.upper(),variable.value.split(','))
if 'SEEK' in actions:
self.position_scale.set_sensitive(True)
self.seek_forward_button.set_sensitive(True)
self.seek_backward_button.set_sensitive(True)
else:
self.position_scale.set_sensitive(False)
self.seek_forward_button.set_sensitive(False)
self.seek_backward_button.set_sensitive(False)
self.start_button.set_sensitive('PLAY' in actions)
self.stop_button.set_sensitive('STOP' in actions)
self.prev_button.set_sensitive('PREVIOUS' in actions)
self.next_button.set_sensitive('NEXT' in actions)
except:
#very unlikely to happen
import traceback
print traceback.format_exc()
elif variable.name == 'AVTransportURI':
if variable.value != '':
pass
#self.seek_backward_button.set_sensitive(True)
#self.stop_button.set_sensitive(True)
#self.start_button.set_sensitive(True)
#self.seek_forward_button.set_sensitive(True)
else:
#self.seek_backward_button.set_sensitive(False)
#self.stop_button.set_sensitive(False)
#self.start_button.set_sensitive(False)
#self.seek_forward_button.set_sensitive(False)
self.album_art_image.set_from_pixbuf(self.blank_icon)
self.title_text.set_markup('')
self.album_text.set_markup('')
self.artist_text.set_markup('')
elif variable.name == 'Volume':
try:
volume = int(variable.value)
if int(self.volume_scale.get_value()) != volume:
self.volume_scale.set_value(volume)
service = self.device.get_service_by_type('RenderingControl')
mute_variable = service.get_state_variable('Mute')
if means_true(mute_variable.value) == True:
self.volume_image.set_from_pixbuf(self.volume_muted_icon)
elif volume < 34:
self.volume_image.set_from_pixbuf(self.volume_low_icon)
elif volume < 67:
self.volume_image.set_from_pixbuf(self.volume_medium_icon)
else:
self.volume_image.set_from_pixbuf(self.volume_high_icon)
except:
import traceback
print traceback.format_exc()
elif variable.name == 'Mute':
service = self.device.get_service_by_type('RenderingControl')
volume_variable = service.get_state_variable('Volume')
volume = volume_variable.value
if means_true(variable.value) == True:
self.volume_image.set_from_pixbuf(self.volume_muted_icon)
elif volume < 34:
self.volume_image.set_from_pixbuf(self.volume_low_icon)
elif volume < 67:
self.volume_image.set_from_pixbuf(self.volume_medium_icon)
else:
self.volume_image.set_from_pixbuf(self.volume_high_icon)
def set_never_evented(self, value):
self.never_evented = utils.means_true(value)
def __init__(self,config):
self.config = config
fullscreen = False
try:
if means_true(self.config['fullscreen']):
fullscreen = True
except:
pass
grafics = self.config.get('grafics')
if grafics == 'pyglet':
from cadre.scribbling.pyglet_backend import Canvas
else:
from cadre.scribbling.clutter_backend import Canvas
self.canvas = Canvas(fullscreen)
try:
overlays = self.config['overlay']
if not isinstance(overlays,list):
overlays = [overlays]
except:
overlays = []
map(self.canvas.add_overlay,overlays)
coherence_config = {}
#coherence_config['version'] = '1'
coherence_config['logmode'] = 'warning'
#coherence_config['controlpoint'] = 'yes'
louie.connect(self.media_server_found, 'Coherence.UPnP.ControlPoint.MediaServer.detected', louie.Any)
louie.connect(self.media_server_removed, 'Coherence.UPnP.ControlPoint.MediaServer.removed', louie.Any)
self.coherence = Coherence(coherence_config)
name = self.config.get('name','Cadre - Coherence Picture-Frame')
kwargs = {'version':1,
'no_thread_needed':True,
'name':name}
kwargs['transition'] = 'NONE'
try:
if self.config['transition'].upper() in self.get_available_transitions():
kwargs['transition'] = self.config['transition'].upper()
self.set_transition(self.config['transition'].upper())
except:
pass
try:
kwargs['display_time'] = int(self.config['display_time'])
except:
pass
self.canvas.set_title(name)
kwargs['controller'] = self
uuid = self.config.get('uuid')
if uuid:
kwargs['uuid'] = uuid
print kwargs
self.renderer = MediaRenderer(self.coherence,CadreRenderer,**kwargs)
if 'uuid' not in self.config:
self.config['uuid'] = str(self.renderer.uuid)[5:]
try:
self.config.save()
except AttributeError:
pass
reactor.callLater(0.5,self.start,name)
def state_variable_change(self, variable):
print "%s %r" % (variable.name, variable.value)
if variable.name == 'CurrentTrackMetaData':
if variable.value != None and len(variable.value) > 0:
try:
from coherence.upnp.core import DIDLLite
elt = DIDLLite.DIDLElement.fromString(variable.value)
for item in elt.getItems():
print "now playing:", repr(item.artist),
print "-", repr(item.title),
print "(%s/%r)" % (item.id, item.upnp_class)
self.title_text.set_markup("<b>%s</b>" % item.title)
if item.album != None:
self.album_text.set_markup(item.album)
else:
self.album_text.set_markup('')
if item.artist != None:
self.artist_text.set_markup("<i>%s</i>" %
item.artist)
else:
self.artist_text.set_markup("")
def got_icon(icon):
icon = icon[0]
icon_loader = gtk.gdk.PixbufLoader()
icon_loader.write(icon)
icon_loader.close()
icon = icon_loader.get_pixbuf()
icon = icon.scale_simple(128, 128,
gtk.gdk.INTERP_BILINEAR)
self.album_art_image.set_from_pixbuf(icon)
if item.upnp_class.startswith(
'object.item.audioItem'
) and item.albumArtURI != None:
d = getPage(item.albumArtURI)
d.addCallback(got_icon)
elif item.upnp_class.startswith(
'object.item.imageItem'):
res = item.res.get_matching('http-get:*:image/:*')
if len(res) > 0:
res = res[0]
d = getPage(res.data)
d.addCallback(got_icon)
else:
self.album_art_image.set_from_pixbuf(
self.blank_icon)
else:
self.album_art_image.set_from_pixbuf(
self.blank_icon)
except SyntaxError:
#print "seems we haven't got an XML string"
return
else:
self.title_text.set_markup('')
self.album_text.set_markup('')
self.artist_text.set_markup('')
self.album_art_image.set_from_pixbuf(self.blank_icon)
elif variable.name == 'TransportState':
print variable.name, 'changed from', variable.old_value,
print 'to', variable.value
if variable.value == 'PLAYING':
service = self.device.get_service_by_type('AVTransport')
if 'Pause' in service.get_actions():
self.start_button.set_image(self.pause_button_image)
try:
self.position_loop.start(1.0, now=True)
except:
pass
elif variable.value != 'TRANSITIONING':
self.start_button.set_image(self.start_button_image)
try:
self.position_loop.stop()
except:
pass
if variable.value == 'STOPPED':
self.get_position()
context_id = self.status_bar.get_context_id("Statusbar")
self.status_bar.pop(context_id)
self.status_bar.push(context_id, "%s" % variable.value)
elif variable.name == 'CurrentTransportActions':
try:
actions = map(lambda x: x.upper(), variable.value.split(','))
if 'SEEK' in actions:
self.position_scale.set_sensitive(True)
self.seek_forward_button.set_sensitive(True)
self.seek_backward_button.set_sensitive(True)
else:
self.position_scale.set_sensitive(False)
self.seek_forward_button.set_sensitive(False)
self.seek_backward_button.set_sensitive(False)
self.start_button.set_sensitive('PLAY' in actions)
self.stop_button.set_sensitive('STOP' in actions)
self.prev_button.set_sensitive('PREVIOUS' in actions)
self.next_button.set_sensitive('NEXT' in actions)
except:
#very unlikely to happen
import traceback
print traceback.format_exc()
elif variable.name == 'AVTransportURI':
print variable.name, 'changed from', variable.old_value,
print 'to', variable.value
if variable.value != '':
pass
#self.seek_backward_button.set_sensitive(True)
#self.stop_button.set_sensitive(True)
#self.start_button.set_sensitive(True)
#self.seek_forward_button.set_sensitive(True)
else:
#self.seek_backward_button.set_sensitive(False)
#self.stop_button.set_sensitive(False)
#self.start_button.set_sensitive(False)
#self.seek_forward_button.set_sensitive(False)
self.album_art_image.set_from_pixbuf(self.blank_icon)
self.title_text.set_markup('')
self.album_text.set_markup('')
self.artist_text.set_markup('')
elif variable.name == 'Volume':
try:
volume = int(variable.value)
print "volume value", volume
if int(self.volume_scale.get_value()) != volume:
self.volume_scale.set_value(volume)
service = self.device.get_service_by_type('RenderingControl')
mute_variable = service.get_state_variable('Mute')
if means_true(mute_variable.value) == True:
self.volume_image.set_from_pixbuf(self.volume_muted_icon)
elif volume < 34:
self.volume_image.set_from_pixbuf(self.volume_low_icon)
elif volume < 67:
self.volume_image.set_from_pixbuf(self.volume_medium_icon)
else:
self.volume_image.set_from_pixbuf(self.volume_high_icon)
except:
import traceback
print traceback.format_exc()
pass
elif variable.name == 'Mute':
service = self.device.get_service_by_type('RenderingControl')
volume_variable = service.get_state_variable('Volume')
volume = volume_variable.value
if means_true(variable.value) == True:
self.volume_image.set_from_pixbuf(self.volume_muted_icon)
elif volume < 34:
self.volume_image.set_from_pixbuf(self.volume_low_icon)
elif volume < 67:
self.volume_image.set_from_pixbuf(self.volume_medium_icon)
else:
self.volume_image.set_from_pixbuf(self.volume_high_icon)
def __init__(self, server, **kwargs):
BackendStore.__init__(self, server, **kwargs)
self.next_id = 1000
self.name = kwargs.get('name', 'my media')
self.content = kwargs.get('content', None)
if self.content is not None:
if isinstance(self.content, str):
self.content = [self.content]
cl = []
for a in self.content:
cl += a.split(',')
self.content = cl
else:
self.content = xdg_content()
self.content = [x[0] for x in self.content]
if self.content is None:
self.content = 'tests/content'
if not isinstance(self.content, list):
self.content = [self.content]
self.content = set([os.path.abspath(x) for x in self.content])
ignore_patterns = kwargs.get('ignore_patterns', [])
self.store = {}
self.inotify = None
if kwargs.get('enable_inotify', 'yes') == 'yes':
if INotify:
try:
self.inotify = INotify()
self.inotify.startReading()
except Exception as msg:
self.error(f'inotify disabled: {msg}')
self.inotify = None
else:
self.info(f'{no_inotify_reason}')
else:
self.info('FSStore content auto-update disabled upon user request')
if kwargs.get('enable_destroy', 'no') == 'yes':
self.upnp_DestroyObject = self.hidden_upnp_DestroyObject
self.import_folder = kwargs.get('import_folder', None)
if self.import_folder is not None:
self.import_folder = os.path.abspath(self.import_folder)
if not os.path.isdir(self.import_folder):
self.import_folder = None
self.ignore_file_pattern = re.compile(r'|'.join([r'^\..*'] +
list(ignore_patterns)))
parent = None
self.update_id = 0
if (len(self.content) > 1
or utils.means_true(kwargs.get('create_root', False))
or self.import_folder is not None):
UPnPClass = classChooser('root')
id = str(self.getnextID())
try:
parent = self.store[id] = FSItem(
id,
parent,
'media',
'root',
self.urlbase,
UPnPClass,
update=True,
store=self,
)
except Exception as e:
self.error(
f'Error on setting self.store[id], Error on FSItem: {e}')
exit(1)
if self.import_folder is not None:
id = str(self.getnextID())
self.store[id] = FSItem(
id,
parent,
self.import_folder,
'directory',
self.urlbase,
UPnPClass,
update=True,
store=self,
)
self.import_folder_id = id
for bytesPath in self.content:
if isinstance(bytesPath, (list, tuple)):
path = str(bytesPath[0])
else:
path = str(bytesPath)
if self.ignore_file_pattern.match(path):
continue
try:
self.walk(path, parent, self.ignore_file_pattern)
except Exception as msg:
self.warning(f'on walk of {path!r}: {msg!r}')
import traceback
self.debug(traceback.format_exc())
self.wmc_mapping.update({'14': '0', '15': '0', '16': '0', '17': '0'})
self.init_completed = True
def set_never_evented(self, value):
self.never_evented = utils.means_true(value)
def __init__(self, server, **kwargs):
BackendStore.__init__(self, server, **kwargs)
self.next_id = 1000
self.name = kwargs.get('name', 'my media')
self.content = kwargs.get('content', None)
if self.content != None:
if isinstance(self.content, str):
self.content = [self.content]
l = []
for a in self.content:
l += a.split(',')
self.content = l
else:
self.content = xdg_content()
self.content = [x[0] for x in self.content]
if self.content == None:
self.content = 'tests/content'
if not isinstance(self.content, list):
self.content = [self.content]
self.content = Set([os.path.abspath(x) for x in self.content])
ignore_patterns = kwargs.get('ignore_patterns', [])
self.store = {}
self.inotify = None
if kwargs.get('enable_inotify', 'yes') == 'yes':
if INotify:
try:
self.inotify = INotify()
except Exception as msg:
self.info("%s", msg)
else:
self.info("%s", no_inotify_reason)
else:
self.info("FSStore content auto-update disabled upon user request")
if kwargs.get('enable_destroy', 'no') == 'yes':
self.upnp_DestroyObject = self.hidden_upnp_DestroyObject
self.import_folder = kwargs.get('import_folder', None)
if self.import_folder != None:
self.import_folder = os.path.abspath(self.import_folder)
if not os.path.isdir(self.import_folder):
self.import_folder = None
self.ignore_file_pattern = re.compile('|'.join(['^\..*'] +
list(ignore_patterns)))
parent = None
self.update_id = 0
if (len(self.content) > 1
or utils.means_true(kwargs.get('create_root', False))
or self.import_folder != None):
UPnPClass = classChooser('root')
id = str(self.getnextID())
parent = self.store[id] = FSItem(id,
parent,
'media',
'root',
self.urlbase,
UPnPClass,
update=True,
store=self)
if self.import_folder != None:
id = str(self.getnextID())
self.store[id] = FSItem(id,
parent,
self.import_folder,
'directory',
self.urlbase,
UPnPClass,
update=True,
store=self)
self.import_folder_id = id
for path in self.content:
if isinstance(path, (list, tuple)):
path = path[0]
if self.ignore_file_pattern.match(path):
continue
try:
path = path.encode('utf-8') # patch for #267
self.walk(path, parent, self.ignore_file_pattern)
except Exception as msg:
self.warning('on walk of %r: %r', path, msg)
import traceback
self.debug(traceback.format_exc())
self.wmc_mapping.update({'14': '0', '15': '0', '16': '0', '17': '0'})
louie.send('Coherence.UPnP.Backend.init_completed', None, backend=self)
