artespy 0.1.0__py3-none-any.whl

artespy/__init__.py

@@ -0,0 +1,3 @@
+from artespy.selenium.handler import SeleniumHandler
+
+__all__ = ["SeleniumHandler"]

artespy/errors/__init__.py

@@ -0,0 +1,22 @@
+class HandlerException(Exception):
+    """Classe base para exceptions relacionadas ao handler."""
+
+
+class UnknownAlertException(HandlerException):
+    pass
+
+
+class ElementNotFoundException(HandlerException):
+    pass
+
+
+class InvalidPageException(HandlerException):
+    pass
+
+
+class SeiException(Exception):
+    """Classe base para exceptions relacionadas ao SEI."""
+
+
+class InvalidCredentialsError(SeiException):
+    pass

artespy/selenium/handler.py

@@ -0,0 +1,262 @@
+import datetime as dt
+import os
+from typing import Literal
+
+import pandas as pd
+from selenium.webdriver import Chrome, ChromeOptions, ChromeService
+from selenium.webdriver.support.ui import WebDriverWait
+from webdriver_manager.chrome import ChromeDriverManager
+
+from artespy.errors import HandlerException, InvalidPageException
+from artespy.selenium.pages.home import HomePage
+from artespy.selenium.pages.login import LoginPage
+from artespy.selenium.pages.processo import ProcessoPage
+
+
+class SeleniumHandler:
+    """Handler Selenium para automatizar operações no portal SEI."""
+
+    def __init__(self, headless: bool = False, timeout: int = 60) -> None:
+        self.headless: bool = headless
+        self.timeout: int = timeout
+
+        self.driver = None
+        self.wait = None
+        self._page = None
+
+    @property
+    def page(self):
+        if not self._page:
+            raise HandlerException("Página atual não inicializada.")
+        return self._page
+
+    def _inicializar_driver(self) -> None:
+        """Instanciar um novo driver e espera explícita."""
+        opts = ChromeOptions()
+        opts.add_argument("--log-level=3")
+        opts.add_argument("--start-maximized")
+        if self.headless:
+            opts.add_argument("--headless")
+        opts.add_experimental_option("excludeSwitches", ["enable-automation"])
+        opts.add_experimental_option("useAutomationExtension", False)
+        opts.add_experimental_option(
+            "prefs",
+            {
+                "credentials_enable_service": False,
+                "profile.password_manager_enabled": False,
+            },
+        )
+
+        chrome_install = ChromeDriverManager().install()
+        folder = os.path.dirname(chrome_install)
+        driver_path = os.path.join(folder, "chromedriver.exe")
+        svc = ChromeService(driver_path)
+
+        self.driver = Chrome(service=svc, options=opts)
+        self.wait = WebDriverWait(self.driver, self.timeout)
+
+    def _encerrar_driver(self) -> None:
+        if self.driver:
+            self.driver.close()
+            self.driver = None
+        if self.wait:
+            self.wait = None
+
+    def __enter__(self) -> "SeleniumHandler":
+        """Ponto de entrada do gerenciador de contexto."""
+        self._inicializar_driver()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
+        """Ponto de saída do gerenciador de contexto."""
+        self._encerrar_driver()
+
+    def _get_driver_e_espera(
+        self,
+    ) -> tuple[Chrome, WebDriverWait[Chrome]]:
+        if not self.driver or not self.wait:
+            raise HandlerException("Driver e/ou espera não inicializados.")
+        return self.driver, self.wait
+
+    def acessar_sei(self, usuario: str, senha: str, orgao: str = "ARTESP"):
+        """Acessa e faz login no portal SEI."""
+        driver, wait = self._get_driver_e_espera()
+
+        if not isinstance(usuario, str):
+            msg = "Acessando SEI: usuario deve ser uma string"
+            raise TypeError(msg)  # pyright:ignore[reportUnreachable]
+        if not usuario:
+            msg = "Acessando SEI: usuário deve ser uma string não vazia"
+            raise ValueError(msg)
+        if not isinstance(senha, str):
+            msg = "Acessando SEI: senha deve ser uma string"
+            raise TypeError(msg)  # pyright:ignore[reportUnreachable]
+        if not senha:
+            msg = "Acessando SEI: senha deve ser uma string não vazia"
+            raise ValueError(msg)
+        if not isinstance(orgao, str):
+            msg = "Acessando SEI: orgao deve ser uma string"
+            raise TypeError(msg)  # pyright:ignore[reportUnreachable]
+        if not orgao:
+            msg = "Acessando SEI: órgão deve ser uma string não vazia"
+            raise ValueError(msg)
+
+        LoginPage(driver, wait).fazer_login(usuario, senha, orgao)
+        self._page = HomePage(driver, wait)
+        self._page.fechar_modal_novidades()
+
+    def trocar_unidade(self, unidade: str):
+        driver, wait = self._get_driver_e_espera()
+
+        if not isinstance(unidade, str):
+            msg = "Trocando unidade: unidade deve ser uma string"
+            raise TypeError(msg)  # pyright:ignore[reportUnreachable]
+        if not unidade:
+            msg = "Trocando unidade: unidade deve ser uma string não vazia"
+            raise ValueError(msg)
+
+        self.page.navbar.trocar_unidade(unidade)
+        self._page = HomePage(driver, wait)
+
+    def buscar_processo(self, processo: str) -> bool:
+        driver, wait = self._get_driver_e_espera()
+
+        encontrado = self.page.navbar.buscar_processo(processo)
+        if encontrado:
+            self._page = ProcessoPage(driver, wait)
+        return encontrado
+
+    def ler_processos_recebidos(self) -> pd.DataFrame:
+        if not isinstance(self.page, HomePage):
+            msg = "página atual não é a página de controle de processos"
+            raise InvalidPageException(msg)
+
+        r = self.page.ler_tabela_recebidos()
+        if not r.empty:
+            r = (
+                r.drop(columns=["Unnamed: 0", "Recebidos", "Recebidos.2"])
+                .rename(columns={"Recebidos.1": "Processo"})
+                .drop_duplicates(ignore_index=True)
+            )
+
+        return r
+
+    def ler_processos_gerados(self) -> pd.DataFrame:
+        if not isinstance(self.page, HomePage):
+            msg = "página atual não é a página de controle de processos"
+            raise InvalidPageException(msg)
+
+        g = self.page.ler_tabela_gerados()
+        if not g.empty:
+            g = (
+                g.drop(columns=["Unnamed: 0", "Gerados", "Gerados.2"])
+                .rename(columns={"Gerados.1": "Processo"})
+                .drop_duplicates(ignore_index=True)
+            )
+
+        return g
+
+    def ler_processos_unidade(self) -> pd.DataFrame:
+        """Retorna os processos recebidos e gerados em um DF."""
+        r = self.ler_processos_recebidos()
+        g = self.ler_processos_gerados()
+        return pd.concat([r, g], ignore_index=True)
+
+    def ler_status(self) -> str | list[str]:
+        if not isinstance(self.page, ProcessoPage):
+            msg = "página atual não é a página de processo"
+            raise InvalidPageException(msg)
+        return self.page.ler_status()
+
+    def ler_marcadores(self) -> list[str]:
+        if not isinstance(self.page, ProcessoPage):
+            msg = "página atual não é a página de processo"
+            raise InvalidPageException(msg)
+        return self.page.ler_marcadores()
+
+    def ler_prazo(self) -> dt.date | None:
+        if not isinstance(self.page, ProcessoPage):
+            msg = "página atual não é a página de processo"
+            raise InvalidPageException(msg)
+        return self.page.ler_prazo()
+
+    def ler_andamentos(self) -> pd.DataFrame:
+        if not isinstance(self.page, ProcessoPage):
+            msg = "página atual não é a página de processo"
+            raise InvalidPageException(msg)
+        return self.page.ler_andamentos()
+
+    def mover_documentos(self, nome: str, destino: str, motivo: str) -> None:
+        if not isinstance(self.page, ProcessoPage):
+            msg = "página atual não é a página de processo"
+            raise InvalidPageException(msg)
+        if not isinstance(nome, str):
+            msg = "nome deve ser uma string"
+            raise TypeError(msg)  # pyright: ignore[reportUnreachable]
+        if not nome:
+            msg = "nome deve ser uma string não vazia"
+            raise ValueError(msg)
+        if not isinstance(destino, str):
+            msg = "destino deve ser uma string"
+            raise TypeError(msg)  # pyright: ignore[reportUnreachable]
+        if not destino:
+            msg = "destino deve ser uma string não vazia"
+            raise ValueError(msg)
+        if not isinstance(motivo, str):
+            msg = "motivo deve ser uma string"
+            raise TypeError(msg)  # pyright: ignore[reportUnreachable]
+        if not motivo:
+            msg = "motivo deve ser uma string não vazia"
+            raise ValueError(msg)
+
+        self.page.mover_documentos(nome, destino, motivo)
+
+    def concluir_processo(self) -> None:
+        if not isinstance(self.page, ProcessoPage):
+            msg = "página atual não é a página de processo"
+            raise InvalidPageException(msg)
+        self.page.concluir_processo()
+
+    def anexar_processo(self, processo: str) -> None:
+        if not isinstance(self.page, ProcessoPage):
+            msg = "página atual não é a página de processo"
+            raise InvalidPageException(msg)
+        self.page.anexar_processo(processo)
+
+    def conceder_vistas(
+        self,
+        email: str,
+        tipo: Literal["acompanhamento", "disponibilizacao"],
+        motivo: str,
+        dias: int,
+        token: str,
+    ) -> None:
+        if not isinstance(self.page, ProcessoPage):
+            msg = "página atual não é a página de processo"
+            raise InvalidPageException(msg)
+        if not isinstance(email, str):
+            msg = "email deve ser uma string"
+            raise TypeError(msg)  # pyright: ignore[reportUnreachable]
+        if not email:
+            msg = "email deve ser uma string não vazia"
+            raise ValueError(msg)
+        if not isinstance(motivo, str):
+            msg = "motivo deve ser uma string"
+            raise TypeError(msg)  # pyright: ignore[reportUnreachable]
+        if not motivo:
+            msg = "motivo deve ser uma string não vazia"
+            raise ValueError(msg)
+        if not isinstance(dias, int):
+            msg = "dias deve ser um int"
+            raise TypeError(msg)  # pyright: ignore[reportUnreachable]
+        if not dias:
+            msg = "dias deve ser maior que zero"
+            raise ValueError(msg)
+        if not isinstance(token, str):
+            msg = "token deve ser uma string"
+            raise TypeError(msg)  # pyright: ignore[reportUnreachable]
+        if not token:
+            msg = "token deve ser uma string não vazia"
+            raise ValueError(msg)
+
+        self.page.conceder_vistas(email, tipo, motivo, str(dias), token)

artespy/selenium/locators.py

@@ -0,0 +1,96 @@
+from typing import final
+
+from selenium.webdriver.common.by import By
+
+
+@final
+class Locators:
+    # Login
+    InputUsuario = By.ID, "txtUsuario"
+    InputSenha = By.ID, "pwdSenha"
+    SelOrgao = By.ID, "selOrgao"
+    BtnLogin = By.ID, "sbmAcessar"
+
+    # Geral
+    FecharModalNovidade = By.XPATH, "//*[@title='Fechar janela (ESC)']"
+    CxUnidade = By.CSS_SELECTOR, "#divInfraBarraSistemaPadrao #lnkInfraUnidade"
+    LinhaUnidade = By.XPATH, "//td[contains(text(), '{}')]"
+    BuscaRapida = By.ID, "txtPesquisaRapida"
+    ProcessoNaoEncontrado = By.CSS_SELECTOR, "#conteudo > div"
+
+    # Controle de processos
+    TblRecebidos = By.ID, "tblProcessosRecebidos"
+    SelPagRecebidos = By.ID, "selRecebidosPaginacaoSuperior"
+    ProxPagRecebidos = By.ID, "lnkRecebidosProximaPaginaSuperior"
+    TblGerados = By.ID, "tblProcessosGerados"
+    SelPagGerados = By.ID, "selGeradosPaginacaoSuperior"
+    ProxPagGerados = By.ID, "lnkGeradosProximaPaginaSuperior"
+
+    # Processo
+    IframeArvore = By.ID, "ifrArvore"
+    IframeConteudo = By.ID, "ifrConteudoVisualizacao"
+    IframeVisualizacao = By.ID, "ifrVisualizacao"
+    DivStatus = By.ID, "divArvoreInformacao"
+    UnidadesStatus = By.TAG_NAME, "a"
+    Marcadores = By.XPATH, "//*[contains(@title, 'Marcador')]"
+    Prazo = By.XPATH, '//*[contains(@title, "Controle de Prazo:")]'
+    BtnAndamentos = By.CSS_SELECTOR, "#divConsultarAndamento > a"
+    TipoHistorico = By.ID, "ancTipoHistorico"
+    TblAndamentos = By.ID, "tblHistorico"
+    SelPagAndamentos = By.ID, "selInfraPaginacaoSuperior"
+    ProxPagAndamentos = By.ID, "lnkInfraProximaPaginaSuperior"
+    DivArvore = By.ID, "divArvore"
+    Documentos = By.XPATH, "//*/a[@target='ifrConteudoVisualizacao']"
+    Documento = By.LINK_TEXT, "{}"
+    DivArvoreInfo = By.ID, "divArvoreInformacao"
+    # Ações
+    AcaoMover = By.XPATH, "//*[@title='Mover Documento para outro Processo']"
+    AcaoConcluir = By.XPATH, "//*[@title='Concluir Processo']"
+    AcaoAnexar = By.XPATH, "//*[@title='Anexar Processo']"
+    AcaoVistas = (
+        By.XPATH,
+        "//*[@title='Gerenciar Disponibilizações de Acesso Externo']",
+    )
+    AcaoMarcadores = By.XPATH, "//*[@title='Gerenciar Marcador']"
+    # Mover Documento
+    ProcessoDestino = By.ID, "txtProcedimentoDestino"
+    BtnPesquisar = By.ID, "btnPesquisar"
+    InputMotivoMover = By.ID, "txaMotivo"
+    BtnMover = By.ID, "sbmMover"
+    # Concluir Processo
+    BtnSalvarConclusao = By.ID, "sbmSalvar"
+    # Anexar Processo
+    InputAnexar = By.ID, "txtProtocolo"
+    BtnPesquisar = By.ID, "btnPesquisar"
+    BtnAnexar = By.ID, "sbmAnexar"
+    # Vistas
+    InputEmailUnidade = By.ID, "selEmailUnidade"
+    FiltroUsuarioExterno = By.ID, "lblUsuariosExternos"
+    InputDestinatario = By.ID, "txtDestinatario"
+    AutocompleteDestinatario = By.ID, "divInfraAjaxtxtDestinatario"
+    InputEmailDestinatario = By.ID, "txtEmailDestinatario"
+    InputMotivoVistas = By.ID, "txaMotivo"
+    OptVistasIntegral = By.ID, "lblIntegral"
+    OptVistasParcial = By.ID, "lblParcial"
+    PermitirInclusaoDocs = By.ID, "lblSinInclusao"
+    SelecionarDocs = By.ID, "imgLupaSeries"
+    SelecionarProtocolos = By.ID, "imgLupaProtocolos"
+    IframeModal = By.NAME, "modal-frame"
+    FecharModalDocs = By.XPATH, "//*[@title='Fechar janela (ESC)']"
+    SelPagDocs = By.ID, "selInfraPaginacaoSuperior"
+    BtnTransportar = (
+        By.CSS_SELECTOR,
+        "#divInfraBarraComandosSuperior > #btnTransportarSelecao",
+    )
+    OptDocAnexo = (
+        By.CSS_SELECTOR,
+        "a#lnkInfraID-1917 ~ div.infraCheckboxDiv > label",
+    )
+    OptDocManifestacaoTecnica = (
+        By.CSS_SELECTOR,
+        "a#lnkInfraID-64 ~ div.infraCheckboxDiv > label",
+    )
+    OptTodosDocs = By.ID, "imgInfraCheck"
+    InputDiasVistas = By.ID, "txtDias"
+    InputTokenVistas = By.ID, "pwdSenha"
+    BtnDisponibilizar = By.ID, "btnDisponibilizar"

artespy/selenium/pages/base.py

@@ -0,0 +1,34 @@
+from selenium.common.exceptions import TimeoutException
+from selenium.webdriver import Chrome
+from selenium.webdriver.support import expected_conditions as EC
+from selenium.webdriver.support.ui import WebDriverWait
+
+from artespy.selenium.pages.components.navbar import Navbar
+
+
+class BasePage:
+    def __init__(self, driver: Chrome, wait: WebDriverWait[Chrome]) -> None:
+        self.driver: Chrome = driver
+        self.wait: WebDriverWait[Chrome] = wait
+
+    def get_texto_alerta(self, timeout=5) -> str:
+        try:
+            return (
+                WebDriverWait(self.driver, timeout)
+                .until(EC.alert_is_present())
+                .text
+            )
+        except TimeoutException:
+            return ""
+
+    def confirmar_alerta(self):
+        self.driver.switch_to.alert.accept()
+
+    def fechar_alerta(self):
+        self.driver.switch_to.alert.dismiss()
+
+
+class BaseLoggedInPage(BasePage):
+    def __init__(self, driver: Chrome, wait: WebDriverWait[Chrome]) -> None:
+        super().__init__(driver, wait)
+        self.navbar: Navbar = Navbar(driver, wait)

artespy/selenium/pages/components/base.py

@@ -0,0 +1,8 @@
+from selenium.webdriver import Chrome
+from selenium.webdriver.support.ui import WebDriverWait
+
+
+class BaseComponent:
+    def __init__(self, driver: Chrome, wait: WebDriverWait[Chrome]) -> None:
+        self.driver: Chrome = driver
+        self.wait: WebDriverWait[Chrome] = wait

artespy/selenium/pages/components/navbar.py

@@ -0,0 +1,40 @@
+from selenium.common.exceptions import TimeoutException
+from selenium.webdriver import Keys
+from selenium.webdriver.support import expected_conditions as EC
+from selenium.webdriver.support.ui import WebDriverWait
+
+from artespy.selenium.locators import Locators as lc
+from artespy.selenium.pages.components.base import BaseComponent
+
+
+class Navbar(BaseComponent):
+    def get_unidade_atual(self) -> str:
+        return self.wait.until(EC.element_to_be_clickable(lc.CxUnidade)).text
+
+    def acessar_pag_unidade(self) -> None:
+        self.wait.until(EC.element_to_be_clickable(lc.CxUnidade)).click()
+
+    def trocar_unidade(self, unidade: str) -> None:
+        u = self.get_unidade_atual()
+        if u.lower() == unidade.strip().lower():
+            return
+
+        self.acessar_pag_unidade()
+
+        loc = lc.LinhaUnidade[0], lc.LinhaUnidade[1].format(unidade)
+        self.wait.until(EC.element_to_be_clickable(loc)).click()
+
+    def buscar_processo(self, processo: str) -> bool:
+        self.driver.switch_to.default_content()
+        busca = self.wait.until(EC.element_to_be_clickable(lc.BuscaRapida))
+        busca.send_keys(processo)
+        busca.send_keys(Keys.ENTER)
+
+        try:
+            _ = WebDriverWait(self.driver, 5).until(
+                EC.visibility_of_element_located(lc.ProcessoNaoEncontrado)
+            )
+        except TimeoutException:  # processo encontrado
+            return True
+        else:
+            return False

artespy/selenium/pages/home.py

@@ -0,0 +1,28 @@
+import pandas as pd
+from selenium.common.exceptions import TimeoutException
+from selenium.webdriver.support import expected_conditions as EC
+from selenium.webdriver.support.ui import WebDriverWait
+
+from artespy.selenium.locators import Locators as lc
+from artespy.selenium.pages.base import BaseLoggedInPage
+from artespy.selenium.pages.mixins.table import TableMixin
+
+
+class HomePage(BaseLoggedInPage, TableMixin):
+    def fechar_modal_novidades(self) -> None:
+        try:
+            WebDriverWait(self.driver, 5).until(
+                EC.element_to_be_clickable(lc.FecharModalNovidade)
+            ).click()
+        except TimeoutException:
+            pass  # modal ausente
+
+    def ler_tabela_recebidos(self) -> pd.DataFrame:
+        return self.ler_tabela(
+            lc.TblRecebidos, lc.SelPagRecebidos, lc.ProxPagRecebidos
+        )
+
+    def ler_tabela_gerados(self) -> pd.DataFrame:
+        return self.ler_tabela(
+            lc.TblGerados, lc.SelPagGerados, lc.ProxPagGerados
+        )

artespy/selenium/pages/login.py

@@ -0,0 +1,47 @@
+from selenium.webdriver.support import expected_conditions as EC
+from selenium.webdriver.support.ui import Select
+from artespy.errors import InvalidCredentialsError, UnknownAlertException
+from artespy.selenium.locators import Locators as lc
+from artespy.selenium.pages.base import BasePage
+
+
+class LoginPage(BasePage):
+    URL: str = "https://sei.sp.gov.br/sip/login.php?sigla_orgao_sistema=GESP&sigla_sistema=SEI&infra_url=L3NlaS8="
+
+    def acessar(self) -> None:
+        self.driver.get(self.URL)
+
+    def preencher_usuario(self, usuario: str) -> None:
+        self.wait.until(EC.element_to_be_clickable(lc.InputUsuario)).send_keys(
+            usuario
+        )
+
+    def preencher_senha(self, senha: str) -> None:
+        self.wait.until(EC.element_to_be_clickable(lc.InputSenha)).send_keys(
+            senha
+        )
+
+    def selecionar_orgao(self, orgao: str) -> None:
+        Select(
+            self.wait.until(EC.element_to_be_clickable(lc.SelOrgao))
+        ).select_by_visible_text(orgao)
+
+    def clicar_login(self) -> None:
+        self.wait.until(EC.element_to_be_clickable(lc.BtnLogin)).click()
+
+    def fazer_login(self, usuario: str, senha: str, orgao: str) -> None:
+        self.acessar()
+
+        self.preencher_usuario(usuario)
+        self.preencher_senha(senha)
+        self.selecionar_orgao(orgao)
+        self.clicar_login()
+
+        t = self.get_texto_alerta()
+        if t:
+            if t.lower() == "usuário ou senha inválida.":
+                msg = "usuário, senha ou órgão inválidos"
+                raise InvalidCredentialsError(msg)
+            else:
+                msg = f"alerta com mensagem inesperada: '{t}'"
+                raise UnknownAlertException(msg)

artespy/selenium/pages/mixins/table.py

@@ -0,0 +1,105 @@
+import re
+from io import StringIO
+from math import ceil
+
+import pandas as pd
+from selenium.common.exceptions import NoSuchElementException, TimeoutException
+from selenium.webdriver.common.by import By
+from selenium.webdriver.remote.webelement import WebElement
+from selenium.webdriver.support import expected_conditions as EC
+from selenium.webdriver.support.ui import Select, WebDriverWait
+
+from artespy.errors import ElementNotFoundException
+from artespy.selenium.locators import Locators as lc
+
+
+class TableMixin:
+    def get_tabela(self, locator: tuple[str, str]) -> WebElement | None:
+        sw = WebDriverWait(self.driver, 5)
+        try:
+            return sw.until(EC.visibility_of_element_located(locator))
+        except TimeoutException:
+            # Tabela de processos recebidos/gerados pode não estar presente
+            # caso nenhum processo da categoria correspondente esteja na
+            # unidade
+            if locator == lc.TblRecebidos or locator == lc.TblGerados:
+                return None
+            msg = f"Tabela '{locator}' não encontrada"
+            raise ElementNotFoundException(msg)
+
+    def calcular_num_pags(self, tbl: WebElement) -> int:
+        try:
+            caption = tbl.find_element(By.TAG_NAME, "caption")
+        except NoSuchElementException:
+            return 0
+
+        txt = caption.text
+        if not txt:
+            return 0
+
+        match = re.search(r"\d+", txt)
+        qtd_processos = int(match.group(0)) if match else 0
+        return ceil(qtd_processos / 100)
+
+    def ler_tabela(
+        self,
+        tbl_lc: tuple[str, str],
+        sel_lc: tuple[str, str],
+        btn_lc: tuple[str, str],
+    ) -> pd.DataFrame:
+        tbl = self.get_tabela(tbl_lc)
+        if tbl is None:
+            return pd.DataFrame()
+
+        primeira_pag = pd.read_html(StringIO(tbl.get_attribute("outerHTML")))
+        df = primeira_pag[0]
+
+        pags = self.calcular_num_pags(tbl)
+        sw = WebDriverWait(self.driver, 10)
+        if pags >= 3:
+            sel = Select(sw.until(EC.visibility_of_element_located(sel_lc)))
+            for i in range(1, len(sel.options)):
+                # Relocalizar o select pra evitar StaleElementReferenceException
+                Select(
+                    sw.until(EC.element_to_be_clickable(sel_lc))
+                ).select_by_index(i)
+                pag = self.wait.until(EC.visibility_of_element_located(tbl_lc))
+                pag_df = pd.read_html(StringIO(pag.get_attribute("outerHTML")))
+                df = pd.concat([df, pag_df[0]], ignore_index=True)
+        if pags == 2:
+            sw.until(EC.element_to_be_clickable(btn_lc)).click()
+
+            pag = self.wait.until(EC.visibility_of_element_located(tbl_lc))
+            pag_df = pd.read_html(StringIO(pag.get_attribute("outerHTML")))
+            df = pd.concat([df, pag_df[0]], ignore_index=True)
+        if not pags:
+            try:
+                sel = Select(sw.until(EC.visibility_of_element_located(sel_lc)))
+            except TimeoutException:
+                pass  # tabela não possui 3+ páginas
+            else:
+                for i in range(1, len(sel.options)):
+                    # Relocalizar o select pra evitar StaleElementReferenceException
+                    Select(
+                        sw.until(EC.element_to_be_clickable(sel_lc))
+                    ).select_by_index(i)
+                    pag = self.wait.until(
+                        EC.visibility_of_element_located(tbl_lc)
+                    )
+                    pag_df = pd.read_html(
+                        StringIO(pag.get_attribute("outerHTML"))
+                    )
+                    df = pd.concat([df, pag_df[0]], ignore_index=True)
+
+                return df
+
+            try:
+                sw.until(EC.element_to_be_clickable(btn_lc)).click()
+            except TimeoutException:
+                pass  # tabela não possui 2 páginas
+            else:
+                pag = self.wait.until(EC.visibility_of_element_located(tbl_lc))
+                pag_df = pd.read_html(StringIO(pag.get_attribute("outerHTML")))
+                df = pd.concat([df, pag_df[0]], ignore_index=True)
+
+        return df

artespy/selenium/pages/processo.py

@@ -0,0 +1,378 @@
+import datetime as dt
+from logging import getLogger
+import re
+from typing import Literal
+
+import pandas as pd
+from selenium.common.exceptions import TimeoutException
+from selenium.webdriver import Chrome, Keys
+from selenium.webdriver.remote.webelement import WebElement
+from selenium.webdriver.support import expected_conditions as EC
+from selenium.webdriver.support.ui import Select, WebDriverWait
+
+from artespy.errors import (
+    ElementNotFoundException,
+    HandlerException,
+    SeiException,
+    UnknownAlertException,
+)
+from artespy.selenium.locators import Locators as lc
+from artespy.selenium.pages.base import BaseLoggedInPage
+from artespy.selenium.pages.mixins.table import TableMixin
+
+logger = getLogger(__name__)
+
+
+class ProcessoPage(BaseLoggedInPage, TableMixin):
+    def __init__(self, driver: Chrome, wait: WebDriverWait[Chrome]) -> None:
+        super().__init__(driver, wait)
+        self.sw: WebDriverWait[Chrome] = WebDriverWait(driver, 5)
+
+    def acessar_iframe_arvore(self) -> None:
+        self.driver.switch_to.default_content()
+        _ = self.wait.until(
+            EC.frame_to_be_available_and_switch_to_it(lc.IframeArvore)
+        )
+
+    def acessar_iframe_conteudo(self) -> None:
+        self.driver.switch_to.default_content()
+        _ = self.wait.until(
+            EC.frame_to_be_available_and_switch_to_it(lc.IframeConteudo)
+        )
+
+    def acessar_iframe_visualizacao(self) -> None:
+        self.acessar_iframe_conteudo()
+        _ = self.wait.until(
+            EC.frame_to_be_available_and_switch_to_it(lc.IframeVisualizacao)
+        )
+
+    def acessar_iframe_modal(self) -> None:
+        self.driver.switch_to.default_content()
+        _ = self.wait.until(
+            EC.frame_to_be_available_and_switch_to_it(lc.IframeModal)
+        )
+
+    def acessar_acao(self, loc: tuple[str, str]) -> None:
+        self.acessar_iframe_conteudo()
+        try:
+            self.wait.until(EC.element_to_be_clickable(loc)).click()
+        except TimeoutException:
+            msg = "timeout ao localizar ação"
+            raise ElementNotFoundException(msg)
+
+    def acessar_acao_mover(self) -> None:
+        self.acessar_acao(lc.AcaoMover)
+
+    def acessar_acao_concluir(self) -> None:
+        self.acessar_acao(lc.AcaoConcluir)
+
+    def acessar_acao_anexar(self) -> None:
+        self.acessar_acao(lc.AcaoAnexar)
+
+    def acessar_acao_vistas(self) -> None:
+        self.acessar_acao(lc.AcaoVistas)
+
+    def ler_status(self) -> str | list[str]:
+        self.acessar_iframe_visualizacao()
+
+        div_status = self.wait.until(
+            EC.visibility_of_element_located(lc.DivStatus)
+        )
+        txt = div_status.text
+
+        if not txt:
+            return ""
+
+        status: str | list[str] = ""
+        if txt.startswith("Processo aberto somente"):
+            u = div_status.find_element(
+                lc.UnidadesStatus[0], lc.UnidadesStatus[1]
+            )
+            status = u.text
+        elif txt.startswith("Processo aberto nas"):
+            elementos = div_status.find_elements(
+                lc.UnidadesStatus[0], lc.UnidadesStatus[1]
+            )
+            unidades = []
+            for e in elementos:
+                t = e.text
+                match = re.match(r"^\d*$|^\w*\.\w*$", t)
+                if match is not None:
+                    continue
+                unidades.append(t)
+            status = unidades
+        elif txt.startswith("Processo sobrestado"):
+            status = "Sobretado"
+        elif txt.startswith("Processo anexado"):
+            status = "Incorporado"
+        elif txt.startswith("Processo não possui"):
+            status = "Concluído"
+        else:
+            msg = "div status começa com um fragmento de texto não registrado"
+            raise HandlerException(msg)
+
+        return status
+
+    def ler_marcadores(self) -> list[str]:
+        self.acessar_iframe_arvore()
+
+        ms = []
+        try:
+            elems = self.sw.until(
+                EC.visibility_of_all_elements_located(lc.Marcadores)
+            )
+        except TimeoutException:
+            return ms
+        for e in elems:
+            titulo = e.get_attribute("title")
+            if not titulo:
+                continue
+            m = titulo.split("\n")[1]
+            ms.append(m)
+
+        return ms
+
+    def ler_prazo(self) -> dt.date | None:
+        self.acessar_iframe_arvore()
+
+        try:
+            e = self.sw.until(EC.visibility_of_element_located(lc.Prazo))
+        except TimeoutException:
+            return None
+        t = e.get_attribute("title")
+        if t is None:
+            return None
+        return dt.datetime.strptime(t.split(" ")[3], "%d/%m/%Y").date()
+
+    def visualizar_andamentos(self) -> None:
+        self.acessar_iframe_arvore()
+        self.wait.until(EC.element_to_be_clickable(lc.BtnAndamentos)).click()
+        self.acessar_iframe_visualizacao()
+
+        tipo = self.wait.until(EC.element_to_be_clickable(lc.TipoHistorico))
+        if tipo.text == "Ver histórico completo":
+            tipo.click()
+
+    def retornar_andamentos(self) -> pd.DataFrame:
+        self.acessar_iframe_visualizacao()
+        andamentos = self.ler_tabela(
+            lc.TblAndamentos, lc.SelPagAndamentos, lc.ProxPagAndamentos
+        )
+        andamentos["Data/Hora"] = pd.to_datetime(
+            andamentos["Data/Hora"], format="%d/%m/%Y %H:%M"
+        )
+        df = andamentos.drop_duplicates(ignore_index=True).sort_values(
+            by="Data/Hora", ascending=False
+        )
+        return df
+
+    def ler_andamentos(self) -> pd.DataFrame:
+        self.visualizar_andamentos()
+        return self.retornar_andamentos()
+
+    def get_documentos(self) -> list[WebElement]:
+        self.acessar_iframe_arvore()
+        return self.wait.until(
+            EC.visibility_of_all_elements_located(lc.Documentos)
+        )
+
+    def get_nomes_documentos(self) -> list[str]:
+        elems = self.get_documentos()
+        docs = []
+        for e in elems:
+            docs.append(e.text)
+        return docs
+
+    def acessar_documento(self, nome: str) -> None:
+        self.acessar_iframe_arvore()
+        loc = lc.Documento[0], lc.Documento[1].format(nome)
+        self.sw.until(EC.element_to_be_clickable(loc)).click()
+
+    def verificar_presenca_documento(self) -> bool:
+        self.acessar_iframe_visualizacao()
+        div_info = self.wait.until(
+            EC.visibility_of_element_located(lc.DivArvoreInfo)
+        )
+        if "Documento movido" in div_info.text:
+            return False
+        return True
+
+    def mover_documentos(self, nome: str, destino: str, motivo: str) -> None:
+        docs = self.get_nomes_documentos()
+        for d in docs:
+            if nome not in d:
+                continue
+            # Recibo não pode ser movido
+            if "Recibo Eletrônico" in d:
+                continue
+            self.acessar_documento(d)
+            presente = self.verificar_presenca_documento()
+            if not presente:
+                continue
+
+            self.acessar_acao_mover()
+            self.acessar_iframe_visualizacao()
+
+            self.wait.until(
+                EC.element_to_be_clickable(lc.ProcessoDestino)
+            ).send_keys(destino)
+            self.wait.until(EC.element_to_be_clickable(lc.BtnPesquisar)).click()
+
+            t = self.get_texto_alerta()
+            if t:
+                if t == "Processo não encontrado.":
+                    self.confirmar_alerta()
+                    msg = f"processo destino ({destino}) não encontrado"
+                    raise SeiException(msg)
+                else:
+                    self.fechar_alerta()
+                    msg = f"alerta com mensagem inesperada: '{t}'"
+                    raise UnknownAlertException(msg)
+            self.wait.until(
+                EC.element_to_be_clickable(lc.InputMotivoMover)
+            ).send_keys(motivo)
+            self.wait.until(EC.element_to_be_clickable(lc.BtnMover)).click()
+            logger.info(f"documento '{nome}' movido para {destino}")
+
+    def concluir_processo(self) -> None:
+        self.acessar_acao_concluir()
+        self.acessar_iframe_visualizacao()
+        self.wait.until(
+            EC.element_to_be_clickable(lc.BtnSalvarConclusao)
+        ).click()
+
+    def anexar_processo(self, processo: str) -> None:
+        self.acessar_acao_anexar()
+        self.acessar_iframe_visualizacao()
+        self.wait.until(EC.element_to_be_clickable(lc.InputAnexar)).send_keys(
+            processo
+        )
+        self.wait.until(EC.element_to_be_clickable(lc.BtnPesquisar)).click()
+        t = self.get_texto_alerta()
+        if t:
+            if t == "Processo não encontrado.":
+                self.confirmar_alerta()
+                msg = f"processo a ser anexado ({processo}) não encontrado"
+                raise SeiException(msg)
+            else:
+                self.fechar_alerta()
+                msg = f"alerta com mensagem inesperada: '{t}'"
+                raise UnknownAlertException(msg)
+        self.wait.until(EC.element_to_be_clickable(lc.BtnAnexar)).click()
+
+    def preencher_destinatario(self, email: str) -> None:
+        self.wait.until(
+            EC.element_to_be_clickable(lc.FiltroUsuarioExterno)
+        ).click()
+        destinatario = self.wait.until(
+            EC.element_to_be_clickable(lc.InputDestinatario)
+        )
+        destinatario.send_keys(email)
+        try:
+            _ = self.wait.until(
+                EC.visibility_of_element_located(lc.AutocompleteDestinatario)
+            )
+        except TimeoutException:
+            self.wait.until(
+                EC.element_to_be_clickable(lc.InputEmailDestinatario)
+            ).send_keys(email)
+        else:
+            destinatario.send_keys(Keys.ARROW_DOWN)
+            destinatario.send_keys(Keys.ENTER)
+
+    def preencher_motivo_vistas(self, motivo: str) -> None:
+        self.wait.until(
+            EC.element_to_be_clickable(lc.InputMotivoVistas)
+        ).send_keys(motivo)
+
+    def preencher_opcoes_acompanhamento(self) -> None:
+        self.wait.until(
+            EC.element_to_be_clickable(lc.OptVistasIntegral)
+        ).click()
+        self.wait.until(
+            EC.element_to_be_clickable(lc.PermitirInclusaoDocs)
+        ).click()
+        self.wait.until(EC.element_to_be_clickable(lc.SelecionarDocs)).click()
+
+        self.acessar_iframe_modal()
+
+        self.wait.until(EC.element_to_be_clickable(lc.OptDocAnexo)).click()
+        self.wait.until(EC.element_to_be_clickable(lc.BtnTransportar)).click()
+
+        sel_pag = Select(
+            self.wait.until(EC.element_to_be_clickable(lc.SelPagDocs))
+        )
+        sel_pag.select_by_index(34)
+        self.wait.until(
+            EC.element_to_be_clickable(lc.OptDocManifestacaoTecnica)
+        ).click()
+        self.wait.until(EC.element_to_be_clickable(lc.BtnTransportar)).click()
+
+        sel_pag = Select(  # Evitar StaleElementReference
+            self.wait.until(EC.element_to_be_clickable(lc.SelPagDocs))
+        )
+        sel_pag.select_by_index(0)
+
+        self.driver.switch_to.default_content()
+        self.wait.until(EC.element_to_be_clickable(lc.FecharModalDocs)).click()
+
+    def preencher_opcoes_disponibilizacao(self) -> None:
+        self.wait.until(EC.element_to_be_clickable(lc.OptVistasParcial)).click()
+        self.wait.until(
+            EC.element_to_be_clickable(lc.SelecionarProtocolos)
+        ).click()
+
+        self.acessar_iframe_modal()
+
+        self.wait.until(EC.element_to_be_clickable(lc.OptTodosDocs)).click()
+        self.wait.until(EC.element_to_be_clickable(lc.BtnTransportar)).click()
+
+        self.driver.switch_to.default_content()
+        self.wait.until(EC.element_to_be_clickable(lc.FecharModalDocs)).click()
+
+    def preencher_opcoes_cedoc(self) -> None:
+        self.wait.until(
+            EC.element_to_be_clickable(lc.OptVistasIntegral)
+        ).click()
+
+    def conceder_vistas(
+        self,
+        email: str,
+        tipo: Literal["acompanhamento", "disponibilizacao"],
+        motivo: str,
+        dias: str,
+        token: str,
+    ) -> None:
+        self.acessar_acao_vistas()
+        self.acessar_iframe_visualizacao()
+
+        Select(
+            self.wait.until(EC.element_to_be_clickable(lc.InputEmailUnidade))
+        ).select_by_index(2)
+
+        self.preencher_destinatario(email)
+        self.preencher_motivo_vistas(motivo)
+        if tipo == "acompanhamento":
+            if (
+                "cedoc" in email
+                or "protocolo" in email
+                or "regulatorio" in email
+                or "adm.suref" in email
+            ):
+                self.preencher_opcoes_cedoc()
+            else:
+                self.preencher_opcoes_acompanhamento()
+        elif tipo == "disponibilizacao":
+            self.preencher_opcoes_disponibilizacao()
+
+        self.acessar_iframe_visualizacao()
+        self.wait.until(
+            EC.element_to_be_clickable(lc.InputDiasVistas)
+        ).send_keys(dias)
+        self.wait.until(
+            EC.element_to_be_clickable(lc.InputTokenVistas)
+        ).send_keys(token)
+        self.wait.until(
+            EC.element_to_be_clickable(lc.BtnDisponibilizar)
+        ).click()
+        logger.info(f"vistas concedidas para '{email}'")

artespy-0.1.0.dist-info/METADATA

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: artespy
+Version: 0.1.0
+Summary: Add your description here
+Author-email: Leonardo Hossokawa de Oliveira <estagiario.seguros04@artesp.sp.gov.br>
+Requires-Python: >=3.13
+Requires-Dist: lxml>=6.0.2
+Requires-Dist: pandas>=2.3.3
+Requires-Dist: selenium>=4.38.0
+Requires-Dist: webdriver-manager>=4.0.2

artespy-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+artespy/__init__.py,sha256=gYDuQkdNUX9hQy4rj1JHZZFa7ynX6ypUaR1bMPHR7es,87
+artespy/errors/__init__.py,sha256=EjFOKtG9Z3Qdzo_LRYiJFzxCF-OIoTnEQvwFg0SyGfQ,444
+artespy/selenium/handler.py,sha256=YdIGJq8ZNaPl9R2pD__-0RnTycma-3EPqLJjpQ5hxdw,10369
+artespy/selenium/locators.py,sha256=zH9-qOexTcOfeE9eZtMP43uyduMU6vYidkD7a3Lt_9Q,3942
+artespy/selenium/pages/base.py,sha256=HnFpwm0323O-zAYx2nOB425ERebhGOGmfXevEdhDp9E,1121
+artespy/selenium/pages/home.py,sha256=Fjwsi-bCIbW2WL0V6jwqPm0V29h8Wg_E-IPBMJHKkBA,1027
+artespy/selenium/pages/login.py,sha256=Kej4gxdp6PJhp-U5QNewcncsPDSl65lJLGd9KqEVsP0,1752
+artespy/selenium/pages/processo.py,sha256=uNiNrXQERk0TpPfghoad1Tos6KH14_QMUMUIzZ8iVHc,13577
+artespy/selenium/pages/components/base.py,sha256=pMUR4074h25hrhdveimvrrUo4NkYGHiKTocqy2ZEJ0k,287
+artespy/selenium/pages/components/navbar.py,sha256=J1GL10wqdepZTkx4oVMuoqI1foqXZSVdhOsM45g7Pdw,1492
+artespy/selenium/pages/mixins/table.py,sha256=me60-IRKeAcfzWf4Lw5FljuY5oXZt71UANCCcnCo1wk,4272
+artespy-0.1.0.dist-info/METADATA,sha256=pzXODMRiVG69BRzigTThU711mgKpbRS1ZBOq1WOJ-7A,323
+artespy-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+artespy-0.1.0.dist-info/entry_points.txt,sha256=7CEe8vB91bPbabrPYtw6P77JFVvwa-RkUKSWMWOlaiM,41
+artespy-0.1.0.dist-info/RECORD,,

artespy-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

artespy-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+artespy = artespy:main