← Back to branch summary

~ubuntu-branches/ubuntu/precise/coherence/precise

« back to all changes in this revision

Viewing changes to coherence/upnp/core/device.py

  • Committer: Bazaar Package Importer
  • Author(s): Charlie Smotherman
  • Date: 2010-01-02 10:57:15 UTC
  • mfrom: (1.1.7 upstream) (3.2.8 sid)
  • Revision ID: james.westby@ubuntu.com-20100102105715-sghzl2nw4lr5b1ob
Tags: 0.6.6.2-1
*  New  upstream release, summary of changes:
    - adding all necessary files to MANIFEST.in, to compensate for the
      gone 'auto-include-all-files-under-version-control' setuptools
      feature.
    - rearranging genre and genres attribute in DIDLLite - thx Caleb  
    - fix face_path typo, fixes #275.   

Show diffs side-by-side

added added

removed removed

Lines of Context:
coherence/upnp/core/device.py
26
26
        #self.uid = self.usn[:-len(self.st)-2]
27
27
        self.friendly_name = ""
28
28
        self.device_type = ""
 
29
        self.friendly_device_type = "[unknown]"
 
30
        self.device_type_version = 0
29
31
        self.udn = None
30
32
        self.detection_completed = False
31
33
        self.client = None
42
44
    #    #print "Device removal completed"
43
45
    #    pass
44
46
 
 
47
    def as_dict(self):
 
48
        import copy
 
49
        d = {'device_type': self.get_device_type(),
 
50
             'friendly_name': self.get_friendly_name(),
 
51
             'udn': self.get_id(),
 
52
             'services': [x.as_dict() for x in self.services]}
 
53
        icons = []
 
54
        for icon in self.icons:
 
55
            icons.append({"mimetype":icon['mimetype'],"url":icon['url'], "height":icon['height'], "width":icon['width'], "depth":icon['depth']})
 
56
        d['icons'] = icons
 
57
        return d
 
58
 
45
59
    def remove(self,*args):
46
60
        self.info("removal of ", self.friendly_name, self.udn)
47
61
        while len(self.devices)>0:
57
71
            self.client = None
58
72
        #del self
59
73
 
60
 
    def receiver( self, signal, *args, **kwargs):
61
 
        self.debug("device receiver called with %r %r", signal, kwargs)
 
74
    def receiver(self, *args, **kwargs):
62
75
        if self.detection_completed == True:
63
76
            return
64
77
        for s in self.services:
65
78
            if s.detection_completed == False:
66
79
                return
 
80
        if self.udn == None:
 
81
            return
67
82
        self.detection_completed = True
68
83
        if self.parent != None:
69
84
            self.info("embedded device %r %r initialized, parent %r" % (self.friendly_name,self.device_type,self.parent))
112
127
    def get_device_type(self):
113
128
        return self.device_type
114
129
 
 
130
    def get_friendly_device_type(self):
 
131
        return self.friendly_device_type
 
132
 
 
133
    def get_markup_name(self):
 
134
        try:
 
135
            return self._markup_name
 
136
        except AttributeError:
 
137
            self._markup_name = u"%s:%s %s" % (self.friendly_device_type,
 
138
                    self.device_type_version, self.friendly_name)
 
139
            return self._markup_name
 
140
 
 
141
    def get_device_type_version(self):
 
142
        return self.device_type_version
 
143
 
115
144
    def set_client(self, client):
116
145
        self.client = client
117
146
 
144
173
        return dl
145
174
 
146
175
    def parse_device(self, d):
 
176
        self.info("parse_device %r" %d)
147
177
        self.device_type = unicode(d.findtext('./{%s}deviceType' % ns))
 
178
        self.friendly_device_type, self.device_type_version = \
 
179
                self.device_type.split(':')[-2:]
148
180
        self.friendly_name = unicode(d.findtext('./{%s}friendlyName' % ns))
149
 
        self.udn = d.findtext('.//{%s}UDN' % ns)
 
181
        self.udn = d.findtext('./{%s}UDN' % ns)
 
182
        self.info("found udn %r %r" % (self.udn,self.friendly_name))
150
183
 
151
184
        try:
152
 
            self.manufacturer = d.findtext('.//{%s}manufacturer' % ns)
153
 
        except:
154
 
            pass
155
 
        try:
156
 
            self.manufacturer_url = d.findtext('.//{%s}manufacturerURL' % ns)
157
 
        except:
158
 
            pass
159
 
        try:
160
 
            self.model_name = d.findtext('.//{%s}modelName' % ns)
161
 
        except:
162
 
            pass
163
 
        try:
164
 
            self.model_description = d.findtext('.//{%s}modelDescription' % ns)
165
 
        except:
166
 
            pass
167
 
        try:
168
 
            self.model_number = d.findtext('.//{%s}modelNumber' % ns)
169
 
        except:
170
 
            pass
171
 
        try:
172
 
            self.model_url = d.findtext('.//{%s}modelURL' % ns)
173
 
        except:
174
 
            pass
175
 
        try:
176
 
            self.serial_number = d.findtext('.//{%s}serialNumber' % ns)
177
 
        except:
178
 
            pass
179
 
        try:
180
 
            self.upc = d.findtext('.//{%s}UPC' % ns)
181
 
        except:
182
 
            pass
183
 
        try:
184
 
            self.presentation_url = d.findtext('.//{%s}presentationURL' % ns)
 
185
            self.manufacturer = d.findtext('./{%s}manufacturer' % ns)
 
186
        except:
 
187
            pass
 
188
        try:
 
189
            self.manufacturer_url = d.findtext('./{%s}manufacturerURL' % ns)
 
190
        except:
 
191
            pass
 
192
        try:
 
193
            self.model_name = d.findtext('./{%s}modelName' % ns)
 
194
        except:
 
195
            pass
 
196
        try:
 
197
            self.model_description = d.findtext('./{%s}modelDescription' % ns)
 
198
        except:
 
199
            pass
 
200
        try:
 
201
            self.model_number = d.findtext('./{%s}modelNumber' % ns)
 
202
        except:
 
203
            pass
 
204
        try:
 
205
            self.model_url = d.findtext('./{%s}modelURL' % ns)
 
206
        except:
 
207
            pass
 
208
        try:
 
209
            self.serial_number = d.findtext('./{%s}serialNumber' % ns)
 
210
        except:
 
211
            pass
 
212
        try:
 
213
            self.upc = d.findtext('./{%s}UPC' % ns)
 
214
        except:
 
215
            pass
 
216
        try:
 
217
            self.presentation_url = d.findtext('./{%s}presentationURL' % ns)
185
218
        except:
186
219
            pass
187
220
 
261
294
                    self.add_device(embedded_device)
262
295
                    embedded_device.parse_device(d)
263
296
 
 
297
        self.receiver()
 
298
 
264
299
    def get_location(self):
265
300
        return self.parent.get_location()
266
301
 
273
308
    def get_urlbase(self):
274
309
        return self.parent.get_urlbase()
275
310
 
 
311
    def get_presentation_url(self):
 
312
        try:
 
313
            return self.make_fullyqualified(self.presentation_url)
 
314
        except:
 
315
            return ''
 
316
 
 
317
    def get_parent_id(self):
 
318
        try:
 
319
            return self.parent.get_id()
 
320
        except:
 
321
            return ''
 
322
 
276
323
    def make_fullyqualified(self,url):
277
324
        return self.parent.make_fullyqualified(url)
278
325
 
 
326
    def as_tuples(self):
 
327
        r = []
 
328
 
 
329
        def append(name,attribute):
 
330
            try:
 
331
                if isinstance(attribute,tuple):
 
332
                    if callable(attribute[0]):
 
333
                        v1 = attribute[0]()
 
334
                    else:
 
335
                        v1 = getattr(self,attribute[0])
 
336
                    if v1 in [None,'None']:
 
337
                        return
 
338
                    if callable(attribute[1]):
 
339
                        v2 = attribute[1]()
 
340
                    else:
 
341
                        v2 = getattr(self,attribute[1])
 
342
                    if v2 in [None,'None']:
 
343
                        return
 
344
                    r.append((name,(v1,v2)))
 
345
                    return
 
346
                elif callable(attribute):
 
347
                    v = attribute()
 
348
                else:
 
349
                    v = getattr(self,attribute)
 
350
                if v not in [None,'None']:
 
351
                    r.append((name,v))
 
352
            except:
 
353
                import traceback
 
354
                self.debug(traceback.format_exc())
 
355
 
 
356
        try:
 
357
            r.append(('Location',(self.get_location(),self.get_location())))
 
358
        except:
 
359
            pass
 
360
        try:
 
361
            append('URL base',self.get_urlbase)
 
362
        except:
 
363
            pass
 
364
        try:
 
365
            r.append(('UDN',self.get_id()))
 
366
        except:
 
367
            pass
 
368
        try:
 
369
            r.append(('Type',self.device_type))
 
370
        except:
 
371
            pass
 
372
        try:
 
373
            r.append(('UPnP Version',self.upnp_version))
 
374
        except:
 
375
            pass
 
376
        try:
 
377
            r.append(('DLNA Device Class',','.join(self.dlna_dc)))
 
378
        except:
 
379
            pass
 
380
        try:
 
381
            r.append(('DLNA Device Capability',','.join(self.dlna_cap)))
 
382
        except:
 
383
            pass
 
384
        try:
 
385
            r.append(('Friendly Name',self.friendly_name))
 
386
        except:
 
387
            pass
 
388
        try:
 
389
            append('Manufacturer','manufacturer')
 
390
        except:
 
391
            pass
 
392
        try:
 
393
            append('Manufacturer URL',('manufacturer_url','manufacturer_url'))
 
394
        except:
 
395
            pass
 
396
        try:
 
397
            append('Model Description','model_description')
 
398
        except:
 
399
            pass
 
400
        try:
 
401
            append('Model Name','model_name')
 
402
        except:
 
403
            pass
 
404
        try:
 
405
            append('Model Number','model_number')
 
406
        except:
 
407
            pass
 
408
        try:
 
409
            append('Model URL',('model_url','model_url'))
 
410
        except:
 
411
            pass
 
412
        try:
 
413
            append('Serial Number','serial_number')
 
414
        except:
 
415
            pass
 
416
        try:
 
417
            append('UPC','upc')
 
418
        except:
 
419
            pass
 
420
        try:
 
421
            append('Presentation URL',('presentation_url',lambda: self.make_fullyqualified(getattr(self,'presentation_url'))))
 
422
        except:
 
423
            pass
 
424
 
 
425
        for icon in self.icons:
 
426
            r.append(('Icon', (icon['realurl'],
 
427
                               self.make_fullyqualified(icon['realurl']),
 
428
                               {'Mimetype': icon['mimetype'],
 
429
                                'Width':icon['width'],
 
430
                                'Height':icon['height'],
 
431
                                'Depth':icon['depth']})))
 
432
 
 
433
        return r
 
434
 
279
435
 
280
436
class RootDevice(Device):
281
437
 
294
450
        self.parse_description()
295
451
 
296
452
    def __repr__(self):
297
 
        return "rootdevice %r %r %r, manifestation %r" % (self.friendly_name,self.st,self.host,self.manifestation)
 
453
        return "rootdevice %r %r %r %r, manifestation %r" % (self.friendly_name,self.udn,self.st,self.host,self.manifestation)
298
454
 
299
455
    def get_usn(self):
300
456
        return self.usn
324
480
            return True
325
481
        return False
326
482
 
327
 
    def device_detect( self, signal, *args, **kwargs):
 
483
    def device_detect( self, *args, **kwargs):
328
484
        self.debug("device_detect %r", kwargs)
329
485
        if self.root_detection_completed == True:
330
486
            return
359
515
            data, headers = x
360
516
            tree = utils.parse_xml(data, 'utf-8').getroot()
361
517
 
362
 
            major = tree.findtext('.//{%s}specVersion/{%s}major' % (ns,ns))
363
 
            minor = tree.findtext('.//{%s}specVersion/{%s}minor' % (ns,ns))
 
518
            major = tree.findtext('./{%s}specVersion/{%s}major' % (ns,ns))
 
519
            minor = tree.findtext('./{%s}specVersion/{%s}minor' % (ns,ns))
364
520
            try:
365
521
                self.upnp_version = '.'.join((major,minor))
366
522
            except:
367
523
                self.upnp_version = 'n/a'
368
524
            try:
369
 
                self.urlbase = tree.findtext('.//{%s}URLBase' % ns)
 
525
                self.urlbase = tree.findtext('./{%s}URLBase' % ns)
370
526
            except:
371
527
                import traceback
372
528
                self.debug(traceback.format_exc())
373
529
 
374
 
            d = tree.find('.//{%s}device' % ns)
 
530
            d = tree.find('./{%s}device' % ns)
375
531
            if d is not None:
376
532
                self.parse_device(d) # root device
377
533
 
378
534
        def gotError(failure, url):
379
 
            self.warning("error requesting %r", url)
 
535
            self.warning("error getting device description from %r", url)
380
536
            self.info(failure)
381
537
 
382
538
        utils.getPage(self.location).addCallbacks(gotPage, gotError, None, None, [self.location], None)
393
549
        else:
394
550
            r = urlparse.urljoin(self.get_location(),url)
395
551
        return r
396
 
 
397
 
 
398
 
    def as_tuples(self):
399
 
        r = []
400
 
 
401
 
        def append(name,attribute):
402
 
            try:
403
 
                if isinstance(attribute,tuple):
404
 
                    if callable(attribute[0]):
405
 
                        v1 = attribute[0]()
406
 
                    else:
407
 
                        v1 = getattr(self,attribute[0])
408
 
                    if v1 in [None,'None']:
409
 
                        return
410
 
                    if callable(attribute[1]):
411
 
                        v2 = attribute[1]()
412
 
                    else:
413
 
                        v2 = getattr(self,attribute[1])
414
 
                    if v2 in [None,'None']:
415
 
                        return
416
 
                    r.append((name,(v1,v2)))
417
 
                    return
418
 
                elif callable(attribute):
419
 
                    v = attribute()
420
 
                else:
421
 
                    v = getattr(self,attribute)
422
 
                if v not in [None,'None']:
423
 
                    r.append((name,v))
424
 
            except:
425
 
                import traceback
426
 
                self.debug(traceback.format_exc())
427
 
 
428
 
        r.append(('Location',(self.get_location(),self.get_location())))
429
 
        append('URL base',self.get_urlbase)
430
 
        r.append(('UDN',self.get_id()))
431
 
        r.append(('Type',self.device_type))
432
 
        r.append(('UPnP Version',self.upnp_version))
433
 
        try:
434
 
            r.append(('DLNA Device Class',','.join(self.dlna_dc)))
435
 
        except:
436
 
            pass
437
 
        try:
438
 
            r.append(('DLNA Device Capability',','.join(self.dlna_cap)))
439
 
        except:
440
 
            pass
441
 
        r.append(('Friendly Name',self.friendly_name))
442
 
 
443
 
        append('Manufacturer','manufacturer')
444
 
        append('Manufacturer URL',('manufacturerURL','manufacturerURL'))
445
 
        append('Model Name','model_name')
446
 
        append('Model Description','model_description')
447
 
        append('Model Number','model_number')
448
 
        append('Model URL',('model_url','model_url'))
449
 
        append('Serial Number','serial_number')
450
 
        append('UPC','upc')
451
 
        append('Presentation URL',('presentation_url',lambda: self.make_fullyqualified(getattr(self,'presentation_url'))))
452
 
 
453
 
        for icon in self.icons:
454
 
            r.append(('Icon', (icon['realurl'],
455
 
                               self.make_fullyqualified(icon['realurl']),
456
 
                               {'Mimetype': icon['mimetype'],
457
 
                                'Width':icon['width'],
458
 
                                'Height':icon['height'],
459
 
                                'Depth':icon['depth']})))
460
 
 
461
 
        return r
 
 
b'\\ No newline at end of file'