pyrpa-framework 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.
- pyrpa/__init__.py +0 -0
- pyrpa/__main__.py +5 -0
- pyrpa/cli.py +593 -0
- pyrpa/core/__init__.py +18 -0
- pyrpa/core/compiler.py +166 -0
- pyrpa/core/doctor.py +221 -0
- pyrpa/core/generator.py +337 -0
- pyrpa/core/installer.py +168 -0
- pyrpa/core/modifier.py +346 -0
- pyrpa/core/runner.py +193 -0
- pyrpa/core/validator.py +42 -0
- pyrpa/domain/__init__.py +17 -0
- pyrpa/domain/contracts.py +91 -0
- pyrpa/domain/queue.py +118 -0
- pyrpa/infrastructure/__init__.py +32 -0
- pyrpa/infrastructure/ai.py +131 -0
- pyrpa/infrastructure/browser.py +187 -0
- pyrpa/infrastructure/database.py +111 -0
- pyrpa/infrastructure/http_client.py +101 -0
- pyrpa/infrastructure/logger.py +89 -0
- pyrpa/infrastructure/notifier.py +136 -0
- pyrpa/infrastructure/pdf.py +71 -0
- pyrpa/infrastructure/storage.py +134 -0
- pyrpa/models/__init__.py +0 -0
- pyrpa/models/schema.py +66 -0
- pyrpa/templates/project_structure/application/__init__.py +0 -0
- pyrpa/templates/project_structure/domain/__init__.py +0 -0
- pyrpa/templates/project_structure/infrastructure/__init__.py +0 -0
- pyrpa/templates/project_structure/interfaces/__init__.py +0 -0
- pyrpa/templates/project_structure/main.py +0 -0
- pyrpa_framework-0.1.0.dist-info/METADATA +223 -0
- pyrpa_framework-0.1.0.dist-info/RECORD +36 -0
- pyrpa_framework-0.1.0.dist-info/WHEEL +5 -0
- pyrpa_framework-0.1.0.dist-info/entry_points.txt +2 -0
- pyrpa_framework-0.1.0.dist-info/licenses/LICENSE +21 -0
- pyrpa_framework-0.1.0.dist-info/top_level.txt +1 -0
pyrpa/__init__.py
ADDED
|
File without changes
|
pyrpa/__main__.py
ADDED
pyrpa/cli.py
ADDED
|
@@ -0,0 +1,593 @@
|
|
|
1
|
+
from pathlib import Path
|
|
2
|
+
import sys
|
|
3
|
+
from typing import Optional
|
|
4
|
+
import typer
|
|
5
|
+
from rich.console import Console
|
|
6
|
+
from rich.panel import Panel
|
|
7
|
+
from rich.table import Table
|
|
8
|
+
|
|
9
|
+
from pyrpa.core.compiler import AirflowCompiler, CompiladorException, mapear_periodicidade_para_cron
|
|
10
|
+
from pyrpa.core.doctor import executar_diagnostico_doctor
|
|
11
|
+
from pyrpa.core.generator import gerar_projeto_rpa, GeradorProjetoException, normalizar_modulos
|
|
12
|
+
from pyrpa.core.installer import garantir_dependencias_modulos, ResultadoInstalacaoDeps
|
|
13
|
+
from pyrpa.core.modifier import adicionar_modulo_projeto, ModificadorProjetoException, MODULOS_SUPORTADOS
|
|
14
|
+
from pyrpa.core.runner import FluxoRunner
|
|
15
|
+
from pyrpa.core.validator import validar_arquivo_fluxo, FluxoInvalidoException
|
|
16
|
+
|
|
17
|
+
app = typer.Typer(
|
|
18
|
+
help="pyrpa - Framework de Scaffolding e Orquestração Declarativa para RPA em Clean Architecture",
|
|
19
|
+
no_args_is_help=True,
|
|
20
|
+
add_completion=False,
|
|
21
|
+
)
|
|
22
|
+
console = Console()
|
|
23
|
+
|
|
24
|
+
|
|
25
|
+
def resolver_caminho_fluxo(caminho_informado: Path, operacao: str = "Validação") -> Path:
|
|
26
|
+
"""
|
|
27
|
+
Verifica a existência do arquivo de fluxo. Se não existir no caminho informado,
|
|
28
|
+
inspeciona o diretório atual em busca de subpastas de robôs pyrpa e orienta
|
|
29
|
+
o desenvolvedor de forma amigável com comandos de navegação prontos.
|
|
30
|
+
"""
|
|
31
|
+
if caminho_informado.is_file():
|
|
32
|
+
return caminho_informado
|
|
33
|
+
|
|
34
|
+
pastas_robos = []
|
|
35
|
+
try:
|
|
36
|
+
for item in Path.cwd().iterdir():
|
|
37
|
+
if item.is_dir() and (item / "metadados" / "fluxo.yaml").is_file():
|
|
38
|
+
pastas_robos.append(item.name)
|
|
39
|
+
except Exception:
|
|
40
|
+
pass
|
|
41
|
+
|
|
42
|
+
caminho_absoluto = caminho_informado.resolve()
|
|
43
|
+
mensagem = f"Arquivo de fluxo não encontrado no caminho:\n[yellow]{caminho_absoluto}[/yellow]\n\n"
|
|
44
|
+
|
|
45
|
+
comando_op = operacao.lower()
|
|
46
|
+
if comando_op == "compilação":
|
|
47
|
+
comando_op = "compile"
|
|
48
|
+
elif comando_op == "execução":
|
|
49
|
+
comando_op = "run"
|
|
50
|
+
elif comando_op == "validação":
|
|
51
|
+
comando_op = "validate"
|
|
52
|
+
|
|
53
|
+
if pastas_robos:
|
|
54
|
+
primeiro = pastas_robos[0]
|
|
55
|
+
lista_robos = ", ".join(f"'{r}'" for r in pastas_robos)
|
|
56
|
+
mensagem += (
|
|
57
|
+
f"[bold green]>> Dica de Navegação:[/bold green]\n"
|
|
58
|
+
f"Detectamos o(s) seguinte(s) robô(s) nesta pasta: [bold cyan]{lista_robos}[/bold cyan]!\n"
|
|
59
|
+
f"Para utilizá-lo, entre na pasta do projeto primeiro:\n"
|
|
60
|
+
f" [bold yellow]cd {primeiro}[/bold yellow]\n"
|
|
61
|
+
f" [bold yellow]pyrpa {comando_op}[/bold yellow]\n\n"
|
|
62
|
+
f"Ou aponte diretamente para o arquivo:\n"
|
|
63
|
+
f" [bold yellow]pyrpa {comando_op} {primeiro}/metadados/fluxo.yaml[/bold yellow]"
|
|
64
|
+
)
|
|
65
|
+
else:
|
|
66
|
+
mensagem += (
|
|
67
|
+
"[bold yellow]Dica:[/bold yellow] Certifique-se de estar dentro da pasta do robô "
|
|
68
|
+
f"ou inicialize um novo projeto com: [bold cyan]pyrpa init <nome_do_projeto>[/bold cyan]"
|
|
69
|
+
)
|
|
70
|
+
|
|
71
|
+
console.print(Panel(mensagem, title=f"[bold red]Erro de {operacao}[/bold red]", border_style="red"))
|
|
72
|
+
raise typer.Exit(code=1)
|
|
73
|
+
|
|
74
|
+
|
|
75
|
+
@app.callback(invoke_without_command=True)
|
|
76
|
+
def main(
|
|
77
|
+
ctx: typer.Context,
|
|
78
|
+
version: bool = typer.Option(
|
|
79
|
+
False, "--version", "-v",
|
|
80
|
+
help="Exibe a versão instalada do pyrpa."
|
|
81
|
+
),
|
|
82
|
+
info_flag: bool = typer.Option(
|
|
83
|
+
False, "--info",
|
|
84
|
+
help="Exibe o catálogo completo de conectores e guia rápido."
|
|
85
|
+
),
|
|
86
|
+
doctor_flag: bool = typer.Option(
|
|
87
|
+
False, "--doctor",
|
|
88
|
+
help="Executa diagnóstico de integridade do ambiente e navegadores."
|
|
89
|
+
),
|
|
90
|
+
validate_flag: bool = typer.Option(
|
|
91
|
+
False, "--validate",
|
|
92
|
+
help="Valida o fluxo.yaml do projeto atual."
|
|
93
|
+
),
|
|
94
|
+
run_flag: bool = typer.Option(
|
|
95
|
+
False, "--run",
|
|
96
|
+
help="Executa o fluxo do projeto atual."
|
|
97
|
+
),
|
|
98
|
+
compile_flag: bool = typer.Option(
|
|
99
|
+
False, "--compile",
|
|
100
|
+
help="Compila o fluxo do projeto atual para Apache Airflow."
|
|
101
|
+
),
|
|
102
|
+
) -> None:
|
|
103
|
+
"""
|
|
104
|
+
pyrpa - Framework de Scaffolding e Orquestração Declarativa para RPA em Clean Architecture.
|
|
105
|
+
"""
|
|
106
|
+
if ctx.invoked_subcommand is None:
|
|
107
|
+
if version:
|
|
108
|
+
console.print("[bold cyan]pyrpa[/bold cyan] versão [bold green]0.1.0[/bold green]")
|
|
109
|
+
raise typer.Exit()
|
|
110
|
+
if info_flag:
|
|
111
|
+
info()
|
|
112
|
+
raise typer.Exit()
|
|
113
|
+
if doctor_flag:
|
|
114
|
+
doctor(destino=None)
|
|
115
|
+
raise typer.Exit()
|
|
116
|
+
if validate_flag:
|
|
117
|
+
validate(caminho=Path("metadados/fluxo.yaml"))
|
|
118
|
+
raise typer.Exit()
|
|
119
|
+
if run_flag:
|
|
120
|
+
run(caminho=Path("metadados/fluxo.yaml"))
|
|
121
|
+
raise typer.Exit()
|
|
122
|
+
if compile_flag:
|
|
123
|
+
compile_airflow(caminho=Path("metadados/fluxo.yaml"))
|
|
124
|
+
raise typer.Exit()
|
|
125
|
+
console.print(ctx.get_help())
|
|
126
|
+
raise typer.Exit()
|
|
127
|
+
|
|
128
|
+
|
|
129
|
+
@app.command(name="info")
|
|
130
|
+
def info() -> None:
|
|
131
|
+
"""
|
|
132
|
+
Exibe o catálogo completo de conectores, arquitetura e guia de comandos do pyrpa.
|
|
133
|
+
"""
|
|
134
|
+
console.print(Panel.fit(
|
|
135
|
+
"[bold cyan]pyrpa - Framework de Engenharia de Software e RPA Corporativo[/bold cyan]\n"
|
|
136
|
+
"[white]Desenvolvido com Clean Architecture, tipagem estática e orquestração declarativa.[/white]",
|
|
137
|
+
border_style="cyan"
|
|
138
|
+
))
|
|
139
|
+
|
|
140
|
+
# Tabela de Módulos
|
|
141
|
+
tabela_modulos = Table(title="Catálogo de Conectores e Módulos Suportados", header_style="bold magenta")
|
|
142
|
+
tabela_modulos.add_column("Módulo", style="bold cyan", width=12)
|
|
143
|
+
tabela_modulos.add_column("Tecnologias Utilizadas", style="yellow", width=32)
|
|
144
|
+
tabela_modulos.add_column("Casos de Uso Corporativos", style="white")
|
|
145
|
+
|
|
146
|
+
tabela_modulos.add_row(
|
|
147
|
+
"web",
|
|
148
|
+
"Playwright, Selenium, Undetected",
|
|
149
|
+
"Navegação em portais, preenchimento de formulários e download com fechamento seguro."
|
|
150
|
+
)
|
|
151
|
+
tabela_modulos.add_row(
|
|
152
|
+
"banco",
|
|
153
|
+
"SQLAlchemy, SQLite",
|
|
154
|
+
"Persistência transacional com commit/rollback automático para PostgreSQL, SQL Server e SQLite."
|
|
155
|
+
)
|
|
156
|
+
tabela_modulos.add_row(
|
|
157
|
+
"excel",
|
|
158
|
+
"Pandas, OpenPyXL",
|
|
159
|
+
"Exportação de planilhas formatadas (.xlsx), leitor de dados universal (CSV, JSON, Excel)."
|
|
160
|
+
)
|
|
161
|
+
tabela_modulos.add_row(
|
|
162
|
+
"pdf",
|
|
163
|
+
"PyPDF, Expressões Regulares",
|
|
164
|
+
"Extração de textos e reconhecimento automático de CNPJs, datas, valores e boletos bancários."
|
|
165
|
+
)
|
|
166
|
+
tabela_modulos.add_row(
|
|
167
|
+
"ia",
|
|
168
|
+
"LLMs (OpenAI, Groq, Ollama)",
|
|
169
|
+
"Classificação inteligente de e-mails/chamados e extração estruturada de dados com prompts."
|
|
170
|
+
)
|
|
171
|
+
tabela_modulos.add_row(
|
|
172
|
+
"email",
|
|
173
|
+
"SMTP Corporativo, Webhooks",
|
|
174
|
+
"Disparo de relatórios com anexos e alertas em canais do Microsoft Teams ou Slack."
|
|
175
|
+
)
|
|
176
|
+
console.print(tabela_modulos)
|
|
177
|
+
|
|
178
|
+
# Tabela de Comandos
|
|
179
|
+
tabela_comandos = Table(title="Guia Rápido de Comandos da CLI", header_style="bold green")
|
|
180
|
+
tabela_comandos.add_column("Comando", style="bold cyan", width=22)
|
|
181
|
+
tabela_comandos.add_column("Descrição", style="white")
|
|
182
|
+
tabela_comandos.add_column("Exemplo de Uso", style="yellow")
|
|
183
|
+
|
|
184
|
+
tabela_comandos.add_row(
|
|
185
|
+
"pyrpa init <nome>",
|
|
186
|
+
"Cria novo robô com Clean Architecture.",
|
|
187
|
+
"pyrpa init robo_compras -m web,banco"
|
|
188
|
+
)
|
|
189
|
+
tabela_comandos.add_row(
|
|
190
|
+
"pyrpa add <modulo>",
|
|
191
|
+
"Acrescenta um conector ao robô existente.",
|
|
192
|
+
"pyrpa add pdf"
|
|
193
|
+
)
|
|
194
|
+
tabela_comandos.add_row(
|
|
195
|
+
"pyrpa validate",
|
|
196
|
+
"Valida integridade do fluxo.yaml.",
|
|
197
|
+
"pyrpa validate metadados/fluxo.yaml"
|
|
198
|
+
)
|
|
199
|
+
tabela_comandos.add_row(
|
|
200
|
+
"pyrpa run",
|
|
201
|
+
"Executa o fluxo localmente com cronômetro.",
|
|
202
|
+
"pyrpa run"
|
|
203
|
+
)
|
|
204
|
+
tabela_comandos.add_row(
|
|
205
|
+
"pyrpa compile",
|
|
206
|
+
"Gera DAG para o Apache Airflow.",
|
|
207
|
+
"pyrpa compile -s diario"
|
|
208
|
+
)
|
|
209
|
+
tabela_comandos.add_row(
|
|
210
|
+
"pyrpa doctor",
|
|
211
|
+
"Verifica saúde do ambiente e navegadores.",
|
|
212
|
+
"pyrpa doctor"
|
|
213
|
+
)
|
|
214
|
+
tabela_comandos.add_row(
|
|
215
|
+
"pyrpa info",
|
|
216
|
+
"Apresenta este manual interativo.",
|
|
217
|
+
"pyrpa info"
|
|
218
|
+
)
|
|
219
|
+
console.print(tabela_comandos)
|
|
220
|
+
|
|
221
|
+
|
|
222
|
+
@app.command(name="doctor")
|
|
223
|
+
def doctor(
|
|
224
|
+
destino: Optional[Path] = typer.Option(
|
|
225
|
+
None,
|
|
226
|
+
"--destino", "-d",
|
|
227
|
+
help="Diretório do projeto a ser diagnosticado (padrão: diretório atual)"
|
|
228
|
+
)
|
|
229
|
+
) -> None:
|
|
230
|
+
"""
|
|
231
|
+
Executa diagnóstico de saúde do ambiente, dependências e navegadores instalados.
|
|
232
|
+
"""
|
|
233
|
+
console.print("\n[bold blue]>> Executando diagnóstico do ambiente (pyrpa doctor)...[/bold blue]\n")
|
|
234
|
+
diagnosticos = executar_diagnostico_doctor(diretorio_atual=destino)
|
|
235
|
+
|
|
236
|
+
tabela = Table(title="Diagnóstico de Ambiente do Sistema", header_style="bold magenta")
|
|
237
|
+
tabela.add_column("Categoria", style="cyan", width=24)
|
|
238
|
+
tabela.add_column("Componente / Recurso", style="white", width=34)
|
|
239
|
+
tabela.add_column("Status", style="bold", width=10)
|
|
240
|
+
tabela.add_column("Diagnóstico / Detalhes", style="white")
|
|
241
|
+
|
|
242
|
+
total_ok = 0
|
|
243
|
+
total_avisos = 0
|
|
244
|
+
total_falhas = 0
|
|
245
|
+
|
|
246
|
+
for item in diagnosticos:
|
|
247
|
+
if item.status == "OK":
|
|
248
|
+
status_fmt = "[green][OK][/green]"
|
|
249
|
+
total_ok += 1
|
|
250
|
+
elif item.status == "AVISO":
|
|
251
|
+
status_fmt = "[yellow][AVISO][/yellow]"
|
|
252
|
+
total_avisos += 1
|
|
253
|
+
else:
|
|
254
|
+
status_fmt = "[red][FALHA][/red]"
|
|
255
|
+
total_falhas += 1
|
|
256
|
+
|
|
257
|
+
tabela.add_row(item.categoria, item.item, status_fmt, item.detalhes)
|
|
258
|
+
|
|
259
|
+
console.print(tabela)
|
|
260
|
+
|
|
261
|
+
if total_falhas == 0:
|
|
262
|
+
console.print(Panel.fit(
|
|
263
|
+
f"[bold green][OK] Ambiente pronto para desenvolvimento e execução RPA![/bold green]\n"
|
|
264
|
+
f"Itens operacionais: {total_ok} | Avisos opcionais: {total_avisos}",
|
|
265
|
+
border_style="green"
|
|
266
|
+
))
|
|
267
|
+
else:
|
|
268
|
+
console.print(Panel.fit(
|
|
269
|
+
f"[bold red][FALHA] Foram encontrados {total_falhas} item(ns) impeditivo(s).[/bold red]\n"
|
|
270
|
+
f"Verifique as linhas marcadas com [FALHA] acima antes de executar o robô.",
|
|
271
|
+
border_style="red"
|
|
272
|
+
))
|
|
273
|
+
|
|
274
|
+
|
|
275
|
+
def _exibir_status_dependencias(res: ResultadoInstalacaoDeps) -> None:
|
|
276
|
+
"""Exibe o resultado da verificação e instalação automática de bibliotecas."""
|
|
277
|
+
if res.falhas:
|
|
278
|
+
lista_falhas = ", ".join(res.falhas)
|
|
279
|
+
console.print(Panel.fit(
|
|
280
|
+
f"[bold yellow][AVISO] Algumas bibliotecas não puderam ser instaladas automaticamente:[/bold yellow]\n"
|
|
281
|
+
f"{lista_falhas}\n\n"
|
|
282
|
+
f"[white]Detalhes:[/white] {res.erro_detalhe}\n"
|
|
283
|
+
f"[yellow]Instale manualmente com:[/yellow] pip install -r requirements.txt",
|
|
284
|
+
border_style="yellow",
|
|
285
|
+
))
|
|
286
|
+
return
|
|
287
|
+
|
|
288
|
+
if res.instalados_agora:
|
|
289
|
+
lista_novos = ", ".join(res.instalados_agora)
|
|
290
|
+
console.print(f"[bold green][OK] Bibliotecas instaladas automaticamente:[/bold green] {lista_novos}")
|
|
291
|
+
elif res.ja_instalados:
|
|
292
|
+
console.print(
|
|
293
|
+
f"[bold green][OK] Dependências verificadas ({len(res.ja_instalados)} pacote(s) pronto(s) no ambiente).[/bold green]"
|
|
294
|
+
)
|
|
295
|
+
|
|
296
|
+
|
|
297
|
+
@app.command(name="init")
|
|
298
|
+
def init(
|
|
299
|
+
nome_projeto: str = typer.Argument(..., help="Nome do projeto / robô a ser criado"),
|
|
300
|
+
destino: Optional[Path] = typer.Option(
|
|
301
|
+
None,
|
|
302
|
+
"--destino", "-d",
|
|
303
|
+
help="Diretório onde o projeto será criado (padrão: ./<nome_projeto>)"
|
|
304
|
+
),
|
|
305
|
+
forcar: bool = typer.Option(
|
|
306
|
+
False,
|
|
307
|
+
"--forcar", "-f",
|
|
308
|
+
help="Sobrescrever arquivos se o diretório de destino já existir"
|
|
309
|
+
),
|
|
310
|
+
modulos: Optional[str] = typer.Option(
|
|
311
|
+
None,
|
|
312
|
+
"--modulos", "-m",
|
|
313
|
+
help="Módulos a incluir (ex: 'web,banco', 'excel,email', 'completo')"
|
|
314
|
+
),
|
|
315
|
+
sem_instalar: bool = typer.Option(
|
|
316
|
+
False,
|
|
317
|
+
"--sem-instalar",
|
|
318
|
+
help="Não executa instalação automática de dependências faltantes via pip"
|
|
319
|
+
)
|
|
320
|
+
) -> None:
|
|
321
|
+
"""
|
|
322
|
+
Inicializa um novo projeto RPA estruturado estritamente em Clean Architecture.
|
|
323
|
+
"""
|
|
324
|
+
pasta_destino = destino if destino is not None else Path.cwd() / nome_projeto
|
|
325
|
+
|
|
326
|
+
# Menu interativo se não foi informado via linha de comando
|
|
327
|
+
if modulos is None and sys.stdin.isatty():
|
|
328
|
+
console.print(f"\n[bold cyan]>> Configuração de Módulos para o Robô:[/bold cyan] [green]{nome_projeto}[/green]")
|
|
329
|
+
console.print(" [1] Completo (Navegador, Banco, Excel, PDF, IA e E-mail) [Recomendado]")
|
|
330
|
+
console.print(" [2] Automação Web (Playwright/Selenium)")
|
|
331
|
+
console.print(" [3] Banco de Dados & APIs (SQLAlchemy, SQLite e HTTP Client)")
|
|
332
|
+
console.print(" [4] Extração de Documentos & IA (PDFs + Inteligência Artificial)")
|
|
333
|
+
console.print(" [5] Planilhas & Mensageria (Excel + Disparador de E-mail)")
|
|
334
|
+
console.print(" [6] Personalizado (digitar módulos separados por vírgula)")
|
|
335
|
+
escolha = typer.prompt("Opção", default="1")
|
|
336
|
+
if escolha == "1":
|
|
337
|
+
modulos = "completo"
|
|
338
|
+
elif escolha == "2":
|
|
339
|
+
modulos = "web"
|
|
340
|
+
elif escolha == "3":
|
|
341
|
+
modulos = "banco"
|
|
342
|
+
elif escolha == "4":
|
|
343
|
+
modulos = "pdf,ia"
|
|
344
|
+
elif escolha == "5":
|
|
345
|
+
modulos = "excel,email"
|
|
346
|
+
elif escolha == "6":
|
|
347
|
+
modulos = typer.prompt("Digite os módulos (ex: web,banco,pdf)")
|
|
348
|
+
else:
|
|
349
|
+
modulos = "completo"
|
|
350
|
+
|
|
351
|
+
console.print(f"\n[bold blue]>> Inicializando projeto RPA:[/bold blue] [green]{nome_projeto}[/green]")
|
|
352
|
+
|
|
353
|
+
try:
|
|
354
|
+
caminho_final = gerar_projeto_rpa(
|
|
355
|
+
nome_projeto=nome_projeto,
|
|
356
|
+
destino=pasta_destino,
|
|
357
|
+
forcar=forcar,
|
|
358
|
+
modulos=modulos,
|
|
359
|
+
)
|
|
360
|
+
|
|
361
|
+
tabela = Table(title="Camadas Arquiteturais Geradas", show_header=True, header_style="bold magenta")
|
|
362
|
+
tabela.add_column("Camada", style="cyan", width=20)
|
|
363
|
+
tabela.add_column("Responsabilidade Clean Architecture", style="white")
|
|
364
|
+
|
|
365
|
+
tabela.add_row("domain/", "Entidades, regras de cálculo e validação pura (Python puro, zero dependências)")
|
|
366
|
+
tabela.add_row("application/", "Casos de uso e orquestração interna das regras de negócio do robô")
|
|
367
|
+
tabela.add_row("infrastructure/", "Adaptadores externos: drivers (Playwright/Selenium), bancos SQL e APIs")
|
|
368
|
+
tabela.add_row("interfaces/", "Ponto de entrada, controladores locais e adapters de terminal")
|
|
369
|
+
tabela.add_row("metadados/fluxo.yaml", "Orquestração declarativa dos passos e adaptadores")
|
|
370
|
+
|
|
371
|
+
console.print(tabela)
|
|
372
|
+
|
|
373
|
+
mods_selecionados = normalizar_modulos(modulos)
|
|
374
|
+
res_deps = garantir_dependencias_modulos(
|
|
375
|
+
mods_selecionados,
|
|
376
|
+
instalar_automaticamente=not sem_instalar,
|
|
377
|
+
)
|
|
378
|
+
_exibir_status_dependencias(res_deps)
|
|
379
|
+
|
|
380
|
+
console.print(Panel.fit(
|
|
381
|
+
f"[bold green][OK] Projeto criado com sucesso em:[/bold green]\n{caminho_final}\n\n"
|
|
382
|
+
f"[yellow]Para começar:[/yellow]\n"
|
|
383
|
+
f" cd {caminho_final.name}\n"
|
|
384
|
+
f" pyrpa run\n\n"
|
|
385
|
+
f"[yellow]Para adicionar novos módulos depois:[/yellow]\n"
|
|
386
|
+
f" pyrpa add <modulo> (ex: pyrpa add pdf)",
|
|
387
|
+
border_style="green"
|
|
388
|
+
))
|
|
389
|
+
|
|
390
|
+
except GeradorProjetoException as exc:
|
|
391
|
+
console.print(Panel(f"[bold red]Falha na inicialização:[/bold red]\n{exc}", border_style="red"))
|
|
392
|
+
raise typer.Exit(code=1)
|
|
393
|
+
|
|
394
|
+
|
|
395
|
+
@app.command(name="add")
|
|
396
|
+
def add(
|
|
397
|
+
modulo: str = typer.Argument(
|
|
398
|
+
...,
|
|
399
|
+
help=f"Módulo a ser adicionado ao robô: {', '.join(sorted(MODULOS_SUPORTADOS))}"
|
|
400
|
+
),
|
|
401
|
+
destino: Optional[Path] = typer.Option(
|
|
402
|
+
None,
|
|
403
|
+
"--destino", "-d",
|
|
404
|
+
help="Diretório do projeto (padrão: diretório atual)"
|
|
405
|
+
),
|
|
406
|
+
sem_instalar: bool = typer.Option(
|
|
407
|
+
False,
|
|
408
|
+
"--sem-instalar",
|
|
409
|
+
help="Não executa instalação automática de dependências faltantes via pip"
|
|
410
|
+
)
|
|
411
|
+
) -> None:
|
|
412
|
+
"""
|
|
413
|
+
Acrescenta um novo conector de infraestrutura e caso de uso a um projeto existente.
|
|
414
|
+
"""
|
|
415
|
+
console.print(f"\n[bold blue]>> Adicionando módulo ao projeto:[/bold blue] [cyan]{modulo}[/cyan]")
|
|
416
|
+
|
|
417
|
+
try:
|
|
418
|
+
resultado = adicionar_modulo_projeto(nome_modulo=modulo, diretorio_projeto=destino)
|
|
419
|
+
|
|
420
|
+
tabela = Table(title=f"Módulo Adicionado: {resultado.nome_modulo.upper()}", border_style="green")
|
|
421
|
+
tabela.add_column("Item Modificado", style="bold cyan")
|
|
422
|
+
tabela.add_column("Detalhe", style="white")
|
|
423
|
+
|
|
424
|
+
tabela.add_row("Identificador da Etapa", resultado.passo_adicionado_id)
|
|
425
|
+
tabela.add_row("Nome da Etapa", resultado.passo_adicionado_nome)
|
|
426
|
+
for arq in resultado.arquivos_criados:
|
|
427
|
+
tabela.add_row("Arquivo Gerado/Atualizado", arq)
|
|
428
|
+
|
|
429
|
+
console.print(tabela)
|
|
430
|
+
|
|
431
|
+
res_deps = garantir_dependencias_modulos(
|
|
432
|
+
{modulo.strip().lower()},
|
|
433
|
+
instalar_automaticamente=not sem_instalar,
|
|
434
|
+
incluir_base=False,
|
|
435
|
+
)
|
|
436
|
+
_exibir_status_dependencias(res_deps)
|
|
437
|
+
|
|
438
|
+
console.print(Panel.fit(
|
|
439
|
+
f"[bold green][OK] Módulo '{modulo}' incorporado com sucesso ao fluxo.yaml![/bold green]\n\n"
|
|
440
|
+
f"[yellow]Próximos passos:[/yellow]\n"
|
|
441
|
+
f" pyrpa validate (conferir a nova etapa)\n"
|
|
442
|
+
f" pyrpa run (testar a execução)",
|
|
443
|
+
border_style="green"
|
|
444
|
+
))
|
|
445
|
+
|
|
446
|
+
except ModificadorProjetoException as exc:
|
|
447
|
+
console.print(Panel(f"[bold red]Falha ao adicionar módulo:[/bold red]\n{exc}", border_style="red"))
|
|
448
|
+
raise typer.Exit(code=1)
|
|
449
|
+
|
|
450
|
+
|
|
451
|
+
@app.command(name="validate")
|
|
452
|
+
def validate(
|
|
453
|
+
caminho: Path = typer.Argument(
|
|
454
|
+
Path("metadados/fluxo.yaml"),
|
|
455
|
+
help="Caminho do arquivo de fluxo YAML a ser validado"
|
|
456
|
+
)
|
|
457
|
+
) -> None:
|
|
458
|
+
"""
|
|
459
|
+
Valida um arquivo de orquestração de fluxo contra o contrato Pydantic do pyrpa.
|
|
460
|
+
"""
|
|
461
|
+
caminho = resolver_caminho_fluxo(caminho, operacao="Validação")
|
|
462
|
+
console.print(f"\n[bold blue]>> Validando contrato de fluxo:[/bold blue] {caminho}")
|
|
463
|
+
|
|
464
|
+
try:
|
|
465
|
+
esquema = validar_arquivo_fluxo(caminho)
|
|
466
|
+
|
|
467
|
+
tabela = Table(title=f"Fluxo: {esquema.fluxo.nome} (v{esquema.fluxo.versao})", border_style="green")
|
|
468
|
+
tabela.add_column("ID", style="bold cyan")
|
|
469
|
+
tabela.add_column("Nome da Etapa", style="white")
|
|
470
|
+
tabela.add_column("Provider", style="yellow")
|
|
471
|
+
tabela.add_column("Target UseCase", style="magenta")
|
|
472
|
+
|
|
473
|
+
for passo in esquema.fluxo.passos:
|
|
474
|
+
tabela.add_row(passo.id, passo.nome, passo.provider.value, passo.target)
|
|
475
|
+
|
|
476
|
+
console.print(tabela)
|
|
477
|
+
console.print(f"[bold green][OK] Fluxo válido e pronto para execução ou compilação de DAG![/bold green]\n")
|
|
478
|
+
|
|
479
|
+
except (FileNotFoundError, FluxoInvalidoException) as exc:
|
|
480
|
+
console.print(Panel(f"[bold red]Erro de Validação:[/bold red]\n{exc}", border_style="red"))
|
|
481
|
+
raise typer.Exit(code=1)
|
|
482
|
+
|
|
483
|
+
|
|
484
|
+
@app.command(name="run")
|
|
485
|
+
def run(
|
|
486
|
+
caminho: Path = typer.Argument(
|
|
487
|
+
Path("metadados/fluxo.yaml"),
|
|
488
|
+
help="Caminho do arquivo de fluxo YAML a ser executado"
|
|
489
|
+
)
|
|
490
|
+
) -> None:
|
|
491
|
+
"""
|
|
492
|
+
Executa localmente o fluxo do robô conforme definido no fluxo.yaml.
|
|
493
|
+
"""
|
|
494
|
+
caminho = resolver_caminho_fluxo(caminho, operacao="Execução")
|
|
495
|
+
console.print(f"\n[bold blue]>> Executando fluxo RPA:[/bold blue] {caminho}")
|
|
496
|
+
|
|
497
|
+
try:
|
|
498
|
+
runner = FluxoRunner()
|
|
499
|
+
resultado = runner.executar(caminho)
|
|
500
|
+
|
|
501
|
+
tabela = Table(
|
|
502
|
+
title=f"Resultado da Execução: {resultado.nome_fluxo} (v{resultado.versao})",
|
|
503
|
+
border_style="green" if resultado.sucesso else "red"
|
|
504
|
+
)
|
|
505
|
+
tabela.add_column("ID Passo", style="bold cyan")
|
|
506
|
+
tabela.add_column("Status", style="bold")
|
|
507
|
+
tabela.add_column("Duração (s)", style="yellow")
|
|
508
|
+
tabela.add_column("Mensagem", style="white")
|
|
509
|
+
|
|
510
|
+
for passo_id, res_passo in resultado.resultados_passos.items():
|
|
511
|
+
status_txt = "[green][OK][/green]" if res_passo.sucesso else "[red][FALHA][/red]"
|
|
512
|
+
tabela.add_row(passo_id, status_txt, f"{res_passo.duracao_segundos:.3f}", res_passo.mensagem)
|
|
513
|
+
|
|
514
|
+
console.print(tabela)
|
|
515
|
+
|
|
516
|
+
if resultado.sucesso:
|
|
517
|
+
console.print(Panel.fit(
|
|
518
|
+
f"[bold green][OK] Execução concluída com sucesso![/bold green]\n"
|
|
519
|
+
f"Passos executados: {resultado.passos_executados}/{resultado.total_passos}\n"
|
|
520
|
+
f"Tempo total: {resultado.duracao_total_segundos:.3f} segundos",
|
|
521
|
+
border_style="green"
|
|
522
|
+
))
|
|
523
|
+
else:
|
|
524
|
+
console.print(Panel.fit(
|
|
525
|
+
f"[bold red][FALHA] Execução interrompida:[/bold red]\n{resultado.erro}\n"
|
|
526
|
+
f"Passos executados com êxito: {resultado.passos_executados - 1}/{resultado.total_passos}",
|
|
527
|
+
border_style="red"
|
|
528
|
+
))
|
|
529
|
+
raise typer.Exit(code=1)
|
|
530
|
+
|
|
531
|
+
except (FileNotFoundError, FluxoInvalidoException) as exc:
|
|
532
|
+
console.print(Panel(f"[bold red]Erro de Validação pré-execução:[/bold red]\n{exc}", border_style="red"))
|
|
533
|
+
raise typer.Exit(code=1)
|
|
534
|
+
|
|
535
|
+
|
|
536
|
+
@app.command(name="compile")
|
|
537
|
+
def compile_airflow(
|
|
538
|
+
caminho: Path = typer.Argument(
|
|
539
|
+
Path("metadados/fluxo.yaml"),
|
|
540
|
+
help="Caminho do arquivo de fluxo YAML a ser compilado"
|
|
541
|
+
),
|
|
542
|
+
destino: Optional[Path] = typer.Option(
|
|
543
|
+
None,
|
|
544
|
+
"--destino", "-o",
|
|
545
|
+
help="Caminho do arquivo DAG a ser gerado (padrão: ./dags/dag_<nome>.py)"
|
|
546
|
+
),
|
|
547
|
+
schedule: Optional[str] = typer.Option(
|
|
548
|
+
None,
|
|
549
|
+
"--schedule", "-s",
|
|
550
|
+
help="Periodicidade de execução cron (ex: 'diario', 'horario', 'semanal', '0 8 * * *', 'manual')"
|
|
551
|
+
)
|
|
552
|
+
) -> None:
|
|
553
|
+
"""
|
|
554
|
+
Compila o fluxo.yaml para uma DAG executável do Apache Airflow com agendamento cron (RF05 do TCC).
|
|
555
|
+
"""
|
|
556
|
+
caminho = resolver_caminho_fluxo(caminho, operacao="Compilação")
|
|
557
|
+
console.print(f"\n[bold blue]>> Compilando fluxo para Apache Airflow:[/bold blue] {caminho}")
|
|
558
|
+
|
|
559
|
+
if schedule is None and sys.stdin.isatty():
|
|
560
|
+
console.print("\n[bold cyan]Escolha a periodicidade de execução no Airflow:[/bold cyan]")
|
|
561
|
+
console.print(" [1] Manual (Sob demanda / sem agendamento)")
|
|
562
|
+
console.print(" [2] De hora em hora (@hourly)")
|
|
563
|
+
console.print(" [3] Diário (todos os dias às 08:00)")
|
|
564
|
+
console.print(" [4] Semanal (toda segunda-feira às 08:00)")
|
|
565
|
+
console.print(" [5] Mensal (no 1º dia do mês às 08:00)")
|
|
566
|
+
console.print(" [6] Personalizado (digitar expressão cron)")
|
|
567
|
+
opcao = typer.prompt("Opção", default="1")
|
|
568
|
+
if opcao == "6":
|
|
569
|
+
schedule = typer.prompt("Digite a expressão cron (ex: */15 * * * *)")
|
|
570
|
+
else:
|
|
571
|
+
schedule = opcao
|
|
572
|
+
|
|
573
|
+
try:
|
|
574
|
+
compilador = AirflowCompiler()
|
|
575
|
+
caminho_dag = compilador.compilar(caminho_fluxo=caminho, destino_dag=destino, schedule=schedule)
|
|
576
|
+
cron_resolvido = mapear_periodicidade_para_cron(schedule)
|
|
577
|
+
info_agenda = f"[yellow]Agendamento:[/yellow] {cron_resolvido}" if cron_resolvido else "[yellow]Agendamento:[/yellow] Manual (None)"
|
|
578
|
+
|
|
579
|
+
console.print(Panel.fit(
|
|
580
|
+
f"[bold green][OK] DAG do Apache Airflow gerada com sucesso![/bold green]\n\n"
|
|
581
|
+
f"[cyan]Arquivo gerado:[/cyan] {caminho_dag}\n"
|
|
582
|
+
f"{info_agenda}\n\n"
|
|
583
|
+
f"[yellow]Para publicar no Airflow:[/yellow] Copie este arquivo para a pasta $AIRFLOW_HOME/dags/",
|
|
584
|
+
border_style="green"
|
|
585
|
+
))
|
|
586
|
+
|
|
587
|
+
except (FileNotFoundError, FluxoInvalidoException, CompiladorException) as exc:
|
|
588
|
+
console.print(Panel(f"[bold red]Erro de Compilação:[/bold red]\n{exc}", border_style="red"))
|
|
589
|
+
raise typer.Exit(code=1)
|
|
590
|
+
|
|
591
|
+
|
|
592
|
+
if __name__ == "__main__":
|
|
593
|
+
app()
|
pyrpa/core/__init__.py
ADDED
|
@@ -0,0 +1,18 @@
|
|
|
1
|
+
from pyrpa.core.compiler import AirflowCompiler, CompiladorException, compilar_fluxo_airflow
|
|
2
|
+
from pyrpa.core.generator import GeradorProjetoException, gerar_projeto_rpa
|
|
3
|
+
from pyrpa.core.runner import ExecucaoFluxoException, FluxoRunner, ResultadoFluxo, executar_fluxo
|
|
4
|
+
from pyrpa.core.validator import FluxoInvalidoException, validar_arquivo_fluxo
|
|
5
|
+
|
|
6
|
+
__all__ = [
|
|
7
|
+
"AirflowCompiler",
|
|
8
|
+
"CompiladorException",
|
|
9
|
+
"compilar_fluxo_airflow",
|
|
10
|
+
"GeradorProjetoException",
|
|
11
|
+
"gerar_projeto_rpa",
|
|
12
|
+
"ExecucaoFluxoException",
|
|
13
|
+
"FluxoRunner",
|
|
14
|
+
"ResultadoFluxo",
|
|
15
|
+
"executar_fluxo",
|
|
16
|
+
"FluxoInvalidoException",
|
|
17
|
+
"validar_arquivo_fluxo",
|
|
18
|
+
]
|