def create_event(language):
r = sr.Recognizer()
with sr.Microphone() as source:
# Título
reproduction_audio('titulo_agenda', language)
audio = r.listen(source)
titulo = r.recognize_google(audio, language=language)
# Data
reproduction_audio('data_agenda', language)
audio = r.listen(source)
data = r.recognize_google(audio, language=language)
title = input('Título do evento: ')
date_and_hour = input('Data e hora (AAAA-MM-DDTHH:MM:SS): ')
date_and_hour_end = input('Data e hora (AAAA-MM-DDTHH:MM:SS): ')
date_and_hour_init = date_and_hour + '-03:00'
date_and_hour_end = date_and_hour_end + '-03:00'
print(date_and_hour_end)
event = {
'summary': title,
'start': {
'dateTime': date_and_hour_init,
},
'end': {
'dateTime': date_and_hour_end,
}
}
return event
def corona_virus(language: str) -> None:
try:
# URL do World Meters com os dados do Corona Virus
url = "https://www.worldometers.info/coronavirus/"
site = get(url) # Realizando a requisição
# Transformando a resposta em um HTML legível com BeautifulSoup
soup = BeautifulSoup(site.text, 'html.parser')
# Lista com as informações
array = soup.findAll(attrs={'class': 'maincounter-number'})
array_formated = []
# Como as informações são em inglês, transforma-se as vírgulas em pontos e acrescentado em um novo array
for text in array:
array_formated.append(text.span.text.replace(
',', '.')) # Trocando a vírgula por um ponto
# Criação da variável de áudio informativo dependendo da linguagem
if language == 'pt-br':
audio = f'Casos {array_formated[0]}, Mortes {array_formated[1]}, Recuperados {array_formated[2]}'
elif language == 'en':
audio = f'Cases {array_formated[0]}, Death {array_formated[1]}, Recovered {array_formated[2]}'
cria_audio(audio, 'cases', language) # Criação do áudio
ps(f'{path}/audios_{language}/cases.mp3') # Reprodução
os.remove(f'{path}/audios_{language}/cases.mp3'
) # Exclusão do áudio para evitar sopreposição
except:
reproduction_audio('erro', language) # Reproduz áudio de erro
def main(url: str, folder: str, message: list, language: str, speak = True) -> None:
# A variável 'speak' serve para informar se é para acionar os áudios ou não
try:
yt = YouTube(url) # Capturando os tipos de downloads
title = yt.title # Pegando o título do vídeo
title = removing_caracters_specials(title).replace(' ', '-')
stream = yt.streams.first() # Pegando todos os tipos de downloads
time = yt.length # Descobrindo o tamanho do vídeo em segundos
if(speak): reproduction_audio('baixar_musica', language)
print(message[2])
stream.download(folder+'/tmp', filename=title) # Realizando o download
print(f'{message[3]}{title}{message[4]}') # Escrevendo o download finalizado
def _thread():
# Começando a conversão de MP4 para MP3
print(message[5])
video_to_audio(folder, time, title) # Convertendo...
print(message[6])
if(speak): reproduction_audio('musica_terminada', language) # Reprodução de aúdio de sucessp
# Começando a thread de conversão de mp4 para mp3
th.start_new_thread(_thread, ())
except:
reproduction_audio('erro', language) # Aúdio de reprodução caso haja algum erro
def Main(text: str, language: str) -> None:
try:
# Removendo possíveis palavras que não são parte do nome da música
text = removing_words(text,
['song', 'música', 'acessar', 'na', 'músicas'])
# Definindo a URL de pesquisa
url = f'https://youtube.com/search?q={text}'
source = get(url).text # Requisição GET a partir da URL montada
# Salvando o resultado em .txt para poder ler as variáveis JavaScript geradas
open("video.txt", "w", encoding='utf-8').write(source)
# Lendo o arquivo resultante, identificando a primeira referência para um vídeo
with open("video.txt", "r", encoding="utf-8") as src:
text = src.read() # Lendo o arquivo
"""
Procurando a primeira referência para um vídeo, localizada em um objeto JavaScript
que contém todas as informações dos vídeos a serem listados. Tal referência, tem como propriedade
"url" e a URL sempre começa com "/watch?v"
"""
init = text.index('"url":"/watch?v') # Primeiro index
fin = text[init + 7:].index(
'"'
) + init + 7 # Último index, eliminando a parte da propriedade ("url": ")
url_video = f'www.youtube.com{text[init+7:fin]}' # Definindo a url do vídeo
# Abrindo o vídeo no navegador padrão
webbrowser.open(url_video)
except:
reproduction_audio('erro', language) # Reproduz áudio de erro
def detection_portal_notas(text: str, language: str) -> None:
if detection_much_words([
'resultado escola', 'notas', 'nota', 'notes', 'notes in portal',
'note'
], text):
reproduction_audio('notas', language)
Portal_de_Notas(language)
reproduction_audio('notas_capturadas', language)
def config_functions(self, text) -> bool:
factor_return: bool = False # Criando a variável de retorno da função
if self.language == 'pt-br':
# Caso quero mudar de língua
if detection_much_words(['mudar língua', 'língua', 'quero inglês'],
text):
reproduction_audio('mudanca_lingua', self.language)
self.language = 'en'
self.att_hotword()
factor_return = True
# Caso eu queira que o programa seja encerrado
if detection_much_words(
['descansada', 'dormir', 'encerra programa'], text):
reproduction_audio('saida', 'pt-br')
sys.exit() # Encerrando o programa
elif self.language == 'en':
# Caso quero mudar de língua
if detection_much_words(
['change language', 'language like Portuguese'], text):
reproduction_audio('language_change', self.language)
self.language = 'pt-br'
self.att_hotword()
factor_return = True
# Caso eu queira que o programa seja encerrado
if detection_much_words(['quit', 'out', 'quitting'], text):
reproduction_audio('quit', 'en')
sys.exit() # Encerrando o programa
return factor_return
def Main(text: str, language: str) -> None:
try:
text = unidecode(text) # Retirando caracteres especiais
with open(f'{path}\\Texts\\Musics\\playlists.txt',
'r') as source: # Abrindo o arquivo
playist = []
# Para cada linha, adiciona os dados na lista
for line in source:
line = line.strip()
playist_aux = line.split(';')
playist.append(playist_aux)
# As linhas foram adicionadas no vetor de playist para a manipulação
linha = -1 # Definindo variável de seleção da playist
for x in range(0, len(playist)):
if playist[x][0] in text: # Verificando se a playist foi escolhida
linha = x
if linha != -1: # Se for diferente de -', quer dizer que uma playist foi escolhida na frase
url = playist[linha][2]
acrescimo(linha, playist)
else: # Se uma playist não tiver sido escolhida
size = 0
quant_cada_play = [
] # Variável para saber quanto cada playist foi tocada
for line in playist: # Descobrindo o total de vezes em que a playist foi tocada
size = int(line[1]) + size
aux_play = [] # Variável auxiliar
for x in range(0, int(line[1])):
aux_play.append(
x + 1
) # Adicionando na variável auxiliar x vezes que a playist foi tocada
quant_cada_play.append(aux_play)
random_num = random.randint(1, size -
1) # Randorizando um número inteiro
factor = 1 # O objetivo a partir daqui é aleatorizar uma playist de acordo com o número de vezes tocadas
count = 0 # Ou seja, quanto mais vezes tocadas, maior a chance de cair ela
for x in range(0, len(quant_cada_play)):
for _ in range(0, len(quant_cada_play[x])):
if factor == random_num:
count = x # Definindo a playist a ser tocada pela randorização
factor = factor + 1
url = playist[count][2]
browser.open(url) # Abrindo na web
except Exception as e:
print(e)
reproduction_audio('erro', language) # Reproduz o aúdio de erros
def Download(language: str) -> None:
# Definindo a linguagem e as mensagens a serem enviadas nos prints
if language == 'pt-br':
message = ['Qual o link da música? ', 'Qual pasta deseja colocar?', 'Começando o download',
'Download da música ', ' realizado com sucesso', 'Convertendo...', 'Finalizado!']
else:
message = ['What is the song link? ', 'Which folder?', 'Starting download', 'Song download ', ' successfully',
'Converting...', 'Finished!']
reproduction_audio('musica_baixar', language) # Reproduzindo audio
url = input(f'{message[0]}(Dê um espaço ao final para não entrar no link): ') # Obtendo o link
folder = input(message[1]) # Pegando o diretório a ser salvo
main(url, folder, message, language)
def clima(language: str) -> None:
try:
# URL da página de pesquisa do clima do Google
url = "https://www.google.com/search?sxsrf=ALeKk03XRgXBBQ0xMOdRKjfYMz17naVuJQ%3A1586300662125&ei=9gaNXumgB5Ke5OUPlcCEwAQ&q=temperatura+agora+governador+valadares&oq=temperatura+atual+de+gover&gs_lcp=CgZwc3ktYWIQAxgAMgYIABAWEB4yBQgAEM0CMgUIABDNAjIFCAAQzQIyBQgAEM0COgQIABBHOgcIIxDqAhAnOgQIIxAnOgQIABBDOgUIABCDAToCCAA6BAgAEAo6BwgAEEYQgAJKNQgXEjEwZzQ4NWczMDdnMjUwZzI1M2cyNDdnMzM0ZzI1MmcyNjRnNDM2ZzMzNGcyNDJnMjM0Sh0IGBIZMGcxZzFnMWcxZzFnMWcxZzFnMWc1ZzVnOVDbljVYsbc1YKjANWgCcAR4AYAB7QOIAco-kgEIMi0xNC4zLjiYAQCgAQGqAQdnd3Mtd2l6sAEK&sclient=psy-ab"
site = get(url) # Realizando a requisição
# Transformando a resposta em um HTML legível com BeautifulSoup
soup = BeautifulSoup(site.text, 'html.parser')
# Procurando o elemento de descrição do tempo a partir de outros que tem a mesma das suas classes
descricao = soup.findAll(attrs={'class': 'BNeawe tAd8D AP7Wnd'})
descricao = descricao[len(descricao) -
1].text # Texto do último elemento (dia atual)
# Retirando a data e o horário, sobrando somente a descrição do tempo
descricao = descricao.split('\n')[1]
# Procurando os elementos informativos de temperatura
temperatura = soup.findAll(attrs={'class': 'BNeawe iBp4i AP7Wnd'})
temperatura = temperatura[1].text # Texto do segundo elemento
# Criação do áudio informativo dependendo da linguagem
if language == 'pt-br':
cria_audio(
f'A temperatura atual é de {temperatura} e está {descricao}',
'clima', language)
else:
# Se for em inglês, como as informações são em português, é utilizado a lib do Google Translator
# para traduzir em inglês
translate = Translator()
descricao = translate.translate(descricao).text
cria_audio(
f'The current temperature is {temperatura} and is {descricao}',
'clima', language)
ps(f'{path}/audios_{language}/clima.mp3'
) # Reproduzindo o áudio criado
os.remove(f'{path}/audios_{language}/clima.mp3') # Excluindo o áudio
except:
reproduction_audio('erro', language) # Reproduz áudio de erro
def Download(language: str) -> None:
# Definindo a linguagem e as mensagens a serem enviadas nos prints
if language == 'pt-br':
message = [
'Qual o link da playlist? ',
'Qual pasta deseja colocar (com o nome título da playlist)?',
'Começando o download', 'Download da playlist ',
' realizado com sucesso', 'Convertendo...', 'Finalizado!'
]
else:
message = [
'What is the playlist link? ', 'Which folder?',
'Starting download', 'Playlist download ', ' successfully',
'Converting...', 'Finished!'
]
reproduction_audio('playlist_baixar', language) # Reproduzindo audio
url = input(
f'{message[0]}(Dê um espaço ao final para não entrar no link): '
) # Obtendo o link
folder = input(message[1]) # Pegando o diretório a ser salvo
try:
playlist = Playlist(url) # Capturando os tipos de downloads
playlist._video_regex = re.compile(
r"\"url\":\"(/watch\?v=[\w-]*)"
) # Transformando a url em algo legível para a lib
# Para cada vídeo, chama a função de baixar música, sem a opção fala
for url in playlist.video_urls:
main(url, folder, message, language, fator=False)
sleep(0.2)
# Removendo o arquivo de pasta temporário
os.remove(folder + '\\tmp')
except:
reproduction_audio(
'erro', language) # Aúdio de reprodução caso haja algum erro
def Main(text: str, language: str) -> None:
reproduction_audio('acessar_pesquisa', language)
padrao = "[0-9]{1,2}" # Descobrindo o número de guias por expressões regulares
retorno = re.findall(
padrao, text
) # Achando todos os números, sendo que o último será o número de abas
num_guias = int(retorno[len(retorno) - 1]) # Defifindo o número de guias
list_words = ['abas', 'aba', 'guias',
'guia'] # Lista de palavras com o significado de abas
list_artigos = ['no', 'em', 'na'] # Artigos
for word in list_words:
if word in text:
source_index = text.index(
word
) # Saber qual indice da string está a palavra abas, para separa em duas
text = text[:source_index] # Separando o text em duas
source = text[source_index:] # Parte da fonte do text
text = text.replace(str(num_guias),
'').strip() # Remodulando a variável text
source = removing_words(source, list_words)
source = removing_words(source, list_artigos) # Descobrindo a fonte pedida
if detection_much_words(
list_artigos,
text[len(text) -
3:]): # Caso a ultima palavra seja um artigo, ela é retirada
text = removing_words(text, list_artigos)
if source == '': # Caso não tenha informado a fonte, será o google
source = 'google'
for url in search(f'"{text}"{source}',
stop=num_guias): # Descobrindo os sites pela lib
browser.open(url) # Acessando as url's
def Download(language: str) -> None:
# Definindo a linguagem e as mensagens a serem enviadas nos prints
if language == 'pt-br':
message = [
'Qual o link do vídeo? ', 'Qual pasta?', 'Começando o download',
'Download do vídeo ', ' realizado com sucesso'
]
else:
message = [
'What is the video link? ', 'What folder?', 'Starting download',
'Video download ', ' successfully'
]
reproduction_audio('video_baixar', language) # Reproduzindo audio
url = input(message[0]) # Obtendo o link
position = url.replace(' ', '') # Tirando o espaço final
folder = input(message[1])
try:
yt = YouTube(position) # Capturando os tipos de downloads
title = yt.title # Pegando o título do vídeo
tipos_downloads = yt.streams.filter(
progressive=True) # Pegando todos os tipos de downloads
stream = None # Definindo o meu tipo de download
# Escolhendo a melhor qualidade e o melhor FPS
qualidade = 0
fps = 0
for link in tipos_downloads:
# Verifcando se existe resolução e fps
if link.resolution is not None and link.fps is not None and link.mime_type == 'video/mp4':
# Verificando se a qualidade ou o fps eh melhor que o anterior
if int(link.resolution.replace('p', '')) >= qualidade and int(
link.fps) >= fps:
stream = link # Atribuindo o novo tipo de download
qualidade = int(link.resolution.replace(
'p', '')) # Mudando a resolução
fps = int(link.fps) # Mudando o fps
# Thread para baixar a música enquanto as ações são executadas normalmente
def thread():
print(message[2])
stream.download(folder) # Realizando o download
print(f'{message[3]}{title}{message[3]}'
) # Escrevendo o download finalizado
th.start_new_thread(thread, ()) # Inicializando a thread de download
reproduction_audio('baixar_video', language)
except:
reproduction_audio(
'erro', language) # Aúdio de reprodução caso haja algum erro
def Main(text: str, language: str) -> None:
"""
Listagem de sites possíveis com suas respectivas URL'S, se algum site pedido não
estiver na lista, reproduz o aúdio de erro
"""
sites = {
'google drive':
"https://drive.google.com/drive/u/0/my-drive",
'youtube':
"https://www.youtube.com/",
'gmail':
"https://mail.google.com/mail/u/0/#inbox",
'plural':
'https://maestro.plurall.net/?state=14795553868286406#/home',
'notas':
'http://prados101.fiemg.com.br/Corpore.Net/Login.aspx?autoload=false&ReturnUrl=%2fCorpore.Net%2fMain'
'.aspx%3fSelectedMenuIDKey%3d%26ShowMode%3d2',
'sesi':
'https://sesieducacao.com.br/publico/index.php',
'what':
'https://web.whatsapp.com/',
'alura':
'https://cursos.alura.com.br/dashboard',
'descomplica':
'https://descomplica.com.br/cursos/medicina-extensivo-completo-2020-A/inicio/',
'tradutor':
'https://www.google.com/search?q=translate&oq=tra&aqs=chrome.0.69i59l2j69i57j69i59j0j69i61l3'
'.991j0j7&sourceid=chrome&ie=UTF-8 '
}
try:
url = '' # Definindo variável de url
# Verificando se existe o site pedido na lista de URL'S
for web in sites:
if web in text:
url = sites[
web] # Se existe, define a url como a do respectivo site
# Se a URL não tiver vazia, abre no navegador
if url != '':
webbrowser.open(url)
reproduction_audio('acessar_site', language)
# Se tiver vazia, reproduz o aúdio de "erro"
else:
reproduction_audio('desculpa_site', language)
except:
reproduction_audio('erro', language) # Reproduz aúdio de erro
def Main(text: str, language: str):
reproduction_audio('acessar_pesquisa', language)
url = "https://www.google.com/search?q=" # Inicial da URL
text_search = f'{url}{text}' # Juntando com o texto a ser pesquisado
webbrowser.open(text_search) # Abrindo no navegador
def _thread():
# Começando a conversão de MP4 para MP3
print(message[5])
video_to_audio(folder, time, title) # Convertendo...
print(message[6])
if(speak): reproduction_audio('musica_terminada', language) # Reprodução de aúdio de sucessp
def detection_corona_virus(text: str, language: str) -> None:
if detection_much_words(['coronavirus', 'corona'],
text): # Casos de coronavírus
reproduction_audio('capturando_web', language)
corona_virus(language)
def Portal_de_Notas(language: str) -> None:
try:
# Definindo configurações de login
login = {'user': '******', 'password': '******'}
# URL inicial
url = "https://prados101.fiemg.com.br/Corpore.Net/Login.aspx"
# URL para identificar qual contexto educacional o aluno está, ou seja, a série
url_contexto_educacional = "http://prados101.fiemg.com.br/Corpore.Net/Source/Edu-Educacional/RM.EDU.CONTEXTO/EduSelecionarContextoModalWebForm.aspx?Qs=ActionID%3dEduNotaAvaliacaoActionWeb%26SelectedMenuIDKey%3dmnNotasAval"
# URL com as notas de cada etapa do aluno naquela série
url_notas_etapa = "http://prados101.fiemg.com.br/Corpore.Net/Main.aspx?ActionID=EduNotaEtapaActionWeb&SelectedMenuIDKey=mnNotasEtapa"
# Inicialização do driver de execução
driver = webdriver.Chrome(
executable_path=f"{path}\\Functions\\Web_Scraping\\chromedriver.exe"
)
driver.get(url) # Primeira requisição ao site de login
driver.find_element(By.NAME, 'txtUser').send_keys(
login['user']) # Preenchendo a informação do usuário
driver.find_element(By.NAME, 'txtPass').send_keys(
login['password']) # Preenchendo a informação da senha
driver.find_element(By.NAME, 'btnLogin').click() # Submetendo
# Após a submissão, escolha da atividade na página inicial, se aparecer a opção, se não, continua
try:
driver.find_element(
By.ID, 'ctl17_EDU_EduNotaEtapaActionWeb_LinkControl').click()
except:
pass
driver.get(url_contexto_educacional
) # Requisição para página de contexto educacionals
time.sleep(0.5) # Esperando um tempo para a página carregar
tr = driver.find_elements_by_id(
'rdContexto') # Escolhendo o ano escolar
tr[0].click() # Seleção do ano, no meu caso, está 2019
driver.get(
url_notas_etapa) # Requisição para página das notas das etapas
element = driver.find_element(
By.ID, 'ctl24_xgvNotasFilial_DXMainTable') # Tabela de elementos
# Transformando o elemento em HTML
element_html = element.get_attribute("outerHTML")
# Parsear conteúdo HTML
soup = BeautifulSoup(element_html, 'html.parser')
# Para cada matéria, procura das notas de cada etapa
for materia in soup.findAll(attrs={'class': 'dxgvDataRow_Edu'}):
params = [] # Lista com os parâmetros de nota
for td in materia.findAll(attrs={'class': 'dxgv'}):
params.append(
td.text
) # Para cada parâmetro de nota, acrescenta-se o respectivo texto na variável
# Impressão dos dados da matéria, sendo o sexto a Primeira Etapa, nono a Segunda, e décimo segundo a Terceira
print(
f'Matéria: {params[3]} ; Primeira Etapa: {params[5]} ; Segunda Etapa: {params[8]} ; Terceira Etapa: {params[11]}'
+ '\n')
# Abandonando o navegador
driver.quit()
except:
reproduction_audio('erro', language) # Reproduz aúdio de erro
def config_functions(self, text) -> bool:
factor_return: bool = False # Criando a variável de retorno da função
if self.language == 'pt-br':
# Caso quero mudar de língua
if detection_much_words(['mudar língua', 'língua', 'quero inglês'],
text):
reproduction_audio('mudanca_lingua', self.language)
self.language = 'en'
factor_return = True
# Caso eu queira que o programa seja encerrado
elif detection_much_words(
['descansada', 'dormir', 'encerra programa'], text):
reproduction_audio('saida', 'pt-br')
sys.exit() # Encerrando o programa
# Caso eu queira escrever manualmente o comando
elif detection_much_words(
['para texto', 'input', 'entrada de texto'], text):
reproduction_audio('input', self.language)
entrada = input('Escreva o comando: '
) # Pegando o comando na entrada do cmd
entrada = entrada.lower().strip(
) # Manipulando a string, deixando minúscula e sem espaços finais
self.functions(
entrada
) # Mandando o texto para realização do comando descrito
factor_return = True
elif self.language == 'en':
# Caso quero mudar de língua
if detection_much_words(
['change language', 'language like portuguese'], text):
reproduction_audio('language_change', self.language)
self.language = 'pt-br'
factor_return = True
# Caso eu queira que o programa seja encerrado
elif detection_much_words(['quit', 'out', 'quitting'], text):
reproduction_audio('quit', 'en')
sys.exit() # Encerrando o programa
# Caso eu queira escrever manualmente o comando
elif detection_much_words(['for text', 'text input'], text):
reproduction_audio('input', self.language)
entrada = input('Escreva o comando: '
) # Pegando o comando na entrada do cmd
entrada = entrada.lower().strip(
) # Manipulando a string, deixando minúscula e sem espaços finais
self.functions(
entrada
) # Mandando o texto para realização do comando descrito
factor_return = True
return factor_return
def detection_playist(text: str, language: str) -> None:
if detection_much_words(['playlist'],
text): # Tocando uma playist definida ou aleatória
reproduction_audio('playist_web', language)
Main(text, language)
def detection_clima(text: str, language: str) -> None:
if detection_much_words(
['tempo', 'clima', 'temperatura', 'weather', 'climate', 'temperature'],
text):
reproduction_audio('capturando_web', language)
clima(language)
def detection_acessar_musica(text: str, language: str) -> None:
if detection_much_words(['song', 'música', 'músicas'], text):
reproduction_audio('musica', language)
Main(text, language)