onerom-core 0.1.0__tar.gz

onerom_core-0.1.0/.gitignore

@@ -0,0 +1,2 @@
+# Local Netlify folder
+.netlify

onerom_core-0.1.0/PKG-INFO

@@ -0,0 +1,156 @@
+Metadata-Version: 2.4
+Name: onerom-core
+Version: 0.1.0
+Summary: SDK oficial para automacoes ONEROM
+License: MIT
+Keywords: automation,onerom,rpa,sdk
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.9
+Requires-Dist: pydantic>=2.0
+Requires-Dist: requests>=2.28
+Provides-Extra: dev
+Requires-Dist: pytest-cov; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# onerom-core
+
+SDK oficial Python para automações ONEROM.
+
+Usado dentro de bots executados pelo ONEROM Runner.
+
+## Instalação
+
+```bash
+pip install onerom-core
+```
+
+Ou via `pyproject.toml` do bot:
+
+```toml
+[project]
+dependencies = ["onerom-core>=0.1.0"]
+```
+
+## Uso básico
+
+```python
+from onerom_core import OneromExecution
+import logging
+
+# Inicializa contexto da execução
+# - Carrega parâmetros da execução automaticamente
+# - Anexa handler de log estruturado ao logger raiz
+exec = OneromExecution()
+
+# Acesso a parâmetros tipados
+nome = exec.params.nome
+count = exec.params.count
+
+# Logging — capturado pelo runner e enviado ao backend
+logging.info(f"Processando {nome}")
+
+# Contagem de itens
+for item in get_items():
+    try:
+        process(item)
+        exec.add_success_item()
+    except Exception:
+        exec.add_failed_item()
+
+# Finaliza com sucesso
+exec.finish_success()
+```
+
+## Uso com wrapper automático
+
+```python
+from onerom_core import OneromExecution
+
+exec = OneromExecution()
+
+def main():
+    logging.info("Bot iniciado")
+    # ... lógica do bot ...
+
+# Gerencia mark_running → main() → finish_success/failed automaticamente
+exec.run(main)
+```
+
+## Ciclo de vida
+
+| Método | Descrição |
+|--------|-----------|
+| `mark_running()` | Notifica backend que a execução começou |
+| `add_success_item()` | Incrementa contador de itens processados |
+| `add_failed_item()` | Incrementa contador de itens que falharam |
+| `report_progress(processed, total)` | Reporta progresso parcial |
+| `finish_success()` | Finaliza como bem-sucedida |
+| `finish_failed(error_message)` | Finaliza como falha |
+| `run(fn)` | Wrapper automático completo |
+
+## Parâmetros
+
+Os parâmetros são injetados pelo runner via variável de ambiente `ONEROM_PARAMETERS`.
+
+```python
+exec = OneromExecution()
+
+# Acesso por atributo
+valor = exec.params.meu_parametro
+
+# Acesso como dict (sem schema)
+dados = exec.params.as_dict()
+```
+
+### Schema tipado (opcional)
+
+Se `ONEROM_PARAM_SCHEMA` estiver definido, os parâmetros são validados com Pydantic:
+
+```python
+# Backend retorna schema:
+# [{"name": "cnpj", "type": "string", "required": true}]
+# Validação automática e acesso tipado:
+cnpj: str = exec.params.cnpj
+```
+
+Tipos suportados: `string`, `int`, `double`, `bool`, `json`, `list`
+
+## Logging
+
+O `OneromLogHandler` é anexado automaticamente ao logger raiz. Cada chamada de log
+gera uma linha JSON no stdout, que o runner captura e envia ao backend.
+
+```python
+import logging
+
+logging.info("Processando item")    # → backend via runner
+logging.warning("Item ignorado")
+logging.error("Falha ao processar")
+
+# Logger customizado
+exec.attach_logger(logging.getLogger("meu_modulo"))
+```
+
+## Variáveis de ambiente
+
+Injetadas automaticamente pelo runner:
+
+| Variável | Descrição |
+|----------|-----------|
+| `ONEROM_EXECUTION_ID` | ID da execução atual |
+| `ONEROM_BOT_NAME` | Nome do bot |
+| `ONEROM_RUNNER_ID` | ID do runner |
+| `ONEROM_PARAMETERS` | JSON com parâmetros da execução |
+| `ONEROM_CONTEXT` | JSON com contexto completo |
+| `ONEROM_METRICS_FILE` | Caminho do arquivo de métricas |
+| `ONEROM_API_URL` | URL base da API runner-agent |
+| `ONEROM_RUNNER_KEY` | Chave de autenticação do runner |

onerom_core-0.1.0/README.md

@@ -0,0 +1,133 @@
+# onerom-core
+
+SDK oficial Python para automações ONEROM.
+
+Usado dentro de bots executados pelo ONEROM Runner.
+
+## Instalação
+
+```bash
+pip install onerom-core
+```
+
+Ou via `pyproject.toml` do bot:
+
+```toml
+[project]
+dependencies = ["onerom-core>=0.1.0"]
+```
+
+## Uso básico
+
+```python
+from onerom_core import OneromExecution
+import logging
+
+# Inicializa contexto da execução
+# - Carrega parâmetros da execução automaticamente
+# - Anexa handler de log estruturado ao logger raiz
+exec = OneromExecution()
+
+# Acesso a parâmetros tipados
+nome = exec.params.nome
+count = exec.params.count
+
+# Logging — capturado pelo runner e enviado ao backend
+logging.info(f"Processando {nome}")
+
+# Contagem de itens
+for item in get_items():
+    try:
+        process(item)
+        exec.add_success_item()
+    except Exception:
+        exec.add_failed_item()
+
+# Finaliza com sucesso
+exec.finish_success()
+```
+
+## Uso com wrapper automático
+
+```python
+from onerom_core import OneromExecution
+
+exec = OneromExecution()
+
+def main():
+    logging.info("Bot iniciado")
+    # ... lógica do bot ...
+
+# Gerencia mark_running → main() → finish_success/failed automaticamente
+exec.run(main)
+```
+
+## Ciclo de vida
+
+| Método | Descrição |
+|--------|-----------|
+| `mark_running()` | Notifica backend que a execução começou |
+| `add_success_item()` | Incrementa contador de itens processados |
+| `add_failed_item()` | Incrementa contador de itens que falharam |
+| `report_progress(processed, total)` | Reporta progresso parcial |
+| `finish_success()` | Finaliza como bem-sucedida |
+| `finish_failed(error_message)` | Finaliza como falha |
+| `run(fn)` | Wrapper automático completo |
+
+## Parâmetros
+
+Os parâmetros são injetados pelo runner via variável de ambiente `ONEROM_PARAMETERS`.
+
+```python
+exec = OneromExecution()
+
+# Acesso por atributo
+valor = exec.params.meu_parametro
+
+# Acesso como dict (sem schema)
+dados = exec.params.as_dict()
+```
+
+### Schema tipado (opcional)
+
+Se `ONEROM_PARAM_SCHEMA` estiver definido, os parâmetros são validados com Pydantic:
+
+```python
+# Backend retorna schema:
+# [{"name": "cnpj", "type": "string", "required": true}]
+# Validação automática e acesso tipado:
+cnpj: str = exec.params.cnpj
+```
+
+Tipos suportados: `string`, `int`, `double`, `bool`, `json`, `list`
+
+## Logging
+
+O `OneromLogHandler` é anexado automaticamente ao logger raiz. Cada chamada de log
+gera uma linha JSON no stdout, que o runner captura e envia ao backend.
+
+```python
+import logging
+
+logging.info("Processando item")    # → backend via runner
+logging.warning("Item ignorado")
+logging.error("Falha ao processar")
+
+# Logger customizado
+exec.attach_logger(logging.getLogger("meu_modulo"))
+```
+
+## Variáveis de ambiente
+
+Injetadas automaticamente pelo runner:
+
+| Variável | Descrição |
+|----------|-----------|
+| `ONEROM_EXECUTION_ID` | ID da execução atual |
+| `ONEROM_BOT_NAME` | Nome do bot |
+| `ONEROM_RUNNER_ID` | ID do runner |
+| `ONEROM_PARAMETERS` | JSON com parâmetros da execução |
+| `ONEROM_CONTEXT` | JSON com contexto completo |
+| `ONEROM_METRICS_FILE` | Caminho do arquivo de métricas |
+| `ONEROM_API_URL` | URL base da API runner-agent |
+| `ONEROM_RUNNER_KEY` | Chave de autenticação do runner |

onerom_core-0.1.0/onerom_core/__init__.py

@@ -0,0 +1,15 @@
+"""
+onerom-core — SDK oficial para bots ONEROM.
+
+Uso:
+    from onerom_core import OneromExecution
+
+    exec = OneromExecution()
+    print(exec.params.meu_parametro)
+    exec.run(lambda: minha_funcao())
+"""
+from .execution import OneromExecution
+from .logging_handler import OneromLogHandler
+
+__all__ = ["OneromExecution", "OneromLogHandler"]
+__version__ = "0.1.0"

onerom_core-0.1.0/onerom_core/client.py

@@ -0,0 +1,79 @@
+"""
+Cliente HTTP interno do SDK ONEROM.
+
+Encapsula todas as chamadas ao runner-agent API.
+Autenticacao via X-Runner-Key (injetado pelo runner como ONEROM_RUNNER_KEY).
+
+Se ONEROM_API_URL ou ONEROM_RUNNER_KEY nao estiverem disponiveis,
+o cliente opera em modo passivo (sem chamadas HTTP) — o runner
+ja gerencia o ciclo de vida da execucao via metrics file e stdout.
+"""
+import logging
+import os
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+class OneromClient:
+    """
+    Cliente HTTP para a API runner-agent do ONEROM.
+
+    Todas as chamadas falham silenciosamente — nunca propagam excecoes.
+    O runner e responsavel pelo status final via metrics file.
+    """
+
+    def __init__(self) -> None:
+        self.api_url = os.environ.get("ONEROM_API_URL", "").rstrip("/")
+        self.runner_key = os.environ.get("ONEROM_RUNNER_KEY", "")
+        self.available = bool(self.api_url and self.runner_key)
+
+        raw_id = os.environ.get("ONEROM_EXECUTION_ID")
+        if raw_id is None:
+            raise RuntimeError(
+                "ONEROM_EXECUTION_ID nao definido. "
+                "Este SDK deve ser executado dentro do ONEROM Runner."
+            )
+        self.execution_id = int(raw_id)
+
+        if not self.available:
+            logger.debug(
+                "ONEROM_API_URL ou ONEROM_RUNNER_KEY ausentes — "
+                "cliente HTTP desabilitado (modo passivo)"
+            )
+
+    def put_execution(self, status: str, **kwargs: Any) -> None:
+        """
+        Atualiza status da execucao no backend.
+
+        Args:
+            status: RUNNING | SUCCESS | FAILED | TIMEOUT
+            **kwargs: Campos opcionais (items_processed, items_failed,
+                      error_message, error_traceback, log_output, started_at)
+        """
+        if not self.available:
+            return
+
+        try:
+            import requests
+
+            payload: dict[str, Any] = {"status": status}
+            for key, value in kwargs.items():
+                if value is not None:
+                    payload[key] = value
+
+            resp = requests.put(
+                f"{self.api_url}/api/v1/runner-agent/executions/{self.execution_id}",
+                json=payload,
+                headers={"X-Runner-Key": self.runner_key},
+                timeout=10,
+            )
+
+            if resp.status_code not in (200, 204):
+                logger.debug(
+                    f"put_execution retornou {resp.status_code}: {resp.text[:200]}"
+                )
+
+        except Exception as exc:
+            # Nunca propaga — o runner cobre o status via metrics file
+            logger.debug(f"put_execution falhou silenciosamente: {exc}")

onerom_core-0.1.0/onerom_core/execution.py

@@ -0,0 +1,232 @@
+"""
+OneromExecution — ponto de entrada principal do SDK ONEROM.
+
+Uso basico:
+    from onerom_core import OneromExecution
+    import logging
+
+    exec = OneromExecution()
+    logging.info("Iniciando bot")   # capturado pelo runner via stdout JSON
+
+    nome = exec.params.nome         # parametro tipado da execucao
+
+    exec.add_success_item()
+    exec.finish_success()
+
+Uso com wrapper automatico:
+    exec.run(lambda: my_main_function())
+
+Uso com logger customizado:
+    exec.attach_logger(logging.getLogger("meu_modulo"))
+"""
+import json
+import logging
+import os
+import traceback as tb
+from pathlib import Path
+from typing import Any, Callable, Optional
+
+from .client import OneromClient
+from .logging_handler import OneromLogHandler
+from .params import build_params
+
+logger = logging.getLogger(__name__)
+
+
+class OneromExecution:
+    """
+    Contexto de execucao ONEROM.
+
+    Gerencia:
+    - Parametros tipados e validados
+    - Logging estruturado via stdout (capturado pelo runner)
+    - Metricas de itens processados via arquivo (lido pelo runner)
+    - Ciclo de vida da execucao via HTTP (quando disponivel)
+
+    Design:
+    - Nunca lanca excecao em metodos de ciclo de vida (mark_running, finish_*)
+    - Erros de parametro sao imediatos e claros
+    - Compativel com Python 3.9+
+    """
+
+    def __init__(self) -> None:
+        """
+        Inicializa o contexto de execucao.
+
+        Raises:
+            RuntimeError: Se ONEROM_EXECUTION_ID nao estiver definido.
+            ValueError: Se parametros obrigatorios estiverem ausentes ou invalidos.
+        """
+        # Valida ambiente ONEROM antes de qualquer coisa
+        if "ONEROM_EXECUTION_ID" not in os.environ:
+            raise RuntimeError(
+                "ONEROM_EXECUTION_ID nao definido.\n"
+                "Este SDK deve ser executado dentro do ONEROM Runner.\n"
+                "Variaveis necessarias: ONEROM_EXECUTION_ID, ONEROM_BOT_NAME, "
+                "ONEROM_RUNNER_ID, ONEROM_PARAMETERS"
+            )
+
+        # Cliente HTTP (modo passivo se API_URL/RUNNER_KEY ausentes)
+        self._client = OneromClient()
+
+        # Arquivo de metricas (runner le apos fim da execucao)
+        metrics_path = os.environ.get("ONEROM_METRICS_FILE", "")
+        self._metrics_file: Optional[Path] = Path(metrics_path) if metrics_path else None
+
+        # Contadores locais de itens
+        self._items_processed: int = 0
+        self._items_failed: int = 0
+
+        # Parametros da execucao (validados em tempo de instanciacao)
+        self._params: Any = build_params()
+
+        # Anexa handler de log estruturado ao logger raiz automaticamente
+        root_logger = logging.getLogger()
+        # Evita duplicar o handler se OneromExecution for instanciado mais de uma vez
+        if not any(isinstance(h, OneromLogHandler) for h in root_logger.handlers):
+            root_logger.addHandler(OneromLogHandler())
+
+        logger.debug(
+            f"OneromExecution inicializado "
+            f"(execution_id={self._client.execution_id}, "
+            f"http_available={self._client.available})"
+        )
+
+    # ── Parametros ──────────────────────────────────────────────────────────
+
+    @property
+    def params(self) -> Any:
+        """
+        Parametros da execucao como objeto com acesso por atributo.
+
+        Se ONEROM_PARAM_SCHEMA estiver definido: Pydantic model validado.
+        Caso contrario: SimpleNamespace com valores brutos.
+
+        Exemplo:
+            nome = exec.params.nome
+            count = exec.params.count
+        """
+        return self._params
+
+    # ── Logging ─────────────────────────────────────────────────────────────
+
+    def attach_logger(self, log: logging.Logger) -> None:
+        """
+        Anexa o handler ONEROM a um logger especifico.
+
+        O logger raiz ja recebe o handler automaticamente no __init__.
+        Use este metodo para loggers de modulos especificos.
+
+        Args:
+            log: Logger ao qual o handler sera adicionado.
+        """
+        if not any(isinstance(h, OneromLogHandler) for h in log.handlers):
+            log.addHandler(OneromLogHandler())
+
+    # ── Ciclo de vida ────────────────────────────────────────────────────────
+
+    def mark_running(self) -> None:
+        """
+        Notifica o backend que a execucao iniciou.
+        O runner ja reporta RUNNING antes de spawnar o subprocess —
+        use este metodo para reconfirmar ou apos delay no startup.
+        """
+        self._client.put_execution("RUNNING")
+
+    def report_progress(self, processed: int, total: int) -> None:
+        """
+        Reporta progresso parcial da execucao.
+
+        Atualiza o arquivo de metricas (lido pelo runner ao fim).
+        Nao faz chamada HTTP — o runner le as metricas ao encerrar.
+
+        Args:
+            processed: Numero de itens processados ate agora.
+            total: Total de itens esperados (para calculo de %).
+        """
+        self._items_processed = processed
+        self._write_metrics()
+
+    def add_success_item(self) -> None:
+        """Incrementa contador de itens processados com sucesso."""
+        self._items_processed += 1
+
+    def add_failed_item(self) -> None:
+        """Incrementa contador de itens que falharam."""
+        self._items_failed += 1
+
+    def finish_success(self) -> None:
+        """
+        Finaliza a execucao como bem-sucedida.
+
+        1. Persiste metricas no arquivo (runner le ao encerrar)
+        2. Envia status SUCCESS via HTTP (se disponivel)
+        """
+        self._write_metrics()
+        self._client.put_execution(
+            "SUCCESS",
+            items_processed=self._items_processed,
+            items_failed=self._items_failed,
+        )
+
+    def finish_failed(self, error_message: str) -> None:
+        """
+        Finaliza a execucao como falha.
+
+        1. Persiste metricas no arquivo
+        2. Envia status FAILED com mensagem e traceback via HTTP (se disponivel)
+
+        Args:
+            error_message: Descricao do erro que causou a falha.
+        """
+        self._write_metrics()
+        self._client.put_execution(
+            "FAILED",
+            error_message=error_message,
+            error_traceback=tb.format_exc(),
+            items_processed=self._items_processed,
+            items_failed=self._items_failed,
+        )
+
+    # ── Wrapper automatico ───────────────────────────────────────────────────
+
+    def run(self, fn: Callable[[], None]) -> None:
+        """
+        Executa fn() gerenciando o ciclo de vida automaticamente.
+
+        Sequencia:
+            mark_running() → fn() → finish_success()
+        Em caso de excecao:
+            finish_failed(str(e)) → re-raise
+
+        Args:
+            fn: Funcao principal do bot (sem argumentos).
+
+        Raises:
+            Exception: Propaga qualquer excecao lancada por fn().
+        """
+        try:
+            self.mark_running()
+            fn()
+            self.finish_success()
+        except Exception as exc:
+            self.finish_failed(str(exc))
+            raise
+
+    # ── Internos ─────────────────────────────────────────────────────────────
+
+    def _write_metrics(self) -> None:
+        """Escreve metricas no arquivo lido pelo runner apos o subprocess encerrar."""
+        if not self._metrics_file:
+            return
+        try:
+            self._metrics_file.parent.mkdir(parents=True, exist_ok=True)
+            self._metrics_file.write_text(
+                json.dumps({
+                    "items_processed": self._items_processed,
+                    "items_failed": self._items_failed,
+                }),
+                encoding="utf-8",
+            )
+        except Exception as exc:
+            logger.debug(f"Falha ao escrever metrics file: {exc}")

onerom_core-0.1.0/onerom_core/logging_handler.py

@@ -0,0 +1,54 @@
+"""
+OneromLogHandler — envia logs estruturados via stdout.
+
+O runner captura stdout linha a linha e envia ao backend.
+Este handler nunca faz chamadas HTTP diretamente — apenas escreve JSON no stdout.
+
+Formato esperado pelo runner:
+{
+    "ts": ISO8601,
+    "execution_id": int,
+    "runner_id": int,
+    "bot": str,
+    "source": "bot",
+    "level": str,
+    "message": str,
+    "extra": {...}
+}
+"""
+import json
+import logging
+import os
+import sys
+from datetime import datetime, timezone
+
+
+class OneromLogHandler(logging.Handler):
+    """
+    Handler que escreve logs estruturados como JSON no stdout.
+
+    O runner ONEROM captura cada linha do stdout e, se for JSON valido
+    com os campos obrigatorios, reenvia ao backend como log estruturado.
+
+    Nunca lanca excecoes — falha silenciosa para nao impactar o bot.
+    """
+
+    def emit(self, record: logging.LogRecord) -> None:
+        try:
+            entry = {
+                "ts": datetime.now(timezone.utc).isoformat(),
+                "execution_id": int(os.environ.get("ONEROM_EXECUTION_ID", 0)),
+                "runner_id": int(os.environ.get("ONEROM_RUNNER_ID", 0) or 0),
+                "bot": os.environ.get("ONEROM_BOT_NAME", ""),
+                "source": "bot",
+                "level": record.levelname,
+                "message": self.format(record),
+                "extra": {
+                    "logger": record.name,
+                    "module": record.module,
+                    "line": record.lineno,
+                },
+            }
+            print(json.dumps(entry, ensure_ascii=False), flush=True)
+        except Exception:
+            pass  # nunca propaga excecao do handler

onerom_core-0.1.0/onerom_core/params.py

@@ -0,0 +1,208 @@
+"""
+Geracao dinamica de modelo de parametros em runtime.
+
+Fontes de dados (prioridade):
+1. Env var ONEROM_PARAMETERS (JSON dict injetado pelo runner)
+2. Env var ONEROM_CONTEXT -> parameters (fallback)
+3. Dict vazio
+
+Validacao com schema (opcional, via ONEROM_PARAM_SCHEMA):
+- Se presente: usa pydantic create_model para validacao tipada
+- Se ausente: expoe como SimpleNamespace (acesso por atributo)
+
+Tipos suportados (valores do backend ParameterType enum):
+  string -> str
+  int    -> int
+  double -> float
+  bool   -> bool
+
+Aliases adicionais (compatibilidade com o prompt):
+  integer -> int
+  float   -> float
+  json    -> dict
+  list    -> list
+"""
+import json
+import logging
+import os
+import types
+import warnings
+from typing import Any, Optional
+
+logger = logging.getLogger(__name__)
+
+TYPE_MAP: dict[str, type] = {
+    "string": str,
+    "int": int,
+    "double": float,
+    "bool": bool,
+    # aliases
+    "integer": int,
+    "float": float,
+    "json": dict,
+    "list": list,
+}
+
+
+def _load_raw_parameters() -> dict:
+    """Carrega parametros brutos das env vars injetadas pelo runner."""
+    # Fonte 1: ONEROM_PARAMETERS (JSON string direto)
+    raw = os.environ.get("ONEROM_PARAMETERS", "")
+    if raw:
+        try:
+            data = json.loads(raw)
+            if isinstance(data, dict):
+                return data
+        except (json.JSONDecodeError, TypeError):
+            logger.warning("ONEROM_PARAMETERS nao e JSON valido, ignorando")
+
+    # Fonte 2: ONEROM_CONTEXT -> parameters
+    ctx_raw = os.environ.get("ONEROM_CONTEXT", "")
+    if ctx_raw:
+        try:
+            ctx = json.loads(ctx_raw)
+            params = ctx.get("parameters")
+            if isinstance(params, dict):
+                return params
+        except (json.JSONDecodeError, TypeError):
+            logger.warning("ONEROM_CONTEXT nao e JSON valido, ignorando")
+
+    return {}
+
+
+def _load_schema() -> list[dict] | None:
+    """Carrega schema de parametros de ONEROM_PARAM_SCHEMA (opcional)."""
+    raw = os.environ.get("ONEROM_PARAM_SCHEMA", "")
+    if not raw:
+        return None
+    try:
+        schema = json.loads(raw)
+        if isinstance(schema, list):
+            return schema
+    except (json.JSONDecodeError, TypeError):
+        logger.warning("ONEROM_PARAM_SCHEMA nao e JSON valido, ignorando schema")
+    return None
+
+
+def _coerce_value(value: Any, python_type: type) -> Any:
+    """Converte value para python_type se possivel."""
+    if value is None:
+        return None
+    if isinstance(value, python_type):
+        return value
+    # Conversoes especiais
+    if python_type is bool:
+        if isinstance(value, str):
+            return value.lower() in ("true", "1", "yes")
+        return bool(value)
+    if python_type in (int, float):
+        return python_type(value)
+    if python_type is str:
+        return str(value)
+    # Para dict e list: tenta JSON parse se vier como string
+    if python_type in (dict, list) and isinstance(value, str):
+        try:
+            parsed = json.loads(value)
+            if isinstance(parsed, python_type):
+                return parsed
+        except (json.JSONDecodeError, TypeError):
+            pass
+    return value
+
+
+def build_params() -> Any:
+    """
+    Constroi objeto de parametros validado.
+
+    Com schema (ONEROM_PARAM_SCHEMA presente):
+        Retorna instancia de Pydantic model dinamico com campos tipados.
+        Levanta ValidationError se validacao falhar.
+
+    Sem schema:
+        Retorna SimpleNamespace com valores brutos (acesso por atributo).
+        Tambem expoe .as_dict() para acesso como dict.
+    """
+    raw_params = _load_raw_parameters()
+    schema = _load_schema()
+
+    if schema:
+        return _build_with_schema(raw_params, schema)
+    else:
+        return _build_simple(raw_params)
+
+
+def _build_with_schema(raw_params: dict, schema: list[dict]) -> Any:
+    """Gera Pydantic model dinamico a partir do schema."""
+    try:
+        from pydantic import create_model
+        from pydantic import ValidationError
+    except ImportError:
+        warnings.warn(
+            "pydantic nao instalado — parametros sem validacao de schema",
+            RuntimeWarning,
+            stacklevel=3,
+        )
+        return _build_simple(raw_params)
+
+    fields: dict[str, Any] = {}
+    coerced_values: dict[str, Any] = {}
+
+    for item in schema:
+        name = item.get("name")
+        type_str = item.get("type", "string")
+        required = item.get("required", False)
+        default_value = item.get("default_value")  # string or None
+
+        if not name:
+            continue
+
+        # Resolve tipo Python
+        if type_str not in TYPE_MAP:
+            logger.warning(
+                f"Tipo desconhecido '{type_str}' para parametro '{name}', usando dict"
+            )
+            python_type = dict
+        else:
+            python_type = TYPE_MAP[type_str]
+
+        # Prepara valor
+        raw_val = raw_params.get(name)
+        if raw_val is None and default_value is not None:
+            raw_val = default_value
+
+        coerced = _coerce_value(raw_val, python_type) if raw_val is not None else None
+        coerced_values[name] = coerced
+
+        # Define campo Pydantic
+        if required:
+            fields[name] = (python_type, ...)
+        else:
+            fields[name] = (Optional[python_type], None)
+
+    # Campos extras em raw_params que nao estao no schema
+    for key, val in raw_params.items():
+        if key not in fields:
+            fields[key] = (Any, None)
+            coerced_values[key] = val
+
+    if not fields:
+        return _build_simple(raw_params)
+
+    try:
+        DynamicParams = create_model("ExecutionParams", **fields)
+        # Filtra None para campos obrigatorios que tem valor
+        return DynamicParams(**{k: v for k, v in coerced_values.items() if v is not None or k in coerced_values})
+    except Exception as e:
+        # Levanta erro claro — nunca silencia erros de validacao
+        raise ValueError(
+            f"Falha ao validar parametros da execucao: {e}\n"
+            f"Parametros recebidos: {raw_params}"
+        ) from e
+
+
+def _build_simple(raw_params: dict) -> Any:
+    """Retorna SimpleNamespace para acesso por atributo sem validacao de schema."""
+    ns = types.SimpleNamespace(**raw_params)
+    # Adiciona acesso como dict
+    ns.as_dict = lambda: dict(raw_params)
+    return ns

onerom_core-0.1.0/pyproject.toml

@@ -0,0 +1,36 @@
+[project]
+name = "onerom-core"
+version = "0.1.0"
+description = "SDK oficial para automacoes ONEROM"
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+keywords = ["onerom", "rpa", "automation", "sdk"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Libraries",
+]
+dependencies = [
+    "requests>=2.28",
+    "pydantic>=2.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "pytest-cov",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["onerom_core"]