def test_urlencode(self): assert utils.urlencode({'foo': 'bar', 'skipped': (), 'a param with space': 'value', 'x': 'a value with space'}) == \ 'a+param+with+space=value&foo=bar&x=a+value+with+space' assert utils.urlencode({'a': u'foo', 'b': u'\u4f60\u597d', 'c': '\xe4\xbd\xa0\xe5\xa5\xbd', u'\u4f60\u597d': 'd'}) == \ 'a=foo&b=%E4%BD%A0%E5%A5%BD' + \ '&c=%E4%BD%A0%E5%A5%BD&%E4%BD%A0%E5%A5%BD=d'
def url(self, path="/", attr=None): url = self.config["url"] + path if attr: url += "?" i = 0 for key in attr: if i > 0: url += "&" val = attr[key] url += utils.urlencode(key) + "=" + utils.urlencode(val) i += 1 return url
def _wrapper(self, generator="pumblr", group=None, date=None, private=0, tags=None, slug=None, **kw): """ Write API. Arguments: - `generator`: A short description of the application - `group`: Post this to a secondary blog on your account - `date`: (optional) - The post date - `private`: (optional) 1 or 0. Whether the post is private. - `tags`: (optional) Comma-separated list of post tags. - `slug`: (optional) A custom string to appear in the post's URL \n """ url = "http://www.tumblr.com/api/write" if group is not None: group = group if "." in group else "%s.tumblr.com" % group query = dict( email=self._email, password=self._password, generator=generator, group=group, date=date, private=private, tags=tags, slug=slug, ) query.update(f(self, **kw)) if not "type" in query.keys(): raise PumblrError("post type is needed!") self._check_status_code(url, utils.urlencode(query))
def update_query_param( request, *remove, **add, ): return request.path + urlencode( _add_query_param(_remove_query_param(request.query, *remove), **add))
def openRequestUrl(url, params, files): if len(files.get()) == 0: try: paramsdict = params.get() sanitized_params = {} for k, v in paramsdict.items(): if hasattr(k, 'encode'): key = k.encode('utf-8') elif hasattr(k, 'decode'): key = k.decode('utf-8').encode('utf-8') else: key = str(k).encode('utf-8') if hasattr(v, 'encode'): val = v.encode('utf-8') elif hasattr(k, 'decode'): val = v.decode('utf-8').encode('utf-8') else: val = str(v).encode('utf-8') sanitized_params[key] = val f = urllib.urlopen(url, urlencode(sanitized_params)) #except Exception, e: except Exception as e: raise KalturaClientException(e, KalturaClientException.ERROR_CONNECTION_FAILED) else: fullParams = params fullParams.update(files) datagen, headers = multipart_encode(fullParams.get()) request = urllib2.Request(url, datagen, headers) try: f = urllib2.urlopen(request) except Exception as e: raise KalturaClientException(e, KalturaClientException.ERROR_CONNECTION_FAILED) return f
def authorize(self): ''' Makes an authorization request. ''' if not self._discovered: print('Need to discover authorization and token endpoints.') return headers = {'Content-Type': 'application/x-www-form-urlencoded'} payload = {'client_id': self.client_id, 'scope': ' '.join(self.scopes)} encoded = urlencode(payload) r = requests.request('POST', self._device_auth_endpoint, data=encoded, headers=headers) j = r.json() r.close() if 'error' in j: raise RuntimeError(j['error']) self._device_code = j['device_code'] self.user_code = j['user_code'] self.verification_url = j['verification_url'] self._interval = j['interval'] self._code_expires_in = j['expires_in'] self._authorization_started = True message = 'Use code %s at %s to authorize the device.' % ( self.user_code, self.verification_url) print(message)
def openRequestUrl(url, params, files): if len(files.get()) == 0: try: paramsdict = params.get() sanitized_params = {} for k, v in paramsdict.items(): if hasattr(k, 'encode'): key = k.encode('utf-8') elif hasattr(k, 'decode'): key = k.decode('utf-8').encode('utf-8') else: key = str(k).encode('utf-8') if hasattr(v, 'encode'): val = v.encode('utf-8') elif hasattr(k, 'decode'): val = v.decode('utf-8').encode('utf-8') else: val = str(v).encode('utf-8') sanitized_params[key] = val f = urllib.urlopen(url, urlencode(sanitized_params)) #except Exception, e: except Exception as e: raise KalturaClientException( e, KalturaClientException.ERROR_CONNECTION_FAILED) else: fullParams = params fullParams.update(files) datagen, headers = multipart_encode(fullParams.get()) request = urllib2.Request(url, datagen, headers) try: f = urllib2.urlopen(request) except Exception as e: raise KalturaClientException( e, KalturaClientException.ERROR_CONNECTION_FAILED) return f
def events(self, limit=5): # Calendar id is part of the endpoint iself. endpoint = 'https://www.googleapis.com/calendar/v3/calendars/primary/events' start_time = today_rfc3339(hours_offset=-1) token = self.device_auth.token() authorization = 'Bearer %s' % (token) headers = { 'Authorization': authorization, 'Accept': 'application/json' } payload = { 'maxResults': limit, 'orderBy': 'startTime', 'singleEvents': 'true', 'timeMin': start_time, 'key': API_KEY } encoded = urlencode(payload) full_url = '%s?%s' % (endpoint, encoded) r = requests.request('GET', full_url, headers=headers) j = r.json() r.close() if 'error' in j: raise RuntimeError(j) return self._parse_calendar_events(j)
def delete(self, post_id): """ Deleting post Arguments: - `post_id`: The integer ID of the post you wish to delete. """ url = "http://www.tumblr.com/api/delete" query = {"email": self._email, "password": self._password, "post-id": post_id} self._check_status_code(url, utils.urlencode(query))
def prepare_request(self, method, uri, params=None, headers=None, data=None, json=None): params = {} if params is None else params if not isinstance(params, dict): raise TypeError('params should be dict') method = method.upper() params = encoded_dict(params) logger.debug(uri) url = '/'.join([ self.api_server.strip(), self.endpoint.strip().strip('/'), self.version.strip().strip('/') ]) + uri.strip() logger.debug(url) url_parsed = urlparse(url) enc_params = urlencode(params) logger.debug(enc_params) if url_parsed.query is None or url_parsed.query == '': query = enc_params else: query = '%s&%s' % (url_parsed.query, enc_params) real_uri = urlunparse(('', '', url_parsed.path, url_parsed.params, query, url_parsed.fragment)) real_url = urlunparse( (url_parsed.scheme, url_parsed.netloc, url_parsed.path, url_parsed.params, query, url_parsed.fragment)) self.request_data.host = url_parsed.netloc self.request_data.uri = real_uri self.request_data.method = method self.request_data.headers = { 'Accept': 'application/json; charset=utf-8' } if headers is not None: # headers 是字典 self.request_data.headers.update(headers) if method == 'GET': self.request_data.body = '' else: if json is not None: self.request_data.headers[ 'Content-Type'] = 'application/json; charset=utf-8' self.request_data.body = json_util.dumps(json, ensure_ascii=False) else: self.request_data.body = data return real_url
def plugin_widgetlisting(pluginpath, sublevel=""): """get all nodes in a plugin listing""" widgets = [] if sublevel: media_array = kodi_json('Files.GetDirectory', { "directory": pluginpath, "media": "files" }) else: if not getCondVisibility("System.HasAddon(%s)" % pluginpath): return [] media_array = kodi_json('Files.GetDirectory', { "directory": "plugin://%s" % pluginpath, "media": "files" }) for item in media_array: log_msg("skinshortcuts widgets processing: %s" % (item["file"])) content = item["file"] label = item["label"] # extendedinfo has some login-required widgets, skip those if ("script.extendedinfo" in pluginpath and not EXTINFO_CREDS and ("info=starred" in content or "info=rated" in content or "info=account" in content)): continue if item.get("filetype", "") == "file": continue mutils = MetadataUtils() media_type = mutils.detect_plugin_content(item["file"]) del mutils if media_type == "empty": continue if media_type == "folder": content = "plugin://script.skin.helper.service?action=widgets&path=%s&sublevel=%s" % ( urlencode(item["file"]), label) # add reload param for widgets if "reload=" not in content: if "movies" in content: reloadstr = "&reload=$INFO[Window(Home).Property(widgetreload-movies)]" elif "episodes" in content: reloadstr = "&reload=$INFO[Window(Home).Property(widgetreload-episodes)]" elif "tvshows" in content: reloadstr = "&reload=$INFO[Window(Home).Property(widgetreload-tvshows)]" elif "musicvideos" in content: reloadstr = "&reload=$INFO[Window(Home).Property(widgetreload-musicvideos)]" elif "albums" in content or "songs" in content or "artists" in content: reloadstr = "&reload=$INFO[Window(Home).Property(widgetreload-music)]" else: reloadstr = "&reload=$INFO[Window(Home).Property(widgetreload)]"\ "$INFO[Window(Home).Property(widgetreload2)]" content = content + reloadstr content = content.replace("&limit=100", "&limit=25") widgets.append([label, content, media_type]) if pluginpath == "script.extendedinfo" and not sublevel: # some additional entrypoints for extendedinfo... widgets += extendedinfo_youtube_widgets() return widgets
def auth(self, email, password): """validate credentials""" self._email = email self._password = password self._authenticated = False url = "http://www.tumblr.com/api/authenticate" query = dict(email=self._email, password=self._password) text = self._check_status_code(url, utils.urlencode(query)) self._check_we_ll_be_back(text) self._authenticated = True
def post(self, request, *args, **kwargs): """Sends the user to the deletion page with a valid signature.""" del request, args, kwargs # unused self.enforce_xsrf(self.ACTION_ID) action = ('delete', self.params.id) path = '/delete?' + utils.urlencode({ 'id': self.params.id, 'signature': reveal.sign(action), }) return django.shortcuts.redirect( self.build_absolute_uri(path, self.env.repo))
def prepare_form_encoded_body(params): """Prepare the Form-Encoded Body. Per `section 3.5.2`_ of the spec. params: OAuth parameters and data (i.e. POST data). .. _`section 3.5.2`: http://tools.ietf.org/html/rfc5849#section-3.5.2 """ return urlencode(params)
def add_kts_mobile_flavor(client, kaltura_id): payload = kts_mobile_flavor_payload.copy() payload['ks'] = client.getKs() settings = properties.load_kaltura_settings().get(kaltura_id) url = "%s/api_v3/" % settings['SERVICE_URL'] data = urlencode(payload) req = urllib2.Request(url, data) response = urllib2.urlopen(req).read() contentxml = ET.fromstring(response) flavor_id = contentxml.find('./result/id').text return flavor_id
def dashboard(self, start=0, num=20, type=None, likes=0): """ Dashboard reading. Arguments: - `start`: The post offset to start from. The default is 0. - `num`: The number of posts to return. The default is 20, and the maximum is 50. - `type`: The type of posts to return. If unspecified or empty, all types of posts are returned. Must be one of text, quote, photo, link, chat, video, or audio. - `likes`: (optional) 1 or 0, default 0. If 1, liked posts will have the liked="true" attribute. """ url = "http://www.tumblr.com/api/dashboard/json" query = dict(email=self._email, password=self._password, start=start, num=num, likes=likes, type=type) return ApiRead.parse(self._read_json_data(url, utils.urlencode(query)))
def getServeUrl(self): if len(self.callsQueue) != 1: return None (url, params, _) = self.getRequestParams() # reset state self.callsQueue = [] self.multiRequest = False result = '%s&%s' % (url, urlencode(params.get())) self.log("Returned url [%s]" % result) return result
def __request(method, url, params={}, headers={}, auth=None, callback=None): # Encode URL url_parts = url.split("\\?") url = url_parts[0].replace(" ", "%20") if len(url_parts) == 2: url += "?" + url_parts[1] # Lowercase header keys headers = dict((k.lower(), v) for k, v in headers.iteritems()) headers["user-agent"] = USER_AGENT data, post_headers = utils.urlencode(params) if post_headers is not None: headers = dict(headers.items() + post_headers.items()) headers['Accept-encoding'] = 'gzip' if auth is not None: if len(auth) == 2: user = auth[0] password = auth[1] encoded_string = base64.b64encode(user + ':' + password) headers['Authorization'] = "Basic " + encoded_string headers = dict(headers.items() + _defaultheaders.items()) _unirestResponse = None if _httplib == "urlfetch": res = urlfetch.fetch(url, payload=data, headers=headers, method=method, deadline=_timeout) _unirestResponse = UnirestResponse(res.status_code, res.headers, res.content) else: req = urllib2.Request(url, data, headers) req.get_method = lambda: method try: response = urllib2.urlopen(req, timeout=_timeout) _unirestResponse = UnirestResponse(response.code, response.headers, response.read()) except urllib2.HTTPError, e: response = e _unirestResponse = UnirestResponse(response.code, response.headers, response.read()) except urllib2.URLError, e: _unirestResponse = UnirestResponse(0, {}, str(e.reason))
def check_authorization_complete(self, sleep_duration_seconds=5, max_attempts=10): ''' Polls until completion of an authorization request. ''' if not self._authorization_started: print('Start an authorization request.') return headers = {'Content-Type': 'application/x-www-form-urlencoded'} payload = { 'client_id': self.client_id, 'client_secret': self.client_secret, 'device_code': self._device_code, 'grant_type': 'urn:ietf:params:oauth:grant-type:device_code' } encoded = urlencode(payload) current_attempt = 0 while not self.authorized and current_attempt < max_attempts: current_attempt = current_attempt + 1 r = requests.request('POST', self._token_endpoint, data=encoded, headers=headers) j = r.json() r.close() if 'error' in j: if j['error'] == 'authorization_pending': print('Pending authorization. ') time.sleep(sleep_duration_seconds) elif j['error'] == 'access_denied': print('Access denied') raise RuntimeError(j['error']) else: self._access_token = j['access_token'] self._token_acquired_at = int(time.time()) self._token_expires_in = j['expires_in'] self._token_scope = j['scope'] self._token_type = j['token_type'] self._refresh_token = j['refresh_token'] print('Completed authorization') self._authorization_completed = True saved = self.save() if not saved: print('Unable to save auth state.')
def add_flavor_to_default_conversion_profile(client, flavor_id, kaltura_id): def_cp = client.conversionProfile.getDefault() settings = properties.load_kaltura_settings().get(kaltura_id) cp_id = def_cp.id cp_flavorParamsIds = def_cp.flavorParamsIds + u',{}'.format(flavor_id) url = "{}/api_v3/?service=conversionProfile&action=update".format( settings['SERVICE_URL']) payload = {} payload['ks'] = client.getKs() payload['id'] = cp_id payload['conversionProfile:flavorParamsIds'] = cp_flavorParamsIds data = urlencode(payload) req = urllib2.Request(url, data) response = urllib2.urlopen(req).read() if "<error>" in response: raise Exception(response)
def _formulate_get(self, path, params=None): """Return URL and headers for a GET request. This is similar to _formulate_change, except parameters are encoded into the URL. :param path: Path to the object to issue a GET on. :param params: Optional dict of parameter values. :return: A tuple: URL and headers for the request. """ url = self._make_url(path) if params is not None and len(params) > 0: url += "?" + urlencode(params.items()) headers = {} self.auth.sign_request(url, headers) return url, headers
def get_sitting_urls(assembly_id, div_id, sessionurl): root = get.webpage(get.htmltree(sessionurl)) js_calls = [parse_js_call(j) for j in root.xpath('.//a/@href')] params = match_name_codes(js_calls, filter='mainsearch2', type='sessions') nsittings = len(params) params['j'] = str(nsittings) urls = [] for i in range(nsittings): params['SES_NUM'] = params['SES_NUM%s' % i] url = '%s&%s' % (sessionurl, urlencode(params)) # TODO: generalize me url = url.replace('con_search2', 'con_search3') urls.append({'session_name': params['SES_NUM'], 'url': url}) return urls
def build_absolute_path(self, path=None, repo=None, params=None): """Builds an absolute path, including the path prefix if required. Django's HttpRequest objects have a similar function, but we implement our own so that we can handle path prefixes correctly when they're in use. Args: path (str, optional): A path beginning with a slash (may include a query string), e.g., '/abc?x=y'. If the path argument is not specified or is None, the current request's path will be used. repo (str, optional): A repo ID. If specified, the path will be considered relative to the repo's route. If this is specified, path must also be specified. params (list, optional): A list of tuples of query param keys and values to add to the path. Returns: str: An absolute path, including the sitewide OPTIONAL_PATH_PREFIX if it was used with the original request (e.g., '/personfinder/abc?x=y'). Does not preserve query parameters from the original request. """ if path is None: assert not repo # request.path will already include the path prefix if it's being # used. return self.request.path assert path[0] == '/' if repo: path = '/%s%s' % (repo, path) if self._request_is_for_prefixed_path(): res = '/%s%s' % (site_settings.OPTIONAL_PATH_PREFIX, path) else: res = path if params: url_parts = list(urlparse.urlparse(res)) url_params = dict(urlparse.parse_qsl(url_parts[4])) for key, value in params: if value is None: if key in url_params: del (url_params[key]) else: url_params[key] = value url_parts[4] = utils.urlencode(url_params) res = urlparse.urlunparse(url_parts) return res
def build_absolute_path(self, path=None, repo=None, params=None): """Builds an absolute path, including the path prefix if required. Django's HttpRequest objects have a similar function, but we implement our own so that we can handle path prefixes correctly when they're in use. Args: path (str, optional): A path beginning with a slash (may include a query string), e.g., '/abc?x=y'. If the path argument is not specified or is None, the current request's path will be used. repo (str, optional): A repo ID. If specified, the path will be considered relative to the repo's route. If this is specified, path must also be specified. params (list, optional): A list of tuples of query param keys and values to add to the path. Returns: str: An absolute path, including the sitewide OPTIONAL_PATH_PREFIX if it was used with the original request (e.g., '/personfinder/abc?x=y'). Does not preserve query parameters from the original request. """ if path is None: assert not repo # request.path will already include the path prefix if it's being # used. return self.request.path assert path[0] == '/' if repo: path = '/%s%s' % (repo, path) if self._request_is_for_prefixed_path(): res = '/%s%s' % (site_settings.OPTIONAL_PATH_PREFIX, path) else: res = path if params: url_parts = list(urlparse.urlparse(res)) url_params = dict(urlparse.parse_qsl(url_parts[4])) for key, value in params: if value is None: if key in url_params: del(url_params[key]) else: url_params[key] = value url_parts[4] = utils.urlencode(url_params) res = urlparse.urlunparse(url_parts) return res
def token(self, force_refresh=False): ''' Fetches a valid access token. ''' if not self._authorization_completed: print('Complete an authorization request') return buffer = 10 * 60 * -1 # 10 min in seconds now = int(time.time()) is_valid = now < (self._token_acquired_at + self._token_expires_in + buffer) if not is_valid or force_refresh: print('Token expired. Refreshing access tokens.') headers = {'Content-Type': 'application/x-www-form-urlencoded'} payload = { 'client_id': self.client_id, 'client_secret': self.client_secret, 'refresh_token': self._refresh_token, 'grant_type': 'refresh_token' } encoded = urlencode(payload) r = requests.request('POST', self._token_endpoint, data=encoded, headers=headers) status_code = r.status_code j = r.json() r.close() if status_code == 400: print('Unable to refresh tokens.') raise (RuntimeError('Unable to refresh tokens.')) print('Updated access tokens.') self._access_token = j['access_token'] self._token_acquired_at = int(time.time()) self._token_expires_in = j['expires_in'] self._token_scope = j['scope'] self._token_type = j['token_type'] saved = self.save() if not saved: print('Unable to store auth state.') return self._access_token
def prepare_request(self, method, uri, params=None, headers=None, data=None, json=None): params = {} if params is None else params if not isinstance(params, dict): raise TypeError('params should be dict') method = method.upper() params = encoded_dict(params) logger.debug(uri) url = '/'.join([self.api_server.strip(), self.endpoint.strip().strip('/'), self.version.strip().strip('/')]) + uri.strip() logger.debug(url) url_parsed = urlparse(url) enc_params = urlencode(params) logger.debug(enc_params) if url_parsed.query is None or url_parsed.query == '': query = enc_params else: query = '%s&%s' % (url_parsed.query, enc_params) real_uri = urlunparse(('', '', url_parsed.path, url_parsed.params, query, url_parsed.fragment)) real_url = urlunparse((url_parsed.scheme, url_parsed.netloc, url_parsed.path, url_parsed.params, query, url_parsed.fragment)) self.request_data.host = url_parsed.netloc self.request_data.uri = real_uri self.request_data.method = method self.request_data.headers = { 'Accept': 'application/json; charset=utf-8' } if headers is not None: # headers 是字典 self.request_data.headers.update(headers) if method == 'GET': self.request_data.body = '' else: if json is not None: self.request_data.headers['Content-Type'] = 'application/json; charset=utf-8' self.request_data.body = json_util.dumps(json, ensure_ascii=False) else: self.request_data.body = data return real_url
def __request(method, url, params={}, headers={}, auth=None, callback=None): # Encode URL url_parts = url.split("\\?") url = url_parts[0].replace(" ", "%20") if len(url_parts) == 2: url += "?" + url_parts[1] # Lowercase header keys headers = dict((k.lower(), v) for k, v in headers.iteritems()) headers["user-agent"] = USER_AGENT data, post_headers = utils.urlencode(params) if post_headers is not None: headers = dict(headers.items() + post_headers.items()) headers['Accept-encoding'] = 'gzip' if auth is not None: if len(auth) == 2: user = auth[0] password = auth[1] encoded_string = base64.b64encode(user + ':' + password) headers['Authorization'] = "Basic " + encoded_string headers = dict(headers.items() + _defaultheaders.items()) _unirestResponse = None if _httplib == "urlfetch": res = urlfetch.fetch(url, payload=data, headers=headers, method=method, deadline=_timeout) _unirestResponse = UnirestResponse(res.status_code, res.headers, res.content) else: req = urllib2.Request(url, data, headers) req.get_method = lambda: method try: response = urllib2.urlopen(req, timeout=_timeout) except urllib2.HTTPError, e: response = e _unirestResponse = UnirestResponse(response.code, response.url, response.headers, response.read())
def execute_request(self, path, method = 'GET', **params): params = urlencode(params) if method in ['GET', 'DELETE']: req_url = "?".join([path, params]) body = None else: req_url = path body = params.encode("utf8") req_url = "/".join([self.api_url, req_url]) if self.token: self.headers['Authorization'] = "bearer:%s" % self.token func = getattr(requests, method.lower()) response = func(req_url, data = body, headers = self.headers, verify = False) status = {} status['status'] = response.status_code content = response.text data = loads(content) return status, data
def do_find(self): req = requests.post("https://libertyvf.tv/v2/recherche/", "categorie=films&mot_search=" + utils.urlencode(self.title), headers=LiberttVfFinder.HEAD) dom = etree.HTML(req.content) out = [] for elem in (dom.xpath('//div[@class="bloc-generale"]')): if elem.findall('h2'): f = Film("libertyvf.tv") f.title = elem.findall('h2/a')[0].text[13:] f.url = elem.findall('h2/a')[0].get("href") f.year = int( elem.xpath( ".//a[contains(@href, 'https://libertyvf.tv/films/annee/')]" )[0].text[8:]) out.append(f) return out
def prepare_request_uri_query(params, url): """Prepare the Request URI Query. Per `section 3.5.3`_ of the spec. params: OAuth parameters and data (i.e. POST data). url: The request url. Query components will be removed. .. _`section 3.5.3`: http://tools.ietf.org/html/rfc5849#section-3.5.3 """ # convert dict to list of tuples if isinstance(params, dict): params = params.items() # append OAuth params to the existing set of query components sch, net, path, par, query, fra = urlparse(url) queryparams = parse_qsl(query, True) queryparams.extend(params) queryparams.sort(key=lambda i: i[0].startswith("oauth_")) query = urlencode(queryparams) return urlunparse((sch, net, path, par, query, fra))
def get_session_urls(assembly_id, div_id, listurl): def searchform(root, num=''): return root.xpath('.//form[@name="searchform%s"]/@action' % num)[0] root = get.webpage(get.htmltree(listurl)) js_calls = [parse_js_call(j) for j in root.xpath('.//a/@href')] params = match_name_codes(js_calls, filter='mainsearch', type='committees') nsessions = len(params)/2 params['i'] = str(nsessions) params['div'] = str(div_id) params['DAE_NUM'] = str(assembly_id) urls = [] for i in range(nsessions): params['COMM_NAME'] = params['COMM_NAME%s' % i] params['COMM_CODE'] = params['COMM_CODE%s' % i] urls.append(\ {'committee': params['COMM_NAME'], 'url': '%s/content/%s?%s' %\ (BASEURL, searchform(root)[:-2], urlencode(params))}) return urls
def get_session_urls(assembly_id, div_id, listurl): def searchform(root, num=''): return root.xpath('.//form[@name="searchform%s"]/@action' % num)[0] root = get.webpage(get.htmltree(listurl)) js_calls = [parse_js_call(j) for j in root.xpath('.//a/@href')] params = match_name_codes(js_calls, filter='mainsearch', type='committees') nsessions = len(params) / 2 params['i'] = str(nsessions) params['div'] = str(div_id) params['DAE_NUM'] = str(assembly_id) urls = [] for i in range(nsessions): params['COMM_NAME'] = params['COMM_NAME%s' % i] params['COMM_CODE'] = params['COMM_CODE%s' % i] urls.append(\ {'committee': params['COMM_NAME'], 'url': '%s/content/%s?%s' %\ (BASEURL, searchform(root)[:-2], urlencode(params))}) return urls
def get(self): self.require_user() nickname = self.request.get('nickname', '') next = self.request.get('next', '') duration = utils.describe_delta( datetime.timedelta(0, int(self.request.get('duration', '0')))) if not nickname: self.render('templates/register.html', next=next, duration=duration, nickname=self.user.nickname().split('@')[0]) else: # Then proceed to the OAuth authorization page. parameters = { 'scope': latitude.LatitudeOAuthClient.SCOPE, 'domain': model.Config.get('oauth_consumer_key'), 'granularity': 'best', 'location': 'current' } callback_url = self.request.host_url + '/_oauth_callback?' + \ utils.urlencode(nickname=nickname, next=next) oauth_webapp.redirect_to_authorization_page( self, latitude.LatitudeOAuthClient(utils.oauth_consumer), callback_url, parameters)
def reblog(self, post_id, reblog_key, comment=None, reblog_as=None, group=None): """ Reblogging post. Arguments: - `post_id`: The integer ID of the post to reblog. - `reblog_key`: The corresponding reblog_key value from the post's read data. - `comment`: (optional) Text, HTML, or Markdown string (see format) of the commentary added to the reblog. - `reblog_as`: (optional) Reblog as a different format from the original post. - `group`: (optional) Post this to a secondary blog on your account. """ if group is not None: group = group if "." in group else "%s.tumblr.com" % group url = "http://www.tumblr.com/api/reblog" query = { "email": self._email, "password": self._password, "post-id": post_id, "reblog-key": reblog_key, "group": group, "comment": comment, "as": reblog_as, } self._check_status_code(url, utils.urlencode(query))
def _formulate_change(self, path, params, as_json=False): """Return URL, headers, and body for a non-GET request. This is similar to _formulate_get, except parameters are encoded as a multipart form body. :param path: Path to the object to issue a GET on. :param params: A dict of parameter values. :param as_json: Encode params as application/json instead of multipart/form-data. Only use this if you know the API already supports JSON requests. :return: A tuple: URL, headers, and body for the request. """ url = self._make_url(path) if 'op' in params: params = dict(params) op = params.pop('op') url += '?' + urlencode([('op', op)]) if as_json: body, headers = encode_json_data(params) else: body, headers = encode_multipart_data(params, {}) self.auth.sign_request(url, headers) return url, headers, body
def do_find(self): req = requests.post( "https://www.zone-warez.com/index.php?do=search", "do=search&subaction=search&search_start=0&full_search=1&result_from=1&story=" + utils.urlencode(self.title) + "&titleonly=0&searchuser=&replyless=0&replylimit=0&searchdate=0&beforeafter=after&sortby=date&resorder=desc&showposts=1&catlist%5B%5D=2&user_hash=636b4560bb73a51b506836d8293f5770506a68d0", headers=ZoneTelechargementFinder.HEAD) print(req.content) dom = etree.HTML(req.content) out = [] for elem in (dom.xpath('//div[@class="mov"]')): try: f = Film("https://www.zone-warez.com/") f.year = int(elem.findall('.//div[@class="mov-m"]/a')[0].text) f.langue = elem.findall( './/span[@class="langue"]/b')[0].text.strip() f.title = elem.findall('a[@class="mov-t nowrap"]')[0].get( "title") f.url = elem.findall('a[@class="mov-t nowrap"]')[0].get("href") out.append(f) except: pass return out
def get_url(**kwargs): return '{0}?{1}'.format(_url, utils.urlencode(kwargs))
def getcast(self): """helper to get all cast for a given media item""" db_id = None all_cast = [] all_cast_names = list() cache_str = "" download_thumbs = self.params.get("downloadthumbs", "") == "true" extended_cast_action = self.params.get("castaction", "") == "extendedinfo" tmdb = Tmdb() movie = self.params.get("movie") tvshow = self.params.get("tvshow") episode = self.params.get("episode") movieset = self.params.get("movieset") try: # try to parse db_id if movieset: cache_str = "movieset.castcache-%s-%s" % (self.params["movieset"], download_thumbs) db_id = int(movieset) elif tvshow: cache_str = "tvshow.castcache-%s-%s" % (self.params["tvshow"], download_thumbs) db_id = int(tvshow) elif movie: cache_str = "movie.castcache-%s-%s" % (self.params["movie"], download_thumbs) db_id = int(movie) elif episode: cache_str = "episode.castcache-%s-%s" % (self.params["episode"], download_thumbs) db_id = int(episode) except Exception: pass cachedata = self.cache.get(cache_str) if cachedata: # get data from cache all_cast = cachedata else: # retrieve data from json api... if movie and db_id: all_cast = self.kodi_db.movie(db_id)["cast"] elif movie and not db_id: filters = [{"operator": "is", "field": "title", "value": movie}] result = self.kodi_db.movies(filters=filters) all_cast = result[0]["cast"] if result else [] elif tvshow and db_id: all_cast = self.kodi_db.tvshow(db_id)["cast"] elif tvshow and not db_id: filters = [{"operator": "is", "field": "title", "value": tvshow}] result = self.kodi_db.tvshows(filters=filters) all_cast = result[0]["cast"] if result else [] elif episode and db_id: all_cast = self.kodi_db.episode(db_id)["cast"] elif episode and not db_id: filters = [{"operator": "is", "field": "title", "value": episode}] result = self.kodi_db.episodes(filters=filters) all_cast = result[0]["cast"] if result else [] elif movieset: if not db_id: for item in self.kodi_db.moviesets(): if item["title"].lower() == movieset.lower(): db_id = item["setid"] if db_id: json_result = self.kodi_db.movieset(db_id, include_set_movies_fields=["cast"]) if "movies" in json_result: for movie in json_result["movies"]: all_cast += movie["cast"] # optional: download missing actor thumbs if all_cast and download_thumbs: for cast in all_cast: if cast.get("thumbnail"): cast["thumbnail"] = get_clean_image(cast.get("thumbnail")) if not cast.get("thumbnail"): artwork = tmdb.get_actor(cast["name"]) cast["thumbnail"] = artwork.get("thumb", "") # lookup tmdb if item is requested that is not in local db if not all_cast: tmdbdetails = {} if movie and not db_id: tmdbdetails = tmdb.search_movie(movie) elif tvshow and not db_id: tmdbdetails = tmdb.search_tvshow(tvshow) if tmdbdetails.get("cast"): all_cast = tmdbdetails["cast"] # save to cache self.cache.set(cache_str, all_cast) # process listing with the results... for cast in all_cast: if cast.get("name") not in all_cast_names: liz = xbmcgui.ListItem(label=cast.get("name"), label2=cast.get("role"), iconImage=cast.get("thumbnail")) if extended_cast_action: url = "RunScript(script.extendedinfo,info=extendedactorinfo,name=%s)" % cast.get("name") url = "plugin://script.skin.helper.service/?action=launch&path=%s" % url is_folder = False else: url = "RunScript(script.skin.helper.service,action=getcastmedia,name=%s)" % cast.get("name") url = "plugin://script.skin.helper.service/?action=launch&path=%s" % urlencode(url) is_folder = False all_cast_names.append(cast.get("name")) liz.setThumbnailImage(cast.get("thumbnail")) xbmcplugin.addDirectoryItem(handle=int(sys.argv[1]), url=url, listitem=liz, isFolder=is_folder) xbmcplugin.endOfDirectory(int(sys.argv[1]))
def update_backgrounds(self): '''update all our provided backgrounds''' # conditional background self.win.setProperty("SkinHelper.ConditionalBackground", get_cond_background()) # movies backgrounds if xbmc.getCondVisibility("Library.HasContent(movies)"): # random/all movies self.set_background("SkinHelper.AllMoviesBackground", "videodb://movies/titles/", label=32010) # in progress movies self.set_background( "SkinHelper.InProgressMoviesBackground", "videodb://movies/titles/?xsp=%s" % urlencode( '{"limit":50,"order":{"direction":"ascending","method":"random"},' '"rules":{"and":[{"field":"inprogress","operator":"true","value":[]}]},"type":"movies"}' ), label=32012) # recent movies self.set_background("SkinHelper.RecentMoviesBackground", "videodb://recentlyaddedmovies/", label=32011) # unwatched movies self.set_background( "SkinHelper.UnwatchedMoviesBackground", "videodb://movies/titles/?xsp=%s" % urlencode( '{"limit":50,"order":{"direction":"ascending","method":"random"},' '"rules":{"and":[{"field":"playcount","operator":"is","value":0}]},"type":"movies"}' ), label=32013) # tvshows backgrounds if xbmc.getCondVisibility("Library.HasContent(tvshows)"): # random/all tvshows self.set_background("SkinHelper.AllTvShowsBackground", "videodb://tvshows/titles/", label=32014) # in progress tv shows self.set_background( "SkinHelper.InProgressShowsBackground", "videodb://tvshows/titles/?xsp=%s" % urlencode( '{"limit":50,"order":{"direction":"ascending","method":"random"},' '"rules":{"and":[{"field":"inprogress","operator":"true","value":[]}]},"type":"tvshows"}' ), label=32016) # recent episodes self.set_background("SkinHelper.RecentEpisodesBackground", "videodb://recentlyaddedepisodes/", label=32015) # all musicvideos if xbmc.getCondVisibility("Library.HasContent(musicvideos)"): self.set_background("SkinHelper.AllMusicVideosBackground", "videodb://musicvideos/titles", label=32018) # all music if xbmc.getCondVisibility("Library.HasContent(music)"): # music artists self.set_background("SkinHelper.AllMusicBackground", "musicdb://artists/", label=32019) # recent albums self.set_background("SkinHelper.RecentMusicBackground", "musicdb://recentlyaddedalbums/", label=32023) # random songs self.set_background("SkinHelper.AllMusicSongsBackground", "musicdb://songs/", label=32022) # tmdb backgrounds (extendedinfo) if xbmc.getCondVisibility("System.HasAddon(script.extendedinfo)"): self.set_background( "SkinHelper.TopRatedMovies", "plugin://script.extendedinfo/?info=topratedmovies", label=32020) self.set_background( "SkinHelper.TopRatedShows", "plugin://script.extendedinfo/?info=topratedtvshows", label=32021) # pictures background self.set_background("SkinHelper.PicturesBackground", "pictures", label=32017) # pvr background if xbmc.getCondVisibility("PVR.HasTvChannels"): self.set_background("SkinHelper.PvrBackground", "pvr", label=32024) # smartshortcuts backgrounds for node in self.smartshortcuts.get_smartshortcuts_nodes(): self.set_background(node[0], node[1], label=node[2]) # global backgrounds self.set_global_background("SkinHelper.GlobalFanartBackground", [ "SkinHelper.AllMoviesBackground", "SkinHelper.AllTvShowsBackground", "SkinHelper.AllMusicVideosBackground", "SkinHelper.AllMusicBackground" ], label=32009) self.set_global_background("SkinHelper.AllVideosBackground", [ "SkinHelper.AllMoviesBackground", "SkinHelper.AllTvShowsBackground", "SkinHelper.AllMusicVideosBackground" ], label=32025) self.set_global_background("SkinHelper.AllVideosBackground2", [ "SkinHelper.AllMoviesBackground", "SkinHelper.AllTvShowsBackground" ], label=32026) self.set_global_background("SkinHelper.RecentVideosBackground", [ "SkinHelper.RecentMoviesBackground", "SkinHelper.RecentEpisodesBackground" ], label=32027) self.set_global_background("SkinHelper.InProgressVideosBackground", [ "SkinHelper.InProgressMoviesBackground", "SkinHelper.InProgressShowsBackground" ], label=32028)
def __request(method, url, params={}, headers={}, auth=None, callback=None): # Encode URL url_parts = url.split("\\?") url = url_parts[0].replace(" ", "%20") if len(url_parts) == 2: url += "?" + url_parts[1] # Lowercase header keys headers = dict((k.lower(), v) for k, v in headers.iteritems()) headers["user-agent"] = USER_AGENT data, post_headers = utils.urlencode(params) if post_headers is not None: headers = dict(headers.items() + post_headers.items()) headers['Accept-encoding'] = 'gzip' if auth is not None: if len(auth) == 2: user = auth[0] password = auth[1] encoded_string = base64.b64encode(user + ':' + password) headers['Authorization'] = "Basic " + encoded_string headers = dict(headers.items() + _defaultheaders.items()) _unirestResponse = None if _httplib == "urlfetch": res = urlfetch.fetch(url, payload=data, headers=headers, method=method, deadline=_timeout) _unirestResponse = UnirestResponse(res.status_code, res.headers, res.content) else: # Retry if there's a connection failure. response = None error = None for i in range(0, 3): req = urllib2.Request(url, data, headers) req.get_method = lambda: method try: # context = ssl._create_unverified_context() response = urllib2.urlopen(req, timeout=_timeout) except urllib2.HTTPError as e: response = e except urllib2.URLError as e: error = e continue except socket.error as e: error = e continue except Exception as e: error = e break break if response is not None: _unirestResponse = UnirestResponse(response.code, response.headers, response.read()) else: _unirestResponse = error if callback is None or callback == {}: return _unirestResponse else: callback(_unirestResponse)
def execute_initiate(self, request, **kwargs): return self.services[kwargs["service"]].oauth_initiate(config.url + "/authorization/" + kwargs["service"] + "/callback/?from=" + urlencode(request.referrer or config.url))
def add_query_param(request, **params): return request.path + urlencode(_add_query_param(request.query, **params))
def remove_query_param(request, *params): return request.path + urlencode(_remove_query_param( request.query, *params))
def getcast(self): '''helper to get all cast for a given media item''' db_id = None all_cast = [] all_cast_names = list() cache_str = "" download_thumbs = self.params.get("downloadthumbs", "") == "true" extended_cast_action = self.params.get("castaction", "") == "extendedinfo" movie = self.params.get("movie") tvshow = self.params.get("tvshow") episode = self.params.get("episode") movieset = self.params.get("movieset") try: # try to parse db_id if movieset: cache_str = "movieset.castcache-%s-%s" % ( self.params["movieset"], download_thumbs) db_id = int(movieset) elif tvshow: cache_str = "tvshow.castcache-%s-%s" % (self.params["tvshow"], download_thumbs) db_id = int(tvshow) elif movie: cache_str = "movie.castcache-%s-%s" % (self.params["movie"], download_thumbs) db_id = int(movie) elif episode: cache_str = "episode.castcache-%s-%s" % ( self.params["episode"], download_thumbs) db_id = int(episode) except Exception: pass cachedata = self.cache.get(cache_str) if cachedata: # get data from cache all_cast = cachedata else: # retrieve data from json api... if movie and db_id: all_cast = self.mutils.kodidb.movie(db_id)["cast"] elif movie and not db_id: filters = [{ "operator": "is", "field": "title", "value": movie }] result = self.mutils.kodidb.movies(filters=filters) all_cast = result[0]["cast"] if result else [] elif tvshow and db_id: all_cast = self.mutils.kodidb.tvshow(db_id)["cast"] elif tvshow and not db_id: filters = [{ "operator": "is", "field": "title", "value": tvshow }] result = self.mutils.kodidb.tvshows(filters=filters) all_cast = result[0]["cast"] if result else [] elif episode and db_id: all_cast = self.mutils.kodidb.episode(db_id)["cast"] elif episode and not db_id: filters = [{ "operator": "is", "field": "title", "value": episode }] result = self.mutils.kodidb.episodes(filters=filters) all_cast = result[0]["cast"] if result else [] elif movieset: if not db_id: for item in self.mutils.kodidb.moviesets(): if item["title"].lower() == movieset.lower(): db_id = item["setid"] if db_id: json_result = self.mutils.kodidb.movieset( db_id, include_set_movies_fields=["cast"]) if "movies" in json_result: for movie in json_result['movies']: all_cast += movie['cast'] # optional: download missing actor thumbs if all_cast and download_thumbs: for cast in all_cast: if cast.get("thumbnail"): cast["thumbnail"] = self.mutils.get_clean_image( cast.get("thumbnail")) if not cast.get("thumbnail"): artwork = self.mutils.tmdb.get_actor(cast["name"]) cast["thumbnail"] = artwork.get("thumb", "") # lookup tmdb if item is requested that is not in local db if not all_cast: tmdbdetails = {} if movie and not db_id: tmdbdetails = self.mutils.tmdb.search_movie(movie) elif tvshow and not db_id: tmdbdetails = self.mutils.tmdb.search_tvshow(tvshow) if tmdbdetails.get("cast"): all_cast = tmdbdetails["cast"] # save to cache self.cache.set(cache_str, all_cast) # process listing with the results... for cast in all_cast: if cast.get("name") not in all_cast_names: liz = xbmcgui.ListItem(label=cast.get("name"), label2=cast.get("role"), iconImage=cast.get("thumbnail")) if extended_cast_action: url = "RunScript(script.extendedinfo,info=extendedactorinfo,name=%s)" % cast.get( "name") url = "plugin://script.skin.helper.service/?action=launch&path=%s" % url is_folder = False else: url = "RunScript(script.skin.helper.service,action=getcastmedia,name=%s)" % cast.get( "name") url = "plugin://script.skin.helper.service/?action=launch&path=%s" % urlencode( url) is_folder = False all_cast_names.append(cast.get("name")) liz.setThumbnailImage(cast.get("thumbnail")) xbmcplugin.addDirectoryItem(handle=int(sys.argv[1]), url=url, listitem=liz, isFolder=is_folder) xbmcplugin.endOfDirectory(int(sys.argv[1]))
def oauth_initiate(self, callback_url): return redirect("http://api.vk.com/oauth/authorize?client_id=" + self.client_id + "&redirect_uri=" + urlencode(callback_url) + "&display=page")
def oauth_callback(self, request): if request.args.get("error") is not None: return False # TODO: import vkontakte access_token = simplejson.loads(urllib2.urlopen(urllib2.Request("https://api.vkontakte.ru/oauth/access_token?client_id=" + self.client_id + "&client_secret=" + self.client_secret + "&code=" + urlencode(request.args.get("code")))).read()) user = simplejson.loads(urllib2.urlopen(urllib2.Request("https://api.vkontakte.ru/method/getProfiles?uid=" + str(access_token["user_id"]) + "&access_token=" + access_token["access_token"] + "&fields=uid,first_name,last_name,nickname,screen_name,photo")).read())["response"][0] return (int(user["uid"]), dict(user, access_token=access_token["access_token"]))
def get_entry(media_id, kaltura_id, client=None, width=120, height=120): settings = properties.load_kaltura_settings().get(kaltura_id) error = False error_message = None entry = None try: entry = client.media.get(media_id) except Exception as inst: error_message = str(inst) error = True entryData = {} if error: entryData['success'] = False entryData['message'] = error_message else: entryData['success'] = True typelist = { KalturaMediaType.VIDEO: 'VIDEO', KalturaMediaType.IMAGE: 'IMAGE', KalturaMediaType.AUDIO: 'AUDIO', KalturaMediaType.LIVE_STREAM_FLASH: 'LIVE_STREAM_FLASH', KalturaMediaType.LIVE_STREAM_WINDOWS_MEDIA: 'LIVE_STREAM_WINDOWS_MEDIA', KalturaMediaType.LIVE_STREAM_REAL_MEDIA: 'LIVE_STREAM_REAL_MEDIA', KalturaMediaType.LIVE_STREAM_QUICKTIME: 'LIVE_STREAM_QUICKTIME' } entryData['media_type'] = typelist[entry.getMediaType().getValue()] # Urls/Accessors entryData['url'] = entry.getDataUrl() entryData['thumbnail_url_old'] = entry.getThumbnailUrl() url = "%s/api_v3/?service=thumbasset&action=list" % settings[ 'SERVICE_URL'] data = urlencode({"filter:entryIdEqual": media_id, "action": "list"}) req = urllib2.Request(url, data) content = urllib2.urlopen(req).read() entryData['ks'] = client.getKs() contentxml = ET.fromstring(content) thumb_id = '' for item in contentxml.findall('./result/objects/item'): tags = item.find('tags').text if tags and 'default_thumb' in tags: thumb_id = item.find('id').text thumbnail_url = "%s/p/%s/thumbnail/entry_id/%s" % ( settings['SERVICE_URL'], settings['PARTNER_ID'], media_id) entryData['thumbnail_url'] = thumbnail_url + \ "/width/%s/height/%s?%s" % ( width, height, int(time.time())) entryData['download_url'] = entry.getDownloadUrl() entryData['thumb_id'] = thumb_id # ViewData entryData['plays'] = entry.getPlays() entryData['views'] = entry.getViews() entryData['rank'] = (entry.getRank(), entry.getTotalRank()) # Video Properties entryData['width'] = entry.getWidth() entryData['height'] = entry.getHeight() entryData['duration'] = entry.getDuration() entryData['created'] = entry.getCreatedAt() entryData['updated'] = entry.getUpdatedAt() # Video Data entryData['name'] = entry.getName() entryData['description'] = entry.getDescription() entryData['tags'] = entry.getTags() # Search Text entryData['searchtext'] = entry.getSearchText() # Control entryData['startDate'] = entry.getStartDate() entryData['endDate'] = entry.getEndDate() # entryData['status'] = entry.getStatus() return entryData
def read(self, name, start=0, num=20, type=None, id=None, search=None, tagged=None): """ Reading Tumblr data. Arguments: - `name`: username - `start`: The post offset to start from. The default is 0. - `num`: The number of posts to return. The default is 20, and the maximum is 50. - `type`: (optional) The type of posts to return. If unspecified or empty, all types of posts are returned. Must be one of text, quote, photo, link, chat, video, or audio. - `id`: A specific post ID to return. Use instead of start, num, or type. - `search`: Search for posts with this query. - `tagged`: Return posts with this tag in reverse-chronological order (newest first). """ if id is not None: query = dict(id=id) else: query = dict(start=start, num=num, type=type, search=search, tagged=tagged) url = "http://%s/api/read/json?%s" % ((name if "." in name else "%s.tumblr.com" % name), utils.urlencode(query)) # url = "http://%s.tumblr.com/api/read/json?%s" % (name, utils.urlencode(query)) return ApiRead.parse(self._read_json_data(url))
def _like_unlike(self, post_id, reblog_key, like): url = "http://www.tumblr.com/api/%s" % ("like" if like else "unlike") query = {"email": self._email, "password": self._password, "post-id": post_id, "reblog-key": reblog_key} self._check_status_code(url, utils.urlencode(query))
def oauth_initiate(self, callback_url): return redirect("%(homepage)s/api/auth/?api_key=%(api)s&cb=%(callback_url)s" % { "homepage" : self.network.homepage, "api" : self.api_key, "callback_url" : urlencode(callback_url), })