Ejemplo n.º 1
0
        def gotLoggedInPage(result):
            data,headers = result
            if re.search(r'(?i)<form[^>]* name="loginForm"', data) is not None:
                print 'WARNING: unable to log in: bad username or password'
                return
            print "logged in in Youtube"

            # Confirm age
            age_form = {
                        'next_url':		'/',
                        'action_confirm':	'Confirm',
                        }
            postdata = urlencode(age_form)
            d = getPage(self._AGE_URL, postdata=postdata, headers=std_headers)
            d.addCallback(gotAgeConfirmedPage)
Ejemplo n.º 2
0
    def parse_description(self):

        def gotPage(x):
            self.debug("got device description from %r" % self.location)
            data, headers = x
            xml_data = None
            try:
                xml_data = utils.parse_xml(data, 'utf-8')
            except:
                self.warning("Invalid device description received from %r", self.location)
                import traceback
                self.debug(traceback.format_exc())
            
            if xml_data is not None:
                tree = xml_data.getroot()
                major = tree.findtext('./{%s}specVersion/{%s}major' % (ns,ns))
                minor = tree.findtext('./{%s}specVersion/{%s}minor' % (ns,ns))
                try:
                    self.upnp_version = '.'.join((major,minor))
                except:
                    self.upnp_version = 'n/a'
                try:
                    self.urlbase = tree.findtext('./{%s}URLBase' % ns)
                except:
                    import traceback
                    self.debug(traceback.format_exc())
    
                d = tree.find('./{%s}device' % ns)
                if d is not None:
                    self.parse_device(d) # root device

        def gotError(failure, url):
            self.warning("error getting device description from %r", url)
            self.info(failure)

        utils.getPage(self.location).addCallbacks(gotPage, gotError, None, None, [self.location], None)
Ejemplo n.º 3
0
 def gotLanguageSet(result):
     data,headers = result
     # No authentication to be performed
     if username is None:
         return           
     # Log in
     login_form = {
             'current_form': 'loginForm',
             'next':        '/',
             'action_login':    '******',
             'username':    username,
             'password':    password,
     }
     postdata = urlencode(login_form)
     d = getPage(self._LOGIN_URL, method='POST', postdata=postdata, headers=std_headers)
     d.addCallbacks(gotLoggedInPage, gotLoginError)
Ejemplo n.º 4
0
    def update_data(self,rss_url,container=None,encoding="utf-8"):
        """ creates a deferred chain to retrieve the rdf file,
            parse and extract the metadata and reschedule itself
        """

        def fail(f):
            self.info("fail %r", f)
            self.debug(f.getTraceback())
            return f

        dfr = getPage(rss_url)
        dfr.addCallback(parse_xml, encoding=encoding)
        dfr.addErrback(fail)
        dfr.addCallback(self.parse_data,container)
        dfr.addErrback(fail)
        dfr.addBoth(self.queue_update,rss_url,container)
        return dfr
Ejemplo n.º 5
0
    def callRemote(self, soapmethod, arguments):
        soapaction = soapmethod or self.soapaction
        if '#' not in soapaction:
            soapaction = '#'.join((self.namespace[1],soapaction))
        self.action = soapaction.split('#')[1]

        self.info("callRemote %r %r %r %r", self.soapaction, soapmethod, self.namespace, self.action)

        headers = { 'content-type': 'text/xml ;charset="utf-8"',
                    'SOAPACTION': '"%s"' % soapaction,}
        if arguments.has_key('headers'):
            headers.update(arguments['headers'])
            del arguments['headers']

        payload = soap_lite.build_soap_call("{%s}%s" % (self.namespace[1], self.action), arguments,
                                            encoding=None)

        self.info("callRemote soapaction: ", self.action,self.url)
        self.debug("callRemote payload: ", payload)

        def gotError(error, url):
            self.warning("error requesting url %r" % url)
            self.debug(error)
            try:
                tree = parse_xml(error.value.response)
                body = tree.find('{http://schemas.xmlsoap.org/soap/envelope/}Body')
                return failure.Failure(Exception("%s - %s" % (body.find('.//{urn:schemas-upnp-org:control-1-0}errorCode').text,
                                                    body.find('.//{urn:schemas-upnp-org:control-1-0}errorDescription').text)))
            except:
                import traceback
                self.debug(traceback.format_exc())
            return error

        return getPage(self.url, postdata=payload, method="POST",
                        headers=headers
                      ).addCallbacks(self._cbGotResult, gotError, None, None, [self.url], None)
Ejemplo n.º 6
0
    def _real_extract(self, url):
        # Extract video id from URL
        mobj = re.match(self._VALID_URL, url)
        if mobj is None:
            self._downloader.trouble(u'ERROR: invalid URL: %s' % url)
            return
        video_id = mobj.group(2)

        # Downloader parameters
        best_quality = False
        format_param = None
        video_extension = None
        
        quality_index = 0
        if self._downloader is not None:
            params = self._downloader.params
            format_param = params.get('format', None)
            if format_param == '0':
                format_param = self._available_formats[quality_index]
                best_quality = True
        video_extension = self._video_extensions.get(format_param, 'flv')
 
        # video info
        video_info_url = 'http://www.youtube.com/get_video_info?&video_id=%s&el=detailpage&ps=default&eurl=&gl=US&hl=en' % video_id
        if format_param is not None:
            video_info_url = '%s&fmt=%s' % (video_info_url, format_param)

        def gotPage(result, format_param, video_extension):
            video_info_webpage,headers = result
            
            # check format
            if (format_param == '22'):
                print "Check if HD video exists..."
                mobj = re.search(r'var isHDAvailable = true;', video_info_webpage)
                if mobj is None:
                    print "No HD video -> switch back to SD"
                    format_param = '18'
                else:
                    print "...HD video OK!"

            # "t" param
            mobj = re.search(r'(?m)&token=([^&]+)(?:&|$)', video_info_webpage)
            if mobj is None:
            	# Attempt to see if YouTube has issued an error message
                mobj = re.search(r'(?m)&reason=([^&]+)(?:&|$)', video_info_webpage)
                if mobj is None:
                	self.to_stderr(u'ERROR: unable to extract "t" parameter')
                	print video_info_webpage
                	return [None]
                else:
                    reason = unquote_plus(mobj.group(1))
                    self.to_stderr(u'ERROR: YouTube said: %s' % reason.decode('utf-8'))
            
            token = unquote(mobj.group(1))
            video_real_url = 'http://www.youtube.com/get_video?video_id=%s&t=%s&eurl=&el=detailpage&ps=default&gl=US&hl=en' % (video_id, token)
            if format_param is not None:
                video_real_url = '%s&fmt=%s' % (video_real_url, format_param)
            
            # uploader
            mobj = re.search(r'(?m)&author=([^&]+)(?:&|$)', video_info_webpage)
            if mobj is None:
                self._downloader.trouble(u'ERROR: unable to extract uploader nickname')
                return
            video_uploader = unquote(mobj.group(1))
            
            # title
            mobj = re.search(r'(?m)&title=([^&]+)(?:&|$)', video_info_webpage)
            if mobj is None:
                self._downloader.trouble(u'ERROR: unable to extract video title')
                return
            video_title = unquote(mobj.group(1))
            video_title = video_title.decode('utf-8')
            video_title = re.sub(ur'(?u)&(.+?);', self.htmlentity_transform, video_title)
            video_title = video_title.replace(os.sep, u'%')
            
            # simplified title
            simple_title = re.sub(ur'(?u)([^%s]+)' % simple_title_chars, ur'_', video_title)
            simple_title = simple_title.strip(ur'_')
            
            # Return information
            return [{
                'id':		video_id.decode('utf-8'),
                'url':		video_real_url.decode('utf-8'),
                'uploader':	video_uploader.decode('utf-8'),
                'title':	video_title,
                'stitle':	simple_title,
                'ext':		video_extension.decode('utf-8'),
                }]

        def gotError(error):
            print "Unable to process Youtube request: %s" % url
            print "Error: %s" % error
            return [None]

        d = getPage(video_info_url, headers=std_headers)
        d.addCallback(gotPage, format_param, video_extension)
        d.addErrback(gotError)
        return d
Ejemplo n.º 7
0
    def parse_actions(self):

        def gotPage(x):
            #print "gotPage"
            #print x
            self.scpdXML, headers = x
            tree = utils.parse_xml(self.scpdXML, 'utf-8').getroot()
            ns = "urn:schemas-upnp-org:service-1-0"

            for action_node in tree.findall('.//{%s}action' % ns):
                name = action_node.findtext('{%s}name' % ns)
                arguments = []
                for argument in action_node.findall('.//{%s}argument' % ns):
                    arg_name = argument.findtext('{%s}name' % ns)
                    arg_direction = argument.findtext('{%s}direction' % ns)
                    arg_state_var = argument.findtext('{%s}relatedStateVariable' % ns)
                    arguments.append(action.Argument(arg_name, arg_direction,
                                                     arg_state_var))
                self._actions[name] = action.Action(self, name, 'n/a', arguments)

            for var_node in tree.findall('.//{%s}stateVariable' % ns):
                send_events = var_node.attrib.get('sendEvents','yes')
                name = var_node.findtext('{%s}name' % ns)
                data_type = var_node.findtext('{%s}dataType' % ns)
                values = []
                """ we need to ignore this, as there we don't get there our
                    {urn:schemas-beebits-net:service-1-0}X_withVendorDefines
                    attibute there
                """
                for allowed in var_node.findall('.//{%s}allowedValue' % ns):
                    values.append(allowed.text)
                instance = 0
                self._variables.get(instance)[name] = variable.StateVariable(self, name,
                                                               'n/a',
                                                               instance, send_events,
                                                               data_type, values)
                """ we need to do this here, as there we don't get there our
                    {urn:schemas-beebits-net:service-1-0}X_withVendorDefines
                    attibute there
                """
                self._variables.get(instance)[name].has_vendor_values = True


            #print 'service parse:', self, self.device
            self.detection_completed = True
            louie.send('Coherence.UPnP.Service.detection_completed', sender=self.device, device=self.device)
            self.info("send signal Coherence.UPnP.Service.detection_completed for %r" % self)
            """
            if (self.last_time_updated == None):
                if( self.id.endswith('AVTransport') or
                    self.id.endswith('RenderingControl')):
                    louie.send('Coherence.UPnP.DeviceClient.Service.notified', sender=self.device, service=self)
                    self.last_time_updated = time.time()
            """

        def gotError(failure, url):
            self.warning('error requesting', url)
            self.info('failure', failure)
            louie.send('Coherence.UPnP.Service.detection_failed', self.device, device=self.device)

        #print 'getPage', self.get_scpd_url()
        utils.getPage(self.get_scpd_url()).addCallbacks(gotPage, gotError, None, None, [self.get_scpd_url()], None)