artespy 0.1.0__tar.gz

artespy-0.1.0/.gitignore

@@ -0,0 +1,10 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv

artespy-0.1.0/.python-version

@@ -0,0 +1 @@
+3.13

artespy-0.1.0/PKG-INFO

@@ -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/pyproject.toml

@@ -0,0 +1,22 @@
+[project]
+name = "artespy"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+authors = [
+    { name = "Leonardo Hossokawa de Oliveira", email = "estagiario.seguros04@artesp.sp.gov.br" }
+]
+requires-python = ">=3.13"
+dependencies = [
+    "lxml>=6.0.2",
+    "pandas>=2.3.3",
+    "selenium>=4.38.0",
+    "webdriver-manager>=4.0.2",
+]
+
+[project.scripts]
+artespy = "artespy:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"

artespy-0.1.0/src/artespy/__init__.py

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

artespy-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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)