utils-global 0.1.0__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- automacao_utils/__init__.py +40 -0
- automacao_utils/download_utils.py +562 -0
- automacao_utils/mover_arquivo_utils.py +129 -0
- automacao_utils/notificacao_utils.py +64 -0
- automacao_utils/selenium_utils.py +17 -0
- automacao_utils/version_check.py +141 -0
- utils_global-0.1.0.dist-info/METADATA +195 -0
- utils_global-0.1.0.dist-info/RECORD +10 -0
- utils_global-0.1.0.dist-info/WHEEL +5 -0
- utils_global-0.1.0.dist-info/top_level.txt +1 -0
|
@@ -0,0 +1,40 @@
|
|
|
1
|
+
"""
|
|
2
|
+
Biblioteca de funções úteis para automações com Selenium.
|
|
3
|
+
Fornece utilitários para manipulação de arquivos, downloads e interações com Selenium.
|
|
4
|
+
"""
|
|
5
|
+
|
|
6
|
+
# Versão do pacote
|
|
7
|
+
__version__ = "1.8.2"
|
|
8
|
+
|
|
9
|
+
# Funções de Download
|
|
10
|
+
from automacao_utils.download_utils import (
|
|
11
|
+
processar_download,
|
|
12
|
+
iniciar_monitoramento,
|
|
13
|
+
aguardar_download,
|
|
14
|
+
aguardar_carregamento,
|
|
15
|
+
renomear_arquivo,
|
|
16
|
+
is_file_in_use,
|
|
17
|
+
wait_for_file_access,
|
|
18
|
+
is_temp_file_growing,
|
|
19
|
+
limpar_nome_arquivo,
|
|
20
|
+
DownloadErroException
|
|
21
|
+
)
|
|
22
|
+
|
|
23
|
+
# Funções de Selenium
|
|
24
|
+
from automacao_utils.selenium_utils import garantir_iframe
|
|
25
|
+
|
|
26
|
+
# Funções de Notificações
|
|
27
|
+
from automacao_utils.notificacao_utils import enviar_msg_teams
|
|
28
|
+
|
|
29
|
+
# Funções de Movimentação de Arquivos
|
|
30
|
+
from automacao_utils.mover_arquivo_utils import mover_arquivo
|
|
31
|
+
|
|
32
|
+
# Verificação de versão ao importar
|
|
33
|
+
try:
|
|
34
|
+
from automacao_utils.version_check import verificar_versao_mais_recente
|
|
35
|
+
verificar_versao_mais_recente(__version__)
|
|
36
|
+
except ImportError:
|
|
37
|
+
pass
|
|
38
|
+
|
|
39
|
+
# Funções públicas de verificação de versão
|
|
40
|
+
from automacao_utils.version_check import mostrar_ultima_versao
|
|
@@ -0,0 +1,562 @@
|
|
|
1
|
+
import os
|
|
2
|
+
import time
|
|
3
|
+
from watchdog.observers import Observer
|
|
4
|
+
from watchdog.events import FileSystemEventHandler
|
|
5
|
+
|
|
6
|
+
|
|
7
|
+
# Exceção personalizada para erros de download
|
|
8
|
+
class DownloadErroException(Exception):
|
|
9
|
+
"""
|
|
10
|
+
Exceção para erros durante o processo de download.
|
|
11
|
+
Contém informações sobre o erro, incluindo seletor, código e elemento específico.
|
|
12
|
+
"""
|
|
13
|
+
def __init__(self, mensagem=None, seletor_erro=None, codigo_erro=None, elemento_visivel=None):
|
|
14
|
+
self.codigo_erro = codigo_erro or "DESCONHECIDO"
|
|
15
|
+
self.seletor_erro = seletor_erro
|
|
16
|
+
self.elemento_visivel = elemento_visivel
|
|
17
|
+
self.mensagem = mensagem or f"Erro de download: {self.codigo_erro}"
|
|
18
|
+
super().__init__(self.mensagem)
|
|
19
|
+
|
|
20
|
+
def __str__(self):
|
|
21
|
+
return self.mensagem
|
|
22
|
+
|
|
23
|
+
|
|
24
|
+
class NewFileHandler(FileSystemEventHandler):
|
|
25
|
+
"""
|
|
26
|
+
Manipulador de eventos de arquivo para monitoramento de arquivos temporários.
|
|
27
|
+
|
|
28
|
+
Attributes:
|
|
29
|
+
new_file_detected (bool): Indica se um arquivo temporário foi detectado.
|
|
30
|
+
new_files (set): Conjunto de arquivos temporários detectados.
|
|
31
|
+
"""
|
|
32
|
+
def __init__(self):
|
|
33
|
+
super().__init__()
|
|
34
|
+
self.new_file_detected = False
|
|
35
|
+
self.new_files = set()
|
|
36
|
+
|
|
37
|
+
def _handle(self, path):
|
|
38
|
+
self.new_file_detected = True
|
|
39
|
+
self.new_files.add(path)
|
|
40
|
+
|
|
41
|
+
def on_created(self, event):
|
|
42
|
+
if not event.is_directory:
|
|
43
|
+
self._handle(event.src_path)
|
|
44
|
+
|
|
45
|
+
def on_moved(self, event):
|
|
46
|
+
if not event.is_directory:
|
|
47
|
+
self._handle(event.dest_path)
|
|
48
|
+
|
|
49
|
+
def on_modified(self, event):
|
|
50
|
+
if not event.is_directory:
|
|
51
|
+
self._handle(event.src_path)
|
|
52
|
+
|
|
53
|
+
|
|
54
|
+
def iniciar_monitoramento(dir_download):
|
|
55
|
+
"""
|
|
56
|
+
Inicia o monitoramento do diretório de download.
|
|
57
|
+
|
|
58
|
+
Args:
|
|
59
|
+
dir_download: Diretório de download a ser monitorado.
|
|
60
|
+
|
|
61
|
+
Returns:
|
|
62
|
+
tuple: (handler, observer) Instâncias do manipulador de eventos e observador.
|
|
63
|
+
"""
|
|
64
|
+
# Inicia o monitoramento do diretório
|
|
65
|
+
handler = NewFileHandler()
|
|
66
|
+
observer = Observer()
|
|
67
|
+
observer.schedule(handler, dir_download, recursive=False)
|
|
68
|
+
observer.start()
|
|
69
|
+
|
|
70
|
+
# Aguarda que todos os emissores estejam ativos
|
|
71
|
+
while not all(emitter.is_alive() for emitter in observer.emitters):
|
|
72
|
+
time.sleep(0.1)
|
|
73
|
+
print(" -> Monitoramento de download iniciado")
|
|
74
|
+
|
|
75
|
+
# Limpa o estado do handler
|
|
76
|
+
handler.new_file_detected = False
|
|
77
|
+
handler.new_files.clear()
|
|
78
|
+
|
|
79
|
+
return handler, observer
|
|
80
|
+
|
|
81
|
+
|
|
82
|
+
def iniciar_download(sb, btn_download, seletor_carregamento=None, iframe_carregamento=None, btn_download_js=False):
|
|
83
|
+
"""
|
|
84
|
+
Clica no botão de download para iniciar o processo.
|
|
85
|
+
|
|
86
|
+
Args:
|
|
87
|
+
sb: Instância do SeleniumBase.
|
|
88
|
+
btn_download: Elemento ou seletor para iniciar o download.
|
|
89
|
+
seletor_carregamento: Seletor para verificar carregamento.
|
|
90
|
+
iframe_carregamento: (Opcional) Seletor do iframe onde o elemento de carregamento está.
|
|
91
|
+
btn_download_js: (Opcional) Se True, usa JavaScript para clicar no botão.
|
|
92
|
+
"""
|
|
93
|
+
time.sleep(1)
|
|
94
|
+
if isinstance(btn_download, str):
|
|
95
|
+
if btn_download_js:
|
|
96
|
+
sb.js_click(f"{btn_download}")
|
|
97
|
+
else:
|
|
98
|
+
sb.click(btn_download)
|
|
99
|
+
else:
|
|
100
|
+
btn_download.click()
|
|
101
|
+
|
|
102
|
+
if seletor_carregamento:
|
|
103
|
+
aguardar_carregamento(sb, seletor_carregamento, iframe=iframe_carregamento)
|
|
104
|
+
|
|
105
|
+
|
|
106
|
+
def aguardar_download(sb, dir_download, handler, observer, seletores_erro=None, tempo_max_espera=180, intervalo=1):
|
|
107
|
+
"""
|
|
108
|
+
Aguarda a conclusão do download, monitorando a criação e finalização de arquivos temporários.
|
|
109
|
+
|
|
110
|
+
Args:
|
|
111
|
+
sb: Instância do SeleniumBase
|
|
112
|
+
dir_download: Diretório de download
|
|
113
|
+
handler: Instância do manipulador de eventos de arquivo
|
|
114
|
+
observer: Instância do observador de diretório
|
|
115
|
+
seletores_erro: Seletores para verificar erro
|
|
116
|
+
tempo_max_espera: Tempo máximo de espera em segundos
|
|
117
|
+
intervalo: Intervalo entre verificações em segundos
|
|
118
|
+
|
|
119
|
+
Returns:
|
|
120
|
+
str: Caminho do arquivo baixado.
|
|
121
|
+
|
|
122
|
+
Raises:
|
|
123
|
+
DownloadErroException: Se ocorrer algum erro durante o processo de download.
|
|
124
|
+
"""
|
|
125
|
+
TEMP_EXTENSIONS = (".crdownload", ".part", ".tmp")
|
|
126
|
+
|
|
127
|
+
|
|
128
|
+
# Aguarda a detecção de um arquivo temporário por um tempo fixo
|
|
129
|
+
tempo_inicio = time.time()
|
|
130
|
+
while not handler.new_file_detected:
|
|
131
|
+
|
|
132
|
+
if seletores_erro:
|
|
133
|
+
for seletor in seletores_erro:
|
|
134
|
+
if sb.is_element_visible(seletor):
|
|
135
|
+
console_limpar_linha()
|
|
136
|
+
|
|
137
|
+
# Obtém texto do elemento de erro
|
|
138
|
+
try:
|
|
139
|
+
texto_erro = sb.get_text(seletor) or seletor
|
|
140
|
+
except:
|
|
141
|
+
texto_erro = seletor
|
|
142
|
+
|
|
143
|
+
msg_erro = f"Elemento de erro visível durante o download: \n{'-'*50}\n{texto_erro}\n{'-'*50}"
|
|
144
|
+
|
|
145
|
+
# Lança a exceção com todos os detalhes
|
|
146
|
+
raise DownloadErroException(
|
|
147
|
+
mensagem=msg_erro,
|
|
148
|
+
codigo_erro="ELEMENTO", # Código do erro
|
|
149
|
+
elemento_visivel=seletor # Seletor específico que estava visível
|
|
150
|
+
)
|
|
151
|
+
|
|
152
|
+
if time.time() - tempo_inicio > tempo_max_espera:
|
|
153
|
+
observer.stop()
|
|
154
|
+
observer.join()
|
|
155
|
+
console_limpar_linha()
|
|
156
|
+
msg_erro = "Tempo limite excedido aguardando o início do download"
|
|
157
|
+
print(msg_erro)
|
|
158
|
+
raise Exception(msg_erro)
|
|
159
|
+
|
|
160
|
+
console_carregamento("Aguardando início do download")
|
|
161
|
+
time.sleep(intervalo)
|
|
162
|
+
|
|
163
|
+
console_limpar_linha()
|
|
164
|
+
print(" -> Download iniciado!")
|
|
165
|
+
|
|
166
|
+
# Aguarda que o download seja concluído (ou seja, até que os arquivos temporários sumam do diretório)
|
|
167
|
+
tempo_inicio_download = time.time()
|
|
168
|
+
|
|
169
|
+
while any(arquivo.endswith(TEMP_EXTENSIONS) for arquivo in os.listdir(dir_download)):
|
|
170
|
+
if seletores_erro:
|
|
171
|
+
for seletor in seletores_erro:
|
|
172
|
+
if sb.is_element_visible(seletor):
|
|
173
|
+
console_limpar_linha()
|
|
174
|
+
|
|
175
|
+
# Obtém texto do elemento de erro
|
|
176
|
+
try:
|
|
177
|
+
texto_erro = sb.get_text(seletor) or seletor
|
|
178
|
+
except:
|
|
179
|
+
texto_erro = seletor
|
|
180
|
+
|
|
181
|
+
msg_erro = f"Elemento de erro visível durante o download: \n{'-'*50}\n{texto_erro}\n{'-'*50}"
|
|
182
|
+
|
|
183
|
+
# Lança a exceção com todos os detalhes
|
|
184
|
+
raise DownloadErroException(
|
|
185
|
+
mensagem=msg_erro,
|
|
186
|
+
codigo_erro="ELEMENTO", # Código do erro
|
|
187
|
+
elemento_visivel=seletor # Seletor específico que estava visível
|
|
188
|
+
)
|
|
189
|
+
|
|
190
|
+
# Se o tempo máximo foi atingido, verificamos se o download ainda está ativo
|
|
191
|
+
if time.time() - tempo_inicio_download > tempo_max_espera:
|
|
192
|
+
# Verifica se algum arquivo ainda está crescendo
|
|
193
|
+
if is_temp_file_growing(dir_download, TEMP_EXTENSIONS, duration=20, check_interval=1):
|
|
194
|
+
console_limpar_linha()
|
|
195
|
+
print(f" -> O download ainda está em progresso, continuando a espera... ({int(time.time() - tempo_inicio_download)}s)")
|
|
196
|
+
tempo_inicio_download = time.time() # Reinicia o contador, já que ainda há progresso
|
|
197
|
+
else:
|
|
198
|
+
observer.stop()
|
|
199
|
+
observer.join()
|
|
200
|
+
console_limpar_linha()
|
|
201
|
+
|
|
202
|
+
msg_erro = "Tempo limite excedido durante o download"
|
|
203
|
+
print(msg_erro)
|
|
204
|
+
raise Exception(msg_erro)
|
|
205
|
+
|
|
206
|
+
console_carregamento("Baixando arquivo")
|
|
207
|
+
time.sleep(intervalo)
|
|
208
|
+
|
|
209
|
+
console_limpar_linha()
|
|
210
|
+
print(" -> Download concluído!")
|
|
211
|
+
|
|
212
|
+
observer.stop()
|
|
213
|
+
observer.join()
|
|
214
|
+
|
|
215
|
+
# Filtra os arquivos finais (excluindo os temporários)
|
|
216
|
+
arquivos_finais = [
|
|
217
|
+
arquivo
|
|
218
|
+
for arquivo in handler.new_files
|
|
219
|
+
if not arquivo.endswith(TEMP_EXTENSIONS)]
|
|
220
|
+
|
|
221
|
+
if arquivos_finais:
|
|
222
|
+
# Encontra o arquivo mais recente (provavelmente o que acabou de ser baixado)
|
|
223
|
+
caminho_arquivo_baixado = max(map(os.path.abspath, arquivos_finais), key=os.path.getmtime)
|
|
224
|
+
|
|
225
|
+
time.sleep(0.5)
|
|
226
|
+
|
|
227
|
+
# Verificar se o arquivo está crescendo antes de continuar
|
|
228
|
+
while is_temp_file_growing(dir_download, TEMP_EXTENSIONS, duration=5, check_interval=1):
|
|
229
|
+
console_carregamento(f"Finalizando arquivo {os.path.basename(caminho_arquivo_baixado)}")
|
|
230
|
+
|
|
231
|
+
console_limpar_linha()
|
|
232
|
+
|
|
233
|
+
# Verificar se o arquivo está disponível para acesso
|
|
234
|
+
if is_file_in_use(caminho_arquivo_baixado):
|
|
235
|
+
while is_file_in_use(caminho_arquivo_baixado):
|
|
236
|
+
console_carregamento("Aguardando liberação do arquivo")
|
|
237
|
+
time.sleep(0.5)
|
|
238
|
+
|
|
239
|
+
console_limpar_linha()
|
|
240
|
+
|
|
241
|
+
time.sleep(1)
|
|
242
|
+
|
|
243
|
+
return caminho_arquivo_baixado
|
|
244
|
+
|
|
245
|
+
else:
|
|
246
|
+
handler.new_files.clear()
|
|
247
|
+
|
|
248
|
+
msg_erro = "Nenhum arquivo detectado após o download"
|
|
249
|
+
print(msg_erro)
|
|
250
|
+
raise Exception(msg_erro)
|
|
251
|
+
|
|
252
|
+
|
|
253
|
+
def processar_download(sb, dir_download, btn_download, nome_arquivo=None, seletores_erro=None, seletor_carregamento=None, iframe_carregamento=None, btn_download_js=False):
|
|
254
|
+
"""
|
|
255
|
+
Processa o download de um arquivo, monitorando o diretório de download e renomeando o arquivo.
|
|
256
|
+
|
|
257
|
+
Args:
|
|
258
|
+
sb: Instância do SeleniumBase
|
|
259
|
+
dir_download: Diretório onde o arquivo será baixado
|
|
260
|
+
btn_download: Seletor do botão de download ou objeto clicável
|
|
261
|
+
nome_arquivo: (Opcional) Nome do arquivo após o download; se None, não será renomeado
|
|
262
|
+
seletores_erro: (Opcional) Seletor ou lista de seletores para verificar erros. Pode ser:
|
|
263
|
+
- Uma string única com um seletor: "seletor1"
|
|
264
|
+
- Uma lista de seletores: ["seletor1", "seletor2", ...]
|
|
265
|
+
seletor_carregamento: (Opcional) Seletor opcional para aguardar o carregamento desaparecer
|
|
266
|
+
iframe_carregamento: (Opcional) Seletor do iframe onde o elemento de carregamento está
|
|
267
|
+
btn_download_js: (Opcional) Se o botão de download é um objeto JavaScript
|
|
268
|
+
|
|
269
|
+
Returns:
|
|
270
|
+
str: Caminho completo para o arquivo baixado e renomeado (ou apenas baixado, se nome_arquivo for None).
|
|
271
|
+
|
|
272
|
+
Raises:
|
|
273
|
+
DownloadErroException: Se ocorrer algum erro durante o processo de download.
|
|
274
|
+
"""
|
|
275
|
+
intervalo = 1
|
|
276
|
+
|
|
277
|
+
# Normaliza seletores_erro para uma lista, se não for None
|
|
278
|
+
if seletores_erro is not None:
|
|
279
|
+
if isinstance(seletores_erro, str):
|
|
280
|
+
# Se for uma string, converte para lista com um elemento
|
|
281
|
+
seletores_erro = [seletores_erro]
|
|
282
|
+
|
|
283
|
+
# Inicia o monitoramento
|
|
284
|
+
handler, observer = iniciar_monitoramento(dir_download)
|
|
285
|
+
|
|
286
|
+
# Inicia o download
|
|
287
|
+
iniciar_download(sb, btn_download, seletor_carregamento, iframe_carregamento, btn_download_js)
|
|
288
|
+
|
|
289
|
+
# Aguarda o download ser concluído e retorna o caminho do arquivo
|
|
290
|
+
caminho_arquivo_baixado = aguardar_download(sb, dir_download, handler, observer, seletores_erro, tempo_max_espera=180, intervalo=intervalo)
|
|
291
|
+
|
|
292
|
+
# Se nome_arquivo for passado, renomeia; caso contrário, retorna o caminho original
|
|
293
|
+
if nome_arquivo:
|
|
294
|
+
caminho_final = renomear_arquivo(caminho_arquivo_baixado, nome_arquivo)
|
|
295
|
+
else:
|
|
296
|
+
caminho_final = caminho_arquivo_baixado
|
|
297
|
+
|
|
298
|
+
return caminho_final
|
|
299
|
+
|
|
300
|
+
|
|
301
|
+
|
|
302
|
+
|
|
303
|
+
def split_nome_ext(nome, tamanho_max_ext=4):
|
|
304
|
+
"""
|
|
305
|
+
Separa o nome da extensão, considerando apenas o último ponto,
|
|
306
|
+
e valida se a parte após o ponto é curta o suficiente para ser uma extensão.
|
|
307
|
+
|
|
308
|
+
Args:
|
|
309
|
+
nome (str): Nome do arquivo.
|
|
310
|
+
tamanho_max_ext (int): Tamanho máximo esperado para uma extensão (sem o ponto).
|
|
311
|
+
|
|
312
|
+
Returns:
|
|
313
|
+
tuple: (nome_sem_ext, ext) onde ext inclui o ponto, ou uma string vazia se não houver extensão.
|
|
314
|
+
"""
|
|
315
|
+
partes = nome.rsplit('.', 1)
|
|
316
|
+
if len(partes) == 2 and 1 <= len(partes[1]) <= tamanho_max_ext:
|
|
317
|
+
return partes[0], '.' + partes[1]
|
|
318
|
+
return nome, ""
|
|
319
|
+
|
|
320
|
+
|
|
321
|
+
|
|
322
|
+
def limpar_nome_arquivo(nome):
|
|
323
|
+
"""
|
|
324
|
+
Limpa o nome do arquivo, removendo caracteres inválidos e truncando o nome.
|
|
325
|
+
|
|
326
|
+
Args:
|
|
327
|
+
nome (str): Nome do arquivo.
|
|
328
|
+
|
|
329
|
+
Returns:
|
|
330
|
+
str: Nome do arquivo limpo.
|
|
331
|
+
"""
|
|
332
|
+
try:
|
|
333
|
+
# Remove caracteres inválidos para o Windows
|
|
334
|
+
caracteres_invalidos = ["<", ">", ":", "'", "/", "\\", "|", "?", "*", '"']
|
|
335
|
+
for char in caracteres_invalidos:
|
|
336
|
+
nome = nome.replace(char, " ")
|
|
337
|
+
|
|
338
|
+
# Trunca o nome do arquivo para um tamanho máximo permitido
|
|
339
|
+
nome_limpo = nome[:250] if len(nome) > 250 else nome
|
|
340
|
+
return nome_limpo.strip()
|
|
341
|
+
except Exception as e:
|
|
342
|
+
msg_erro = f"Erro ao usar a função limpar_nome_arquivo: {e}"
|
|
343
|
+
raise Exception(msg_erro)
|
|
344
|
+
|
|
345
|
+
|
|
346
|
+
|
|
347
|
+
|
|
348
|
+
def renomear_arquivo(caminho_arquivo, novo_nome):
|
|
349
|
+
"""
|
|
350
|
+
Renomeia um arquivo, permitindo renomear também a extensão se desejado.
|
|
351
|
+
|
|
352
|
+
Se 'novo_nome' já contiver uma extensão válida (por exemplo, 'arquivo.txt'),
|
|
353
|
+
essa extensão será utilizada; caso contrário, a extensão original do arquivo é mantida.
|
|
354
|
+
|
|
355
|
+
Args:
|
|
356
|
+
caminho_arquivo (str): Caminho do arquivo original.
|
|
357
|
+
novo_nome (str): Novo nome do arquivo, com ou sem extensão.
|
|
358
|
+
|
|
359
|
+
Returns:
|
|
360
|
+
str: Caminho do arquivo renomeado.
|
|
361
|
+
"""
|
|
362
|
+
import os
|
|
363
|
+
|
|
364
|
+
try:
|
|
365
|
+
diretorio_base = os.path.dirname(caminho_arquivo)
|
|
366
|
+
|
|
367
|
+
# Separa o nome e a extensão usando nossa função customizada
|
|
368
|
+
base_nome, ext_novo = split_nome_ext(novo_nome)
|
|
369
|
+
|
|
370
|
+
if not ext_novo:
|
|
371
|
+
base_nome = limpar_nome_arquivo(novo_nome)
|
|
372
|
+
ext = os.path.splitext(caminho_arquivo)[1]
|
|
373
|
+
else:
|
|
374
|
+
base_nome = limpar_nome_arquivo(base_nome)
|
|
375
|
+
ext = ext_novo
|
|
376
|
+
|
|
377
|
+
novo_nome_final = base_nome + ext
|
|
378
|
+
novo_caminho = os.path.join(diretorio_base, novo_nome_final)
|
|
379
|
+
|
|
380
|
+
contador = 1
|
|
381
|
+
while os.path.exists(novo_caminho):
|
|
382
|
+
novo_nome_final = f"{base_nome} ({contador}){ext}"
|
|
383
|
+
novo_caminho = os.path.join(diretorio_base, novo_nome_final)
|
|
384
|
+
contador += 1
|
|
385
|
+
|
|
386
|
+
os.rename(caminho_arquivo, novo_caminho)
|
|
387
|
+
print(f"Arquivo renomeado para: {novo_caminho}")
|
|
388
|
+
|
|
389
|
+
if is_file_in_use(novo_caminho):
|
|
390
|
+
print(' -> Arquivo ainda está em uso. Aguardando liberação...')
|
|
391
|
+
wait_for_file_access(novo_caminho)
|
|
392
|
+
|
|
393
|
+
return novo_caminho
|
|
394
|
+
|
|
395
|
+
except Exception as e:
|
|
396
|
+
msg_erro = f"Erro ao usar a função renomear_arquivo: {e}"
|
|
397
|
+
raise Exception(msg_erro)
|
|
398
|
+
|
|
399
|
+
|
|
400
|
+
|
|
401
|
+
# * Funções auxiliares para interface do console
|
|
402
|
+
# Variável global para controlar o estado da animação de carregamento
|
|
403
|
+
_carregamento_indice = 0
|
|
404
|
+
|
|
405
|
+
|
|
406
|
+
def console_carregamento(mensagem="Carregando", indice=None):
|
|
407
|
+
"""
|
|
408
|
+
Exibe uma mensagem de carregamento animada no console.
|
|
409
|
+
|
|
410
|
+
Args:
|
|
411
|
+
mensagem (str): Texto base da mensagem de carregamento (padrão: "Carregando")
|
|
412
|
+
indice (int, opcional): Índice de estado atual. Se None, usa o contador global sequencial.
|
|
413
|
+
|
|
414
|
+
Returns:
|
|
415
|
+
int: Próximo índice de estado para ser usado na próxima chamada (opcional)
|
|
416
|
+
"""
|
|
417
|
+
global _carregamento_indice
|
|
418
|
+
estados = ['.', '..', '...']
|
|
419
|
+
|
|
420
|
+
# Se não foi fornecido um índice, usa o contador global sequencial
|
|
421
|
+
if indice is None:
|
|
422
|
+
indice = _carregamento_indice
|
|
423
|
+
_carregamento_indice = (_carregamento_indice + 1) % len(estados)
|
|
424
|
+
else:
|
|
425
|
+
indice = indice % len(estados)
|
|
426
|
+
|
|
427
|
+
# Exibe a mensagem
|
|
428
|
+
print(f"\r{mensagem}{estados[indice]} ", end='')
|
|
429
|
+
|
|
430
|
+
# Retorna o próximo índice para quem quiser controlar a sequência manualmente
|
|
431
|
+
return (indice + 1) % len(estados)
|
|
432
|
+
|
|
433
|
+
def console_limpar_linha():
|
|
434
|
+
"""
|
|
435
|
+
Limpa a linha atual do console.
|
|
436
|
+
"""
|
|
437
|
+
print("\r" + " " * 50, end='\r') # Imprime espaços em branco e volta ao início da linha
|
|
438
|
+
|
|
439
|
+
# * Aguardar o carregamento da página
|
|
440
|
+
def aguardar_carregamento(sb, elemento, iframe=None):
|
|
441
|
+
"""
|
|
442
|
+
Aguarda o carregamento de uma página web, aguardando o elemento de carregamento ficar não visível.
|
|
443
|
+
|
|
444
|
+
Args:
|
|
445
|
+
sb: Instância do SeleniumBase.
|
|
446
|
+
elemento: Elemento ou seletor de carregamento.
|
|
447
|
+
iframe: (Opcional) Seletor do iframe onde o elemento está, se conhecido.
|
|
448
|
+
"""
|
|
449
|
+
try:
|
|
450
|
+
tempo_verificacao = 0.4 # Mudar conforme necessidade de intervalo de espera para verificação
|
|
451
|
+
contador_nao_visivel = 0
|
|
452
|
+
tempo_total = 0
|
|
453
|
+
tempo_maximo = 600 # Limite maximo de espera em segundos (mudar conforme necessidade)
|
|
454
|
+
|
|
455
|
+
# Abordagem otimizada para lidar com iframes
|
|
456
|
+
sb.switch_to_default_content()
|
|
457
|
+
|
|
458
|
+
# Se o iframe foi especificado, usa ele diretamente
|
|
459
|
+
if iframe:
|
|
460
|
+
sb.switch_to_frame(iframe)
|
|
461
|
+
|
|
462
|
+
# Loop de verificação da visibilidade do elemento
|
|
463
|
+
while contador_nao_visivel < 3 and tempo_total < tempo_maximo:
|
|
464
|
+
if not sb.is_element_visible(elemento):
|
|
465
|
+
contador_nao_visivel += 1
|
|
466
|
+
|
|
467
|
+
sb.sleep(tempo_verificacao)
|
|
468
|
+
tempo_total += tempo_verificacao
|
|
469
|
+
|
|
470
|
+
console_carregamento("Carregando")
|
|
471
|
+
|
|
472
|
+
# Limpa o console após o carregamento
|
|
473
|
+
console_limpar_linha()
|
|
474
|
+
|
|
475
|
+
# Volta para o default content, se necessário
|
|
476
|
+
sb.switch_to_default_content()
|
|
477
|
+
|
|
478
|
+
# Se o temporizador ultrapassar o tempo máximo, lança uma exceção
|
|
479
|
+
if tempo_total >= tempo_maximo:
|
|
480
|
+
raise TimeoutError(f"O tempo de espera para o elemento '{elemento}' ultrapassou o limite de {tempo_maximo} segundos.")
|
|
481
|
+
|
|
482
|
+
except Exception as e:
|
|
483
|
+
print(f"Ocorreu um erro ao aguardar carregamento: {e}")
|
|
484
|
+
|
|
485
|
+
raise
|
|
486
|
+
|
|
487
|
+
def is_file_in_use(file_path):
|
|
488
|
+
"""
|
|
489
|
+
Verifica se um arquivo está em uso por outro processo.
|
|
490
|
+
|
|
491
|
+
Args:
|
|
492
|
+
file_path (str): Caminho do arquivo para verificar.
|
|
493
|
+
|
|
494
|
+
Returns:
|
|
495
|
+
bool: True se o arquivo estiver em uso, False caso contrário.
|
|
496
|
+
"""
|
|
497
|
+
try:
|
|
498
|
+
with open(file_path, 'rb+') as file:
|
|
499
|
+
return False
|
|
500
|
+
except (IOError, PermissionError):
|
|
501
|
+
return True
|
|
502
|
+
except Exception as e:
|
|
503
|
+
print(f"Erro ao verificar se o arquivo está em uso: {e}")
|
|
504
|
+
return True # Em caso de erro, assume que o arquivo está em uso por precaução
|
|
505
|
+
|
|
506
|
+
|
|
507
|
+
def wait_for_file_access(file_path, max_retries=30, retry_interval=1):
|
|
508
|
+
"""
|
|
509
|
+
Aguarda até que um arquivo esteja disponível para acesso.
|
|
510
|
+
|
|
511
|
+
Args:
|
|
512
|
+
file_path (str): Caminho do arquivo para verificar.
|
|
513
|
+
max_retries (int): Número máximo de tentativas.
|
|
514
|
+
retry_interval (float): Intervalo entre as tentativas em segundos.
|
|
515
|
+
|
|
516
|
+
Returns:
|
|
517
|
+
bool: True se o arquivo estiver disponível, False caso contrário.
|
|
518
|
+
"""
|
|
519
|
+
retry_count = 0
|
|
520
|
+
while retry_count < max_retries:
|
|
521
|
+
if not is_file_in_use(file_path):
|
|
522
|
+
return True
|
|
523
|
+
print(f" -> Arquivo {os.path.basename(file_path)} está em uso. Aguardando... ({retry_count + 1}/{max_retries})")
|
|
524
|
+
time.sleep(retry_interval)
|
|
525
|
+
retry_count += 1
|
|
526
|
+
|
|
527
|
+
print(f" -> Timeout atingido. Arquivo {os.path.basename(file_path)} continua em uso após {max_retries} tentativas.")
|
|
528
|
+
return False
|
|
529
|
+
|
|
530
|
+
def is_temp_file_growing(directory, temp_extensions=(".crdownload", ".part", ".tmp"), duration=10, check_interval=1):
|
|
531
|
+
"""
|
|
532
|
+
Verifica se algum arquivo temporário dentro do diretório ainda está crescendo.
|
|
533
|
+
|
|
534
|
+
Args:
|
|
535
|
+
directory (str): Diretório a ser monitorado.
|
|
536
|
+
temp_extensions (tuple): Extensões de arquivos temporários que indicam um download em andamento.
|
|
537
|
+
duration (int): Tempo total para verificar crescimento (segundos).
|
|
538
|
+
check_interval (int): Intervalo entre verificações (segundos).
|
|
539
|
+
|
|
540
|
+
Returns:
|
|
541
|
+
bool: True se algum arquivo temporário ainda estiver crescendo, False caso contrário.
|
|
542
|
+
"""
|
|
543
|
+
temp_files = [os.path.join(directory, f) for f in os.listdir(directory) if f.endswith(temp_extensions)]
|
|
544
|
+
|
|
545
|
+
if not temp_files:
|
|
546
|
+
return False # Nenhum arquivo temporário encontrado, então não há crescimento
|
|
547
|
+
|
|
548
|
+
file_sizes = {file: os.path.getsize(file) for file in temp_files}
|
|
549
|
+
|
|
550
|
+
for _ in range(int(duration / check_interval)):
|
|
551
|
+
time.sleep(check_interval)
|
|
552
|
+
growing = False
|
|
553
|
+
for file in temp_files:
|
|
554
|
+
if os.path.exists(file): # Verifica se o arquivo ainda existe
|
|
555
|
+
new_size = os.path.getsize(file)
|
|
556
|
+
if new_size > file_sizes[file]: # O arquivo está crescendo
|
|
557
|
+
growing = True
|
|
558
|
+
file_sizes[file] = new_size # Atualiza o tamanho para a próxima checagem
|
|
559
|
+
if growing:
|
|
560
|
+
return True # Se algum arquivo temporário cresceu, o download ainda está em andamento
|
|
561
|
+
|
|
562
|
+
return False # Se nenhum arquivo temporário cresceu dentro do período, o download pode ter parado
|
|
@@ -0,0 +1,129 @@
|
|
|
1
|
+
import os
|
|
2
|
+
import shutil
|
|
3
|
+
|
|
4
|
+
def mover_arquivo(diretorio_origem, diretorio_destino, nome_arquivo=None, substituir=True, max_arquivos=10):
|
|
5
|
+
"""
|
|
6
|
+
Copia um arquivo do diretório de origem para o diretório de destino e exclui o arquivo original.
|
|
7
|
+
|
|
8
|
+
Args:
|
|
9
|
+
diretorio_origem: Caminho completo do arquivo a ser movido ou diretório de origem.
|
|
10
|
+
diretorio_destino: Caminho do diretório de destino.
|
|
11
|
+
nome_arquivo: Nome específico do arquivo a ser movido (opcional).
|
|
12
|
+
Se None e diretorio_origem for um arquivo, usa o nome do arquivo no caminho.
|
|
13
|
+
Se None e diretorio_origem for um diretório, move todos os arquivos do diretório.
|
|
14
|
+
substituir: Se True, substitui o arquivo de destino caso já exista um com o mesmo nome.
|
|
15
|
+
Se False (padrão), adiciona um contador no nome do arquivo caso já exista.
|
|
16
|
+
max_arquivos: Número máximo de arquivos que podem ser movidos em uma única operação.
|
|
17
|
+
Se for mover mais arquivos que este limite, será solicitada uma confirmação.
|
|
18
|
+
|
|
19
|
+
Returns:
|
|
20
|
+
Lista de caminhos dos arquivos no diretório de destino.
|
|
21
|
+
"""
|
|
22
|
+
|
|
23
|
+
try:
|
|
24
|
+
arquivos_movidos = []
|
|
25
|
+
arquivos_para_mover = []
|
|
26
|
+
|
|
27
|
+
# Verifica se diretorio_origem é um arquivo
|
|
28
|
+
if os.path.isfile(diretorio_origem):
|
|
29
|
+
# Extrai o nome do arquivo do caminho completo
|
|
30
|
+
nome_arquivo_origem = os.path.basename(diretorio_origem)
|
|
31
|
+
diretorio_origem_base = os.path.dirname(diretorio_origem)
|
|
32
|
+
|
|
33
|
+
# Define o caminho de destino
|
|
34
|
+
caminho_destino = os.path.join(diretorio_destino, nome_arquivo_origem)
|
|
35
|
+
|
|
36
|
+
# Usa o nome_arquivo se fornecido
|
|
37
|
+
if nome_arquivo:
|
|
38
|
+
caminho_destino = os.path.join(diretorio_destino, nome_arquivo)
|
|
39
|
+
|
|
40
|
+
# Verifica se o arquivo já existe no destino
|
|
41
|
+
nome_base, extensao = os.path.splitext(os.path.basename(caminho_destino))
|
|
42
|
+
contador = 1
|
|
43
|
+
if not substituir:
|
|
44
|
+
while os.path.exists(caminho_destino):
|
|
45
|
+
novo_nome = f"{nome_base} ({contador}){extensao}"
|
|
46
|
+
caminho_destino = os.path.join(diretorio_destino, novo_nome)
|
|
47
|
+
contador += 1
|
|
48
|
+
|
|
49
|
+
arquivos_para_mover.append((diretorio_origem, caminho_destino))
|
|
50
|
+
|
|
51
|
+
# Se diretorio_origem é um diretório
|
|
52
|
+
elif os.path.isdir(diretorio_origem):
|
|
53
|
+
# Se um nome de arquivo específico foi fornecido
|
|
54
|
+
if nome_arquivo:
|
|
55
|
+
caminho_origem = os.path.join(diretorio_origem, nome_arquivo)
|
|
56
|
+
if os.path.exists(caminho_origem):
|
|
57
|
+
caminho_destino = os.path.join(diretorio_destino, nome_arquivo)
|
|
58
|
+
|
|
59
|
+
# Verifica se o arquivo já existe no destino
|
|
60
|
+
if not substituir:
|
|
61
|
+
contador = 1
|
|
62
|
+
nome_base, extensao = os.path.splitext(nome_arquivo)
|
|
63
|
+
while os.path.exists(caminho_destino):
|
|
64
|
+
novo_nome = f"{nome_base} ({contador}){extensao}"
|
|
65
|
+
caminho_destino = os.path.join(diretorio_destino, novo_nome)
|
|
66
|
+
contador += 1
|
|
67
|
+
|
|
68
|
+
arquivos_para_mover.append((caminho_origem, caminho_destino))
|
|
69
|
+
else:
|
|
70
|
+
print(f"Arquivo não encontrado: {caminho_origem}")
|
|
71
|
+
|
|
72
|
+
# Se nenhum nome de arquivo específico foi fornecido, move todos os arquivos
|
|
73
|
+
else:
|
|
74
|
+
arquivos = [f for f in os.listdir(diretorio_origem) if os.path.isfile(os.path.join(diretorio_origem, f))]
|
|
75
|
+
|
|
76
|
+
if not arquivos:
|
|
77
|
+
print(f"Nenhum arquivo encontrado no diretório de origem: {diretorio_origem}")
|
|
78
|
+
return []
|
|
79
|
+
|
|
80
|
+
for arquivo in arquivos:
|
|
81
|
+
caminho_origem = os.path.join(diretorio_origem, arquivo)
|
|
82
|
+
caminho_destino = os.path.join(diretorio_destino, arquivo)
|
|
83
|
+
|
|
84
|
+
# Verifica se o arquivo já existe no destino
|
|
85
|
+
if not substituir:
|
|
86
|
+
contador = 1
|
|
87
|
+
nome_base, extensao = os.path.splitext(arquivo)
|
|
88
|
+
while os.path.exists(caminho_destino):
|
|
89
|
+
novo_nome = f"{nome_base} ({contador}){extensao}"
|
|
90
|
+
caminho_destino = os.path.join(diretorio_destino, novo_nome)
|
|
91
|
+
contador += 1
|
|
92
|
+
|
|
93
|
+
arquivos_para_mover.append((caminho_origem, caminho_destino))
|
|
94
|
+
else:
|
|
95
|
+
raise Exception(f"O caminho especificado não existe: {diretorio_origem}")
|
|
96
|
+
|
|
97
|
+
# Verifica o número de arquivos a serem movidos
|
|
98
|
+
num_arquivos = len(arquivos_para_mover)
|
|
99
|
+
if num_arquivos == 0:
|
|
100
|
+
return []
|
|
101
|
+
|
|
102
|
+
# Verifica se excede o limite e precisa de confirmação
|
|
103
|
+
if num_arquivos > max_arquivos:
|
|
104
|
+
print(f"Arquivos a serem movidos ({num_arquivos}):")
|
|
105
|
+
for idx, (origem, destino) in enumerate(arquivos_para_mover, 1):
|
|
106
|
+
print(f"{idx}. {origem} -> {destino}")
|
|
107
|
+
|
|
108
|
+
resposta = input(f"ATENÇÃO: Você está prestes a mover {num_arquivos} arquivos, o que excede o limite de {max_arquivos}. Deseja continuar? (s/n): ").lower()
|
|
109
|
+
if resposta != 's':
|
|
110
|
+
print("Operação cancelada pelo usuário.")
|
|
111
|
+
return []
|
|
112
|
+
|
|
113
|
+
# Verifica se o diretório de destino existe
|
|
114
|
+
if not os.path.exists(diretorio_destino):
|
|
115
|
+
os.makedirs(diretorio_destino, exist_ok=True)
|
|
116
|
+
print(f"Diretório de destino criado: {diretorio_destino}")
|
|
117
|
+
|
|
118
|
+
# Move os arquivos
|
|
119
|
+
for origem, destino in arquivos_para_mover:
|
|
120
|
+
shutil.copy2(origem, destino)
|
|
121
|
+
os.remove(origem)
|
|
122
|
+
arquivos_movidos.append(destino)
|
|
123
|
+
print(f"Arquivo movido: {origem} -> {destino}")
|
|
124
|
+
|
|
125
|
+
return arquivos_movidos
|
|
126
|
+
|
|
127
|
+
except Exception as e:
|
|
128
|
+
msg_erro = f"Erro ao mover arquivo(s): {e}"
|
|
129
|
+
raise Exception(msg_erro)
|
|
@@ -0,0 +1,64 @@
|
|
|
1
|
+
from datetime import datetime
|
|
2
|
+
import requests
|
|
3
|
+
|
|
4
|
+
def layout_msg_teams(titulo, mensagem):
|
|
5
|
+
"""
|
|
6
|
+
Gera o corpo de um Adaptive Card para ser enviado ao Microsoft Teams.
|
|
7
|
+
|
|
8
|
+
Args:
|
|
9
|
+
titulo (str): O título principal da mensagem.
|
|
10
|
+
mensagem (str): A mensagem principal.
|
|
11
|
+
detalhes (str): Detalhes adicionais (opcional).
|
|
12
|
+
|
|
13
|
+
Returns:
|
|
14
|
+
dict: Estrutura JSON do Adaptive Card.
|
|
15
|
+
"""
|
|
16
|
+
agora = datetime.now()
|
|
17
|
+
|
|
18
|
+
return {
|
|
19
|
+
"type": "message",
|
|
20
|
+
"attachments": [
|
|
21
|
+
{
|
|
22
|
+
"contentType": "application/vnd.microsoft.card.adaptive",
|
|
23
|
+
"content": {
|
|
24
|
+
"$schema": "http://adaptivecards.io/schemas/adaptive-card.json",
|
|
25
|
+
"version": "1.4",
|
|
26
|
+
"type": "AdaptiveCard",
|
|
27
|
+
"body": [
|
|
28
|
+
{
|
|
29
|
+
"type": "TextBlock",
|
|
30
|
+
"text": titulo,
|
|
31
|
+
"weight": "Bolder",
|
|
32
|
+
"size": "Large",
|
|
33
|
+
"color": "Attention"
|
|
34
|
+
},
|
|
35
|
+
{
|
|
36
|
+
"type": "TextBlock",
|
|
37
|
+
"text": f"{mensagem}\n\n**Enviado em:** {agora.strftime('%d/%m/%Y %H:%M:%S')}",
|
|
38
|
+
"wrap": True
|
|
39
|
+
}
|
|
40
|
+
]
|
|
41
|
+
}
|
|
42
|
+
}
|
|
43
|
+
]
|
|
44
|
+
}
|
|
45
|
+
|
|
46
|
+
|
|
47
|
+
def enviar_msg_teams(webhook_url, titulo, mensagem):
|
|
48
|
+
"""
|
|
49
|
+
Envia uma mensagem para o Microsoft Teams usando um webhook.
|
|
50
|
+
|
|
51
|
+
Args:
|
|
52
|
+
webhook_url (str): URL do webhook do Teams.
|
|
53
|
+
titulo (str): O título principal da mensagem.
|
|
54
|
+
mensagem (str): A mensagem principal.
|
|
55
|
+
detalhes (str): Detalhes adicionais (opcional).
|
|
56
|
+
"""
|
|
57
|
+
# Gerar o corpo da mensagem usando a função
|
|
58
|
+
corpo_mensagem = layout_msg_teams(titulo, mensagem)
|
|
59
|
+
|
|
60
|
+
response = requests.post(webhook_url, json=corpo_mensagem)
|
|
61
|
+
if response.status_code == 200:
|
|
62
|
+
print("Mensagem enviada com sucesso!")
|
|
63
|
+
else:
|
|
64
|
+
print(f"Erro ao enviar mensagem: {response.status_code}, {response.text}")
|
|
@@ -0,0 +1,17 @@
|
|
|
1
|
+
def garantir_iframe(self, iframe):
|
|
2
|
+
"""Garante que o script está no iframe correto.
|
|
3
|
+
Args:
|
|
4
|
+
sb: Instância do seleniumbase
|
|
5
|
+
iframe: Elemento ou seletor do iframe
|
|
6
|
+
"""
|
|
7
|
+
try:
|
|
8
|
+
self.switch_to_default_content()
|
|
9
|
+
self.wait_for_element_visible(iframe, timeout=30)
|
|
10
|
+
if self.is_element_visible(iframe):
|
|
11
|
+
self.switch_to_default_content()
|
|
12
|
+
self.switch_to_frame(self.find_element(iframe))
|
|
13
|
+
else:
|
|
14
|
+
raise Exception(f"Frame '{iframe}' não está visível.")
|
|
15
|
+
|
|
16
|
+
except Exception as e:
|
|
17
|
+
print(f"Erro ao alternar para o frame '{iframe}': {e}")
|
|
@@ -0,0 +1,141 @@
|
|
|
1
|
+
"""
|
|
2
|
+
Utilitário para verificação de novas versões da biblioteca utils-global.
|
|
3
|
+
"""
|
|
4
|
+
import re
|
|
5
|
+
import warnings
|
|
6
|
+
from datetime import datetime, timedelta
|
|
7
|
+
import os
|
|
8
|
+
import json
|
|
9
|
+
|
|
10
|
+
def verificar_versao_mais_recente(versao_atual, force=False):
|
|
11
|
+
"""
|
|
12
|
+
Verifica se há uma versão mais recente da biblioteca disponível no GitHub.
|
|
13
|
+
|
|
14
|
+
Args:
|
|
15
|
+
versao_atual: Versão atual do pacote
|
|
16
|
+
force: Se True, ignora o cache e sempre verifica a versão mais recente
|
|
17
|
+
|
|
18
|
+
Returns:
|
|
19
|
+
bool: True se uma nova versão foi encontrada, False caso contrário
|
|
20
|
+
"""
|
|
21
|
+
try:
|
|
22
|
+
import requests
|
|
23
|
+
|
|
24
|
+
# Verificar se deve usar cache
|
|
25
|
+
if not force and not _deve_verificar_versao():
|
|
26
|
+
return False
|
|
27
|
+
|
|
28
|
+
# URL para verificar a versão mais recente no GitHub (arquivo raw do setup.py na branch main)
|
|
29
|
+
url = "https://raw.githubusercontent.com/gabrielpelizzari/utils-global/main/setup.py"
|
|
30
|
+
|
|
31
|
+
response = requests.get(url, timeout=2)
|
|
32
|
+
|
|
33
|
+
if response.status_code == 200:
|
|
34
|
+
conteudo = response.text
|
|
35
|
+
|
|
36
|
+
# Procura pela linha com a versão no setup.py
|
|
37
|
+
match = re.search(r'version\s*=\s*["\']([^"\']+)["\']', conteudo)
|
|
38
|
+
|
|
39
|
+
if match:
|
|
40
|
+
versao_github = match.group(1)
|
|
41
|
+
|
|
42
|
+
# Salva informação da verificação no cache
|
|
43
|
+
_atualizar_cache_versao(versao_github)
|
|
44
|
+
|
|
45
|
+
# Converte para tuplas de inteiros para comparação (0.1.3 -> (0, 1, 3))
|
|
46
|
+
v_atual = tuple(map(int, versao_atual.split('.')))
|
|
47
|
+
v_github = tuple(map(int, versao_github.split('.')))
|
|
48
|
+
|
|
49
|
+
if v_github > v_atual:
|
|
50
|
+
aviso = f"\n⚠️ Nova versão da biblioteca utils-global disponível: {versao_github} (você está usando {versao_atual}).\n"\
|
|
51
|
+
f"Para atualizar, execute: pip install --upgrade git+https://github.com/gabrielpelizzari/utils-global.git\n"
|
|
52
|
+
|
|
53
|
+
# Mostra um aviso colorido no terminal
|
|
54
|
+
print("\033[93m" + aviso + "\033[0m")
|
|
55
|
+
|
|
56
|
+
# Também emite um aviso do Python
|
|
57
|
+
warnings.warn(aviso)
|
|
58
|
+
|
|
59
|
+
return True
|
|
60
|
+
|
|
61
|
+
return False
|
|
62
|
+
|
|
63
|
+
except Exception as e:
|
|
64
|
+
# Silencia qualquer erro na verificação para não afetar o uso normal da biblioteca
|
|
65
|
+
# print(f"Erro ao verificar versão: {e}")
|
|
66
|
+
return False
|
|
67
|
+
|
|
68
|
+
def mostrar_ultima_versao():
|
|
69
|
+
"""
|
|
70
|
+
Mostra informações sobre a última versão disponível da biblioteca.
|
|
71
|
+
Para uso diretamente pelo usuário quando quiser verificar manualmente.
|
|
72
|
+
"""
|
|
73
|
+
from automacao_utils import __version__
|
|
74
|
+
|
|
75
|
+
# Força uma nova verificação
|
|
76
|
+
if not verificar_versao_mais_recente(__version__, force=True):
|
|
77
|
+
print(f"Você já está usando a versão mais recente: {__version__}")
|
|
78
|
+
|
|
79
|
+
def _deve_verificar_versao():
|
|
80
|
+
"""
|
|
81
|
+
Determina se a biblioteca deve verificar por uma nova versão,
|
|
82
|
+
baseado no tempo decorrido desde a última verificação.
|
|
83
|
+
|
|
84
|
+
Returns:
|
|
85
|
+
bool: True se deve verificar, False caso contrário
|
|
86
|
+
"""
|
|
87
|
+
try:
|
|
88
|
+
# Arquivo de cache para a verificação de versão
|
|
89
|
+
cache_file = os.path.join(os.path.expanduser("~"), ".utils_global_version_cache.json")
|
|
90
|
+
|
|
91
|
+
# Se o arquivo não existir, deve verificar
|
|
92
|
+
if not os.path.exists(cache_file):
|
|
93
|
+
return True
|
|
94
|
+
|
|
95
|
+
# Lê o arquivo de cache
|
|
96
|
+
with open(cache_file, 'r') as f:
|
|
97
|
+
cache = json.load(f)
|
|
98
|
+
|
|
99
|
+
# Obtém a data da última verificação
|
|
100
|
+
ultima_verificacao = datetime.fromisoformat(cache.get('ultima_verificacao', '2000-01-01'))
|
|
101
|
+
|
|
102
|
+
# Verifica se passou pelo menos 24 horas desde a última verificação
|
|
103
|
+
return datetime.now() - ultima_verificacao > timedelta(hours=24)
|
|
104
|
+
|
|
105
|
+
except Exception:
|
|
106
|
+
# Em caso de erro, assume que deve verificar
|
|
107
|
+
return True
|
|
108
|
+
|
|
109
|
+
def _atualizar_cache_versao(versao_github):
|
|
110
|
+
"""
|
|
111
|
+
Atualiza o cache com a informação da última verificação.
|
|
112
|
+
|
|
113
|
+
Args:
|
|
114
|
+
versao_github: Versão mais recente encontrada no GitHub
|
|
115
|
+
"""
|
|
116
|
+
try:
|
|
117
|
+
# Arquivo de cache para a verificação de versão
|
|
118
|
+
cache_file = os.path.join(os.path.expanduser("~"), ".utils_global_version_cache.json")
|
|
119
|
+
|
|
120
|
+
# Cria o objeto de cache
|
|
121
|
+
cache = {
|
|
122
|
+
'ultima_verificacao': datetime.now().isoformat(),
|
|
123
|
+
'ultima_versao': versao_github
|
|
124
|
+
}
|
|
125
|
+
|
|
126
|
+
# Salva o cache
|
|
127
|
+
with open(cache_file, 'w') as f:
|
|
128
|
+
json.dump(cache, f)
|
|
129
|
+
|
|
130
|
+
except Exception:
|
|
131
|
+
# Silencia erros ao salvar o cache
|
|
132
|
+
pass
|
|
133
|
+
|
|
134
|
+
# Para teste quando o módulo é executado diretamente
|
|
135
|
+
if __name__ == "__main__":
|
|
136
|
+
try:
|
|
137
|
+
from automacao_utils import __version__
|
|
138
|
+
print(f"Verificando atualizações para utils-global {__version__}...")
|
|
139
|
+
mostrar_ultima_versao()
|
|
140
|
+
except ImportError:
|
|
141
|
+
print("Não foi possível determinar a versão atual do pacote.")
|
|
@@ -0,0 +1,195 @@
|
|
|
1
|
+
Metadata-Version: 2.4
|
|
2
|
+
Name: utils-global
|
|
3
|
+
Version: 0.1.0
|
|
4
|
+
Summary: Add your description here
|
|
5
|
+
Author: Gedean Zitkoski, Gabriel Pelizzari
|
|
6
|
+
Author-email: gedezitkoski@gmail.com, gpelizzari08@gmail.com
|
|
7
|
+
Requires-Python: >=3.7
|
|
8
|
+
Description-Content-Type: text/markdown
|
|
9
|
+
Requires-Dist: build>=1.2.2.post1
|
|
10
|
+
Requires-Dist: psutil>=7.0.0
|
|
11
|
+
Requires-Dist: seleniumbase>=4.38.2
|
|
12
|
+
Requires-Dist: watchdog>=6.0.0
|
|
13
|
+
Dynamic: author
|
|
14
|
+
Dynamic: author-email
|
|
15
|
+
Dynamic: requires-python
|
|
16
|
+
|
|
17
|
+
# utils-global
|
|
18
|
+
|
|
19
|
+
Repositório com funções globais utilizadas em projetos com Python, focado em automações com Selenium.
|
|
20
|
+
|
|
21
|
+
## Sobre o Projeto
|
|
22
|
+
|
|
23
|
+
Esta biblioteca contém funções utilitárias para automações usando Selenium, com foco em:
|
|
24
|
+
- Gerenciamento de downloads de arquivos
|
|
25
|
+
- Verificação de arquivos em uso
|
|
26
|
+
- Renomeação segura de arquivos
|
|
27
|
+
- Tratamento de erros estruturado
|
|
28
|
+
- Interação com iframes em páginas complexas
|
|
29
|
+
- Envio de notificações para o Microsoft Teams
|
|
30
|
+
|
|
31
|
+
## Módulos Principais
|
|
32
|
+
|
|
33
|
+
- [download_utils](./automacao_utils/download_utils.md): Gerenciamento de downloads e tratamento de erros
|
|
34
|
+
- [selenium_utils](./automacao_utils/selenium_utils.md): Utilitários para interação com iframes no Selenium
|
|
35
|
+
- [notificacao_utils](./automacao_utils/notificacao_utils.md): Envio de notificações para o Microsoft Teams
|
|
36
|
+
- [mover_arquivo_utils](./automacao_utils/mover_arquivo_utils.md): Movimentação de arquivos entre diretórios com opções avançadas
|
|
37
|
+
|
|
38
|
+
Para mais detalhes sobre cada módulo, clique nos links acima para acessar a documentação específica.
|
|
39
|
+
|
|
40
|
+
## Instalação
|
|
41
|
+
|
|
42
|
+
### A partir do GitHub:
|
|
43
|
+
|
|
44
|
+
```bash
|
|
45
|
+
pip install git+https://github.com/gabrielpelizzari/utils-global.git
|
|
46
|
+
```
|
|
47
|
+
|
|
48
|
+
### Para uma versão específica:
|
|
49
|
+
|
|
50
|
+
```bash
|
|
51
|
+
# Usando uma tag específica
|
|
52
|
+
pip install git+https://github.com/gabrielpelizzari/utils-global.git@v0.1.6
|
|
53
|
+
|
|
54
|
+
# Usando um commit específico
|
|
55
|
+
pip install git+https://github.com/gabrielpelizzari/utils-global.git@commit_hash
|
|
56
|
+
|
|
57
|
+
# Usando uma branch específica
|
|
58
|
+
pip install git+https://github.com/gabrielpelizzari/utils-global.git@develop
|
|
59
|
+
```
|
|
60
|
+
|
|
61
|
+
### Atualização:
|
|
62
|
+
|
|
63
|
+
```bash
|
|
64
|
+
pip install --upgrade git+https://github.com/gabrielpelizzari/utils-global.git
|
|
65
|
+
```
|
|
66
|
+
|
|
67
|
+
### Em modo de desenvolvimento (edição local):
|
|
68
|
+
|
|
69
|
+
```bash
|
|
70
|
+
# Clone o repositório
|
|
71
|
+
git clone https://github.com/gabrielpelizzari/utils-global.git
|
|
72
|
+
cd utils-global
|
|
73
|
+
|
|
74
|
+
# Instale em modo editável
|
|
75
|
+
pip install -e .
|
|
76
|
+
```
|
|
77
|
+
|
|
78
|
+
## Exemplos Rápidos
|
|
79
|
+
|
|
80
|
+
### Processamento de Downloads
|
|
81
|
+
|
|
82
|
+
```python
|
|
83
|
+
from automacao_utils import processar_download
|
|
84
|
+
|
|
85
|
+
# Download de um arquivo
|
|
86
|
+
caminho_arquivo = processar_download(
|
|
87
|
+
sb=sb, # instância do SeleniumBase
|
|
88
|
+
dir_download="C:/Downloads",
|
|
89
|
+
btn_download="#botao_download",
|
|
90
|
+
nome_arquivo="relatorio_mensal"
|
|
91
|
+
)
|
|
92
|
+
```
|
|
93
|
+
|
|
94
|
+
### Verificação de Arquivos em Uso
|
|
95
|
+
|
|
96
|
+
```python
|
|
97
|
+
from automacao_utils import is_file_in_use, wait_for_file_access
|
|
98
|
+
|
|
99
|
+
# Verificar se arquivo está em uso
|
|
100
|
+
if is_file_in_use("C:/Downloads/arquivo.pdf"):
|
|
101
|
+
print("O arquivo está sendo usado por outro processo")
|
|
102
|
+
|
|
103
|
+
# Aguardar liberação do arquivo
|
|
104
|
+
wait_for_file_access("C:/Downloads/arquivo.pdf", max_retries=30)
|
|
105
|
+
```
|
|
106
|
+
|
|
107
|
+
### Movimentação de Arquivos
|
|
108
|
+
|
|
109
|
+
```python
|
|
110
|
+
from automacao_utils import mover_arquivo
|
|
111
|
+
|
|
112
|
+
# Mover um arquivo para outro diretório
|
|
113
|
+
arquivos_movidos = mover_arquivo(
|
|
114
|
+
diretorio_origem="C:/Downloads/documento.pdf",
|
|
115
|
+
diretorio_destino="C:/Documentos/Importantes"
|
|
116
|
+
)
|
|
117
|
+
|
|
118
|
+
# Mover todos os arquivos de um diretório (com renomeação automática se já existirem)
|
|
119
|
+
arquivos_movidos = mover_arquivo(
|
|
120
|
+
diretorio_origem="C:/Downloads/Relatórios",
|
|
121
|
+
diretorio_destino="C:/Trabalho/Relatórios",
|
|
122
|
+
substituir=False
|
|
123
|
+
)
|
|
124
|
+
```
|
|
125
|
+
|
|
126
|
+
## Dependências
|
|
127
|
+
|
|
128
|
+
- seleniumbase: Para automação web
|
|
129
|
+
- watchdog: Para monitoramento de arquivos
|
|
130
|
+
- psutil: Para gerenciamento de processos
|
|
131
|
+
- requests: Para verificação de versões
|
|
132
|
+
|
|
133
|
+
## Contribuição
|
|
134
|
+
|
|
135
|
+
Para contribuir com este projeto:
|
|
136
|
+
1. Faça um fork do repositório
|
|
137
|
+
2. Crie uma branch para sua feature (`git checkout -b feature/nova-funcionalidade`)
|
|
138
|
+
3. Faça commit das mudanças (`git commit -m 'Adiciona nova funcionalidade'`)
|
|
139
|
+
4. Faça push para a branch (`git push origin feature/nova-funcionalidade`)
|
|
140
|
+
5. Abra um Pull Request
|
|
141
|
+
|
|
142
|
+
## Autores
|
|
143
|
+
|
|
144
|
+
- Gabriel Pelizzari
|
|
145
|
+
- Gedean Zitkoski
|
|
146
|
+
|
|
147
|
+
## Versão
|
|
148
|
+
|
|
149
|
+
Versão atual: 1.8.2
|
|
150
|
+
|
|
151
|
+
## Histórico de Versões
|
|
152
|
+
|
|
153
|
+
### Novidades na Versão 1.8.2
|
|
154
|
+
|
|
155
|
+
- Testes validando o pypi
|
|
156
|
+
|
|
157
|
+
### Novidades na Versão 1.8.1
|
|
158
|
+
|
|
159
|
+
- Ajustado para que a função processar_download o parâmetro de renomear: 'nome_arquivo' seja opcional
|
|
160
|
+
- Pequenos ajustes na função garantir_iframe para melhorar a robustez
|
|
161
|
+
|
|
162
|
+
### Novidades na Versão 1.8
|
|
163
|
+
|
|
164
|
+
- Adicionado parâmetro `btn_download_js` para permitir o uso de JavaScript para clicar no botão de download
|
|
165
|
+
|
|
166
|
+
### Novidades na Versão 1.7
|
|
167
|
+
|
|
168
|
+
- Adicionado suporte para renomear arquivos com extensão e tratamento de erros ao renomear arquivos com pontos antes da extensão
|
|
169
|
+
|
|
170
|
+
### Novidades na Versão 1.6
|
|
171
|
+
|
|
172
|
+
- Adicionado módulo `mover_arquivo_utils` para movimentação de arquivos entre diretórios com opções avançadas
|
|
173
|
+
- Documentação detalhada do novo módulo com exemplos de uso
|
|
174
|
+
|
|
175
|
+
### Novidades na Versão 1.5
|
|
176
|
+
|
|
177
|
+
- Adicionado módulo `selenium_utils` com função `garantir_iframe` para facilitar a interação com iframes
|
|
178
|
+
- Adicionado módulo `notificacao_utils` para envio de mensagens ao Microsoft Teams
|
|
179
|
+
- Aprimorado o gerenciamento de versão no pacote
|
|
180
|
+
- Melhorias na documentação com arquivos específicos para cada módulo
|
|
181
|
+
|
|
182
|
+
### Novidades na Versão 1.4
|
|
183
|
+
|
|
184
|
+
- Adicionado sistema automático de verificação de novas versões
|
|
185
|
+
- A biblioteca agora notifica o usuário quando há uma nova versão disponível
|
|
186
|
+
- Incluída função manual para verificar atualizações
|
|
187
|
+
- Adicionados tratamentos try/except em mais pontos para melhorar a robustez
|
|
188
|
+
|
|
189
|
+
### Novidades na Versão 1.3
|
|
190
|
+
|
|
191
|
+
- Melhorado tratamento de erros com suporte para múltiplos seletores
|
|
192
|
+
- Adicionado atributo `elemento_visivel` na classe `DownloadErroException` para identificar qual seletor específico foi encontrado
|
|
193
|
+
- Simplificada a API para permitir uso de string única ou lista de seletores
|
|
194
|
+
- Adicionados tratamentos try/except para captura do texto de elementos de erro
|
|
195
|
+
- Atualizada a documentação e exemplos de uso
|
|
@@ -0,0 +1,10 @@
|
|
|
1
|
+
automacao_utils/__init__.py,sha256=jYr--aglfXFRAjXxece-kWOnZ6rUQz7WWbZtPmML4Ag,1118
|
|
2
|
+
automacao_utils/download_utils.py,sha256=eAo3DlbxzoeyrZ6gyo1NRLi2oWj-Z_RAEfpO5qRvGVs,21102
|
|
3
|
+
automacao_utils/mover_arquivo_utils.py,sha256=jtZHx4MXQ3n_GfPOEk9j4NNDF0XFqdn2RqTSiE-Z8ZY,6423
|
|
4
|
+
automacao_utils/notificacao_utils.py,sha256=TfoPwqj37hkoLXft4TqWaZH6eqez1LqEQeswm3csvHE,2192
|
|
5
|
+
automacao_utils/selenium_utils.py,sha256=knt86lD41GAW9UG4RVbsHaxTQFYr3lD3xgJUET9IWDY,643
|
|
6
|
+
automacao_utils/version_check.py,sha256=h793upmoYdG4ZJbZZUijnnzb7dklViffICSVd9FXK2A,5333
|
|
7
|
+
utils_global-0.1.0.dist-info/METADATA,sha256=FqSjs4IPUmVlTDrxdas1j0hj13oELdMLhRGR2lYMeJ4,6281
|
|
8
|
+
utils_global-0.1.0.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
|
|
9
|
+
utils_global-0.1.0.dist-info/top_level.txt,sha256=-TTj4tBJP9mN8ninuIPFj2wJqxVCqiVyALkyGg6x0WU,16
|
|
10
|
+
utils_global-0.1.0.dist-info/RECORD,,
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
automacao_utils
|