rpa-bot-sdk-core 1.0.0__tar.gz

rpa_bot_sdk_core-1.0.0/PKG-INFO

@@ -0,0 +1,31 @@
+Metadata-Version: 2.4
+Name: rpa-bot-sdk-core
+Version: 1.0.0
+Summary: Orchestrator bot-side core: server client, pause/stop, logging, config loading. Shared by rpa-bot-sdk-performer and rpa-bot-sdk-dispatcher.
+Author: Kasun Perera
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: pandas
+Requires-Dist: openpyxl
+Provides-Extra: sqlcipher
+Requires-Dist: sqlcipher3-binary; extra == "sqlcipher"
+Requires-Dist: keyring; extra == "sqlcipher"
+Provides-Extra: screenshot
+Requires-Dist: pyautogui; extra == "screenshot"
+
+# rpa-bot-sdk-core
+
+The Orchestrator bot-side code shared by every role: `DbClient` (server auth,
+queue, assets, storage, human-in-the-loop over HTTP, or a local SQLite queue
+in StandaloneMode), `PauseController`/`checkpoint`, structured logging,
+`init_all_settings()` (Config.xlsx loader), `take_screenshot()`, and the
+`safe_*` UI-action wrappers.
+
+Neither a Performer nor a Dispatcher project installs this directly — it's
+the shared dependency of [`rpa-bot-sdk-performer`](../performer/README.md)
+and [`rpa-bot-sdk-dispatcher`](../dispatcher/README.md), pulled in
+automatically by whichever of those two a project actually needs.
+
+Bump this package's version specifically when the server contract itself
+changes (a `db_client.py` field/action). A change confined to one role's own
+orchestration (e.g. `QueueManager`) belongs in that role's package instead.

rpa_bot_sdk_core-1.0.0/README.md

@@ -0,0 +1,16 @@
+# rpa-bot-sdk-core
+
+The Orchestrator bot-side code shared by every role: `DbClient` (server auth,
+queue, assets, storage, human-in-the-loop over HTTP, or a local SQLite queue
+in StandaloneMode), `PauseController`/`checkpoint`, structured logging,
+`init_all_settings()` (Config.xlsx loader), `take_screenshot()`, and the
+`safe_*` UI-action wrappers.
+
+Neither a Performer nor a Dispatcher project installs this directly — it's
+the shared dependency of [`rpa-bot-sdk-performer`](../performer/README.md)
+and [`rpa-bot-sdk-dispatcher`](../dispatcher/README.md), pulled in
+automatically by whichever of those two a project actually needs.
+
+Bump this package's version specifically when the server contract itself
+changes (a `db_client.py` field/action). A change confined to one role's own
+orchestration (e.g. `QueueManager`) belongs in that role's package instead.

rpa_bot_sdk_core-1.0.0/pyproject.toml

@@ -0,0 +1,22 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "rpa-bot-sdk-core"
+version = "1.0.0"
+description = "Orchestrator bot-side core: server client, pause/stop, logging, config loading. Shared by rpa-bot-sdk-performer and rpa-bot-sdk-dispatcher."
+readme = "README.md"
+requires-python = ">=3.9"
+authors = [{ name = "Kasun Perera" }]
+dependencies = [
+    "pandas",     # init_all_settings() reads Config.xlsx at import time
+    "openpyxl",   # pandas' xlsx engine
+]
+
+[project.optional-dependencies]
+sqlcipher = ["sqlcipher3-binary", "keyring"]   # StandaloneMode + SQLiteDatabaseType=SQLCipher only
+screenshot = ["pyautogui"]                      # take_screenshot() only
+
+[tool.setuptools.packages.find]
+where = ["src"]

rpa_bot_sdk_core-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

rpa_bot_sdk_core-1.0.0/src/rpa_bot_sdk_core/__init__.py

@@ -0,0 +1,32 @@
+"""rpa_bot_sdk_core — the part of the Orchestrator's bot-side protocol layer
+that BOTH a Performer and a Dispatcher project need: the server client, the
+pause/stop controller, logging, Config.xlsx loading, and safe UI-action
+wrappers. Nothing here knows which role is using it.
+
+Split out from rpa_bot_sdk-performer / rpa_bot_sdk-dispatcher on purpose: a
+Dispatcher machine installing rpa-bot-sdk-dispatcher pulls this in as its one
+shared dependency, but never pulls in Performer-only code (queue_manager,
+transaction states, ...), and vice versa. Bump this package's version when
+the server contract itself changes (db_client.py); bump the role packages
+when only their own orchestration changes.
+"""
+
+__version__ = "1.0.0"
+
+from .db_client import DbClient, standalone_enabled, standalone_queue_args
+from .pause_controller import PauseController, checkpoint, get_pause_controller
+from .structured_logger import setup_logging, attach_proxy_handler
+from .init_all_settings import init_all_settings
+from .utils import take_screenshot
+from .safe_actions import (
+    safe_sleep, safe_click, safe_type_text, safe_fill_text, safe_call, safe_iter,
+)
+
+__all__ = [
+    "__version__",
+    "DbClient", "standalone_enabled", "standalone_queue_args",
+    "PauseController", "checkpoint", "get_pause_controller",
+    "setup_logging", "attach_proxy_handler",
+    "init_all_settings", "take_screenshot",
+    "safe_sleep", "safe_click", "safe_type_text", "safe_fill_text", "safe_call", "safe_iter",
+]

rpa_bot_sdk_core-1.0.0/src/rpa_bot_sdk_core/db_client.py

@@ -0,0 +1,709 @@
+import json
+import logging
+import getpass
+from contextlib import contextmanager
+import socket as _hostsock
+import uuid
+import urllib.request
+import urllib.error
+
+
+def _machine_identity():
+    # hostname\\username — uniquely identifies this bot's Windows profile,
+    # computed automatically (no environment variable needed).
+    try:
+        return _hostsock.gethostname() + chr(92) + getpass.getuser()
+    except Exception:
+        try:
+            return _hostsock.gethostname()
+        except Exception:
+            return "Unknown"
+
+logger = logging.getLogger("DbClient")
+
+
+class _LocalQueue:
+    """A local stand-in for the Orchestrator queue, used only in StandaloneMode.
+
+    The SQLite templates keep BUSINESS data in a local SQLite file but the QUEUE
+    itself still lives in the Orchestrator. With no server there is therefore
+    nothing to dispatch into and nothing to pick up, so standalone needs a real
+    local queue or the Performer would drain zero items and exit reporting success.
+
+    This class implements the same verbs the proxy does, against a
+    '_standalone_queue' table inside the project's own SQLite database, and mirrors
+    the server's semantics deliberately:
+        * duplicate unique_id per (process, queue) is rejected
+        * items are picked oldest-New-first and claimed as InProgress
+        * InProgress items older than an hour revert to New (crash recovery)
+    Keeping it in the SAME database file means a SQLCipher project encrypts the
+    queue with the same key as its business data, and the client is handed one file.
+    """
+
+    _DDL = (
+        "CREATE TABLE IF NOT EXISTS _standalone_queue ("
+        " id INTEGER PRIMARY KEY AUTOINCREMENT,"
+        " unique_id TEXT, reference TEXT, json_data TEXT, json_data_secure TEXT,"
+        " status TEXT NOT NULL DEFAULT 'New', retry_count INTEGER NOT NULL DEFAULT 0,"
+        " exception_type TEXT, exception TEXT,"
+        " process_name TEXT, queue_name TEXT, client_name TEXT, user_name TEXT,"
+        " bot_id TEXT, machine_name TEXT,"
+        " created_at TEXT, start_time TEXT, end_time TEXT)",
+        "CREATE INDEX IF NOT EXISTS _sq_pick "
+        "ON _standalone_queue (status, process_name, queue_name, created_at)",
+        "CREATE UNIQUE INDEX IF NOT EXISTS _sq_unique "
+        "ON _standalone_queue (process_name, queue_name, unique_id)",
+    )
+    # Columns added after the first release. Applied with ALTER TABLE so a queue file
+    # created by an earlier bot keeps working instead of failing on an unknown column.
+    _MIGRATIONS = ("ALTER TABLE _standalone_queue ADD COLUMN json_data_secure TEXT",)
+
+    def __init__(self, db_path, password=None):
+        if not db_path:
+            raise RuntimeError(
+                "StandaloneMode needs a local queue database. Set "
+                "'SQLiteDatabasePath' in Config.xlsx.")
+        self._db_path  = db_path
+        self._password = password or ""
+        import os as _os
+        _d = _os.path.dirname(_os.path.abspath(db_path))
+        if _d and not _os.path.isdir(_d):
+            _os.makedirs(_d, exist_ok=True)
+        with self._conn() as conn:
+            for stmt in self._DDL:
+                conn.execute(stmt)
+            for stmt in self._MIGRATIONS:
+                try:
+                    conn.execute(stmt)
+                except Exception:
+                    pass          # already present
+        logger.info(f"Standalone queue ready: {db_path} (table _standalone_queue)")
+
+    @contextmanager
+    def _conn(self):
+        """One connection per operation, always closed.
+
+        Note `with sqlite3.connect(...)` commits but does NOT close, so a plain
+        `with` here would leak a handle for every queue operation in the run.
+        """
+        if self._password:
+            from sqlcipher3 import dbapi2 as _sq
+        else:
+            import sqlite3 as _sq
+        # isolation_level=None -> autocommit; the pick path opens its own
+        # BEGIN IMMEDIATE explicitly.
+        conn = _sq.connect(self._db_path, timeout=30, isolation_level=None)
+        try:
+            conn.row_factory = _sq.Row
+            if self._password:
+                # Doubling the quote is the only escape SQLite string literals have;
+                # PRAGMA key cannot be parameterised.
+                conn.execute("PRAGMA key='" + self._password.replace("'", "''") + "'")
+            yield conn
+        finally:
+            conn.close()
+
+    @staticmethod
+    def _now():
+        from datetime import datetime as _dt, timezone as _tz
+        return _dt.now(_tz.utc).strftime("%Y-%m-%d %H:%M:%S")
+
+    def handle(self, action, payload):
+        fn = getattr(self, "_do_" + action, None)
+        if fn is None:
+            return {"status": "ok", "standalone": True}
+        try:
+            return fn(payload or {})
+        except Exception as e:
+            logger.error(f"Standalone queue error on {action}: {e}")
+            return {"status": "error", "message": str(e)}
+
+    def _do_add_queue_item(self, p):
+        import json as _json
+        raw = p.get("json_data", p.get("excel_file_path", ""))
+        if isinstance(raw, dict):
+            jd = raw
+        elif isinstance(raw, str) and raw.strip().startswith("{"):
+            try:
+                jd = _json.loads(raw)
+            except Exception:
+                jd = {"Excel File Path": raw}
+        else:
+            jd = {"Excel File Path": raw}
+        proc  = p.get("process_name", "")
+        qname = (str(p.get("queue_name") or "").strip() or "Main")
+        uid   = p.get("unique_id")
+        with self._conn() as conn:
+            if uid:
+                cur = conn.execute(
+                    "SELECT id FROM _standalone_queue "
+                    "WHERE process_name=? AND queue_name=? AND unique_id=?",
+                    (proc, qname, uid))
+                if cur.fetchone():
+                    msg = (f"Duplicate unique_id '{uid}' in queue '{qname}' "
+                           f"for process '{proc}'.")
+                    logger.warning(f"Standalone queue insert rejected: {msg}")
+                    return {"status": "error", "message": msg}
+            # json_data_secure is the Fernet ciphertext a Secure Cloud bot produced
+            # with its phi.key. Store it verbatim and never look inside — dropping it
+            # here would silently lose every encrypted field on the way back out.
+            secure_blob = p.get("json_data_secure")
+            if secure_blob is not None and not isinstance(secure_blob, str):
+                secure_blob = _json.dumps(secure_blob)
+            conn.execute(
+                "INSERT INTO _standalone_queue (unique_id, reference, json_data,"
+                " json_data_secure, status,"
+                " retry_count, exception_type, exception, process_name, queue_name,"
+                " client_name, user_name, bot_id, machine_name, created_at)"
+                " VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)",
+                (uid, p.get("reference"), _json.dumps(jd), secure_blob,
+                 p.get("status", "New"),
+                 int(p.get("retry_count") or 0), p.get("exception_type"),
+                 p.get("exception"), proc, qname, p.get("client_name", ""),
+                 p.get("user_name", ""), str(p.get("bot_id") or ""),
+                 p.get("machine_name", ""), self._now()))
+        return {"status": "ok"}
+
+    def _do_get_next_transaction(self, p):
+        proc   = p.get("process_name", "")
+        qname  = (str(p.get("queue_name") or "").strip() or "Main")
+        ref    = (p.get("reference_filter") or "").strip()
+        with self._conn() as conn:
+            # Same crash-recovery rule the server applies: a run that died mid-item
+            # would otherwise strand it as InProgress forever.
+            from datetime import datetime as _dt, timezone as _tz, timedelta as _td
+            cutoff = (_dt.now(_tz.utc) - _td(hours=1)).strftime("%Y-%m-%d %H:%M:%S")
+            conn.execute(
+                "UPDATE _standalone_queue SET status='New', start_time=NULL,"
+                " exception=NULL, exception_type=NULL"
+                " WHERE status='InProgress' AND start_time IS NOT NULL AND start_time < ?",
+                (cutoff,))
+            sql = ("SELECT id, unique_id, json_data, json_data_secure, retry_count,"
+                   " reference FROM _standalone_queue WHERE status='New' AND queue_name=?")
+            args = [qname]
+            if proc:
+                sql += " AND process_name=?"; args.append(proc)
+            if ref:
+                sql += " AND reference LIKE ?"; args.append(ref + "%")
+            sql += " ORDER BY created_at ASC, id ASC LIMIT 1"
+            # BEGIN IMMEDIATE takes the write lock up front, so two bots sharing the
+            # file cannot both claim the same row between the SELECT and the UPDATE.
+            conn.execute("BEGIN IMMEDIATE")
+            try:
+                row = conn.execute(sql, args).fetchone()
+                if not row:
+                    conn.execute("COMMIT")
+                    return {"status": "ok", "data": None}
+                conn.execute(
+                    "UPDATE _standalone_queue SET status='InProgress', start_time=?,"
+                    " bot_id=?, machine_name=?, exception=NULL, exception_type=NULL,"
+                    " end_time=NULL WHERE id=?",
+                    (self._now(), str(p.get("bot_id") or ""),
+                     p.get("machine_name", ""), row["id"]))
+                conn.execute("COMMIT")
+            except Exception:
+                conn.execute("ROLLBACK")
+                raise
+        logger.debug(f"Standalone transaction locked -> {row['unique_id']}")
+        return {"status": "ok", "data": dict(row)}
+
+    def _do_update_transaction_status(self, p):
+        sets, args = ["status=?"], [p.get("status")]
+        if "exception_type" in p: sets.append("exception_type=?"); args.append(p.get("exception_type"))
+        if "error" in p:          sets.append("exception=?");      args.append(p.get("error"))
+        if "retry_count" in p:    sets.append("retry_count=?");    args.append(int(p.get("retry_count") or 0))
+        sets.append("end_time=?"); args.append(p.get("end_time") or self._now())
+        args.append(p.get("id"))
+        with self._conn() as conn:
+            conn.execute("UPDATE _standalone_queue SET " + ", ".join(sets) + " WHERE id=?", args)
+        return {"status": "ok"}
+
+    def _do_update_queue_data(self, p):
+        import json as _json
+        jd = p.get("json_data", {})
+        if not isinstance(jd, str):
+            jd = _json.dumps(jd)
+        sets, args = ["json_data=?"], [jd]
+        # Only rewrite the ciphertext when this update actually carries one. A blind
+        # write would blank the encrypted half whenever a bot updates plaintext only.
+        if p.get("json_data_secure") is not None:
+            blob = p["json_data_secure"]
+            sets.append("json_data_secure=?")
+            args.append(blob if isinstance(blob, str) else _json.dumps(blob))
+        args.append(p.get("id"))
+        with self._conn() as conn:
+            conn.execute("UPDATE _standalone_queue SET " + ", ".join(sets) + " WHERE id=?", args)
+        return {"status": "ok"}
+
+    def _do_get_queue_count(self, p):
+        qname = (str(p.get("queue_name") or "").strip() or "Main")
+        proc  = p.get("process_name", "")
+        sql   = "SELECT COUNT(*) FROM _standalone_queue WHERE status='New' AND queue_name=?"
+        args  = [qname]
+        if proc:
+            sql += " AND process_name=?"; args.append(proc)
+        with self._conn() as conn:
+            n = conn.execute(sql, args).fetchone()[0]
+        return {"status": "ok", "count": n}
+
+
+def standalone_enabled(config: dict = None) -> bool:
+    """True when Config.xlsx says StandaloneMode -> run with no Orchestrator at all.
+
+    Config.xlsx is deliberately the ONLY source. An environment variable would be a
+    second, easier way to switch central logging off, and an operator setting one to
+    make connection errors go away would silently leave a PHI bot unaudited. Turning
+    monitoring off has to be a change someone makes to the project's own config.
+    """
+    val = str((config or {}).get("StandaloneMode", "") or "").strip().lower()
+    return val in ("1", "true", "yes", "y", "on")
+
+
+def standalone_queue_args(config: dict = None) -> dict:
+    """DbClient kwargs for the local queue, read from Config.xlsx.
+
+    Path resolution, in order:
+        StandaloneQueuePath  - explicit, wins if set
+        SQLiteDatabasePath   - a SQLite project keeps queue and business data in ONE
+                               file, so SQLCipher encrypts both with the same key and
+                               the client is handed a single file
+        data/StandaloneQueue.sqlite - Excel and Secure Cloud projects, which have no
+                               database of their own
+
+    A SQLCipher project takes the key from Windows Credential Manager exactly as its
+    business tables do, so the queue is encrypted with the same key instead of
+    sitting in the clear beside the data it points at.
+    """
+    cfg  = config or {}
+    path = str(cfg.get("StandaloneQueuePath", "") or "").strip()
+    if not path:
+        path = str(cfg.get("SQLiteDatabasePath", "") or "").strip()
+    if not path:
+        path = "data/StandaloneQueue.sqlite"
+    pw   = None
+    if str(cfg.get("SQLiteDatabaseType", "") or "").strip().lower() == "sqlcipher":
+        cred = str(cfg.get("SQLiteCredentialName", "") or "").strip()
+        if not cred:
+            raise RuntimeError("SQLiteCredentialName is required for SQLCipher mode.")
+        import keyring
+        pw = keyring.get_password("Windows", cred)
+        if not pw:
+            raise RuntimeError("No password found in Windows Credential Manager for "
+                               "SQLiteCredentialName: " + cred)
+    return {"queue_db_path": path, "queue_db_password": pw}
+
+
+class DbClient:
+    def __init__(self, base_url="http://127.0.0.1", api_key=None, standalone=False,
+                 queue_db_path=None, queue_db_password=None):
+        """
+        base_url: The ALB URL or Server IP (e.g., https://rpa-orchestrator-prod-alb...)
+        api_key: The enterprise unique machine token
+        standalone: run with NO Orchestrator at all (Config.xlsx StandaloneMode=true).
+        queue_db_path / queue_db_password: standalone only — the local SQLite file
+            that holds the queue (Config.xlsx SQLiteDatabasePath, and the SQLCipher
+            key when SQLiteDatabaseType is SQLCipher).
+
+        Standalone mode is for bots handed to a client who does not take the
+        Orchestrator service. Every server call becomes a local no-op, so the bot
+        runs entirely on its own local queue and writes only to its local log file.
+        What is given up, deliberately:
+            * no remote Pause / Stop / Cancel
+            * no central run history, logs or dashboards
+            * no alerting on failure
+        It must be switched on EXPLICITLY — an unreachable Orchestrator is still a
+        hard error, so a connected bot can never fall back to running unmonitored.
+        """
+        self.base_url  = base_url.rstrip('/')
+        self.api_key   = api_key
+        self.standalone = bool(standalone)
+        # Built eagerly so a misconfigured standalone bot fails at startup rather
+        # than at the first queue write, halfway through a run.
+        self._local = _LocalQueue(queue_db_path, queue_db_password) if standalone else None
+        self.run_token: str = ""   # set by register_run_token()
+
+    # ── core command ──────────────────────────────────────────────────────
+    def send_command(self, action: str, payload: dict = None) -> dict:
+        if self.standalone:
+            # Queue verbs are served from the local SQLite queue; run-tracking verbs
+            # (register/close token, get_job_command, write_run_log) have no local
+            # equivalent and fall through to a harmless ok.
+            return self._local.handle(action, payload)
+        url = f"{self.base_url}/api/bot/command"
+        payload = payload or {}
+        if self.api_key and "api_key" not in payload:
+            payload["api_key"] = self.api_key
+        data = json.dumps({"action": action, "payload": payload}).encode("utf-8")
+
+        try:
+            req = urllib.request.Request(url, data=data, headers={'Content-Type': 'application/json'})
+            with urllib.request.urlopen(req, timeout=15) as response:
+                res = json.loads(response.read().decode("utf-8"))
+
+                # Auto re-register if worker didn't know the token
+                if res.get("status") == "error" and "unregistered run_token" in str(res.get("message", "")):
+                    if action != "register_run_token" and hasattr(self, "_last_proc_name"):
+                        machine = _machine_identity()
+                        reg_payload = {
+                            "api_key": self.api_key,
+                            "token": getattr(self, "run_token", ""),
+                            "machine_name": machine,
+                            "process_name": self._last_proc_name,
+                            "process_type": self._last_proc_type,
+                            "user_name": getattr(self, "_last_user_name", ""),
+                            "sub_process_name": getattr(self, "_last_sub_proc", ""),
+                            # Must carry the folder too. This re-registration runs
+                            # when the load balancer sends us to a node that never
+                            # saw the token; dropping FolderPath here would re-bind
+                            # the run to whichever same-named project that node
+                            # resolves first, mid-run, once enforcement is on.
+                            "folder_path": getattr(self, "_last_folder", "")
+                        }
+                        reg_data = json.dumps({"action": "register_run_token", "payload": reg_payload}).encode("utf-8")
+                        reg_req = urllib.request.Request(url, data=reg_data, headers={'Content-Type': 'application/json'})
+
+                        # Loop to try to get past load balancer sending us to different workers
+                        for _ in range(5):
+                            try:
+                                urllib.request.urlopen(reg_req, timeout=15)
+                            except Exception:
+                                pass
+
+                            try:
+                                with urllib.request.urlopen(req, timeout=15) as retry_resp:
+                                    r_json = json.loads(retry_resp.read().decode("utf-8"))
+                                    if not (r_json.get("status") == "error" and "unregistered run_token" in str(r_json.get("message", ""))):
+                                        return r_json
+                            except Exception:
+                                pass
+                return res
+        except urllib.error.URLError as e:
+            logger.error(f"HTTP Connection Error to {self.base_url}: {e}")
+            return {"status": "error", "message": f"Connection refused: {e}"}
+        except Exception as e:
+            logger.error(f"DbClient error: {e}")
+            return {"status": "error", "message": str(e)}
+
+    def register_run_token(self, process_name: str,
+                           process_type: str,
+                           machine_name: str = "",
+                           user_name: str = "",
+                           client_name: str = "",
+                           sub_process_name: str = "",
+                           folder_path: str = "") -> str:
+        """
+        Generate a unique run token, register it with the proxy so it
+        creates logs/{token}.log, and store it for subsequent calls.
+        Returns the token string.
+
+        folder_path is Config.xlsx 'FolderPath' — where this project sits in the
+        Orchestrator, e.g. 'MKV/Claim Status'. ProcessName alone is not unique
+        (Test and Prod share one, and two folders may each hold a 'Dispatcher'),
+        so without it the server picks whichever row it finds first. Blank is
+        accepted until the Orchestrator has 'Require every bot to name its
+        folder' switched on.
+        """
+        import socket as _socket
+        import uuid
+
+        self._last_proc_name = process_name
+        self._last_proc_type = process_type
+        self._last_user_name = user_name
+        self._last_sub_proc  = sub_process_name
+        self._last_folder    = folder_path
+
+        if not hasattr(self, "run_token") or not self.run_token:
+            self.run_token = uuid.uuid4().hex[:8]
+
+        if self.standalone:
+            # No server to register with — keep the token so local log lines still
+            # carry a run id, and carry on.
+            logger.info(f"Standalone mode: run {self.run_token[:8]}... "
+                        f"| {process_name} [{process_type}] (no Orchestrator)")
+            return self.run_token
+
+        token = self.run_token
+        if not machine_name:
+            machine_name = _machine_identity()
+        res = self.send_command("register_run_token", {
+            "token":        token,
+            "process_name": process_name,
+            "process_type": process_type,
+            "machine_name": machine_name,
+            "user_name":    user_name,
+            "sub_process_name": sub_process_name,
+            "folder_path":  folder_path,
+        })
+        # client_name is accepted above and deliberately NOT sent. The server
+        # filters on it when present, and a Dispatcher never calls get_next, so
+        # a project whose Config.xlsx carries a stale ClientName would start
+        # failing at registration the day it was added. FolderPath already
+        # identifies the project; adding a second new filter in the same release
+        # would make a rejection ambiguous about which of the two was wrong.
+        if res.get("status") == "ok":
+            self.run_token = token
+            logger.info(f"Run token registered: {token[:8]}... "
+                        f"| {process_name} [{process_type}] @ {machine_name}")
+        else:
+            msg = res.get("message", "Unknown error")
+            logger.error(f"register_run_token REJECTED: {msg}")
+            raise RuntimeError(
+                f"Proxy rejected token registration: {msg}. "
+                f"Fix Config.xlsx and restart the bot.")
+        return token
+
+
+    def close_run_token(self, summary: dict = None) -> None:
+        """Signal the proxy that this run has finished."""
+        if not self.run_token:
+            return
+        self.send_command("close_run_token", {
+            "token":   self.run_token,
+            "summary": summary or {},
+        })
+        logger.info(f"Run token closed: {self.run_token[:8]}...")
+        self.run_token = ""
+
+    def get_job_command(self) -> str:
+        """Poll the orchestrator for pending commands (PAUSE, STOP)."""
+        if self.standalone:
+            return None          # nobody can steer a standalone run
+        if not self.run_token: return None
+        res = self.send_command("get_job_command", {"token": self.run_token})
+        if res.get("status") == "ok":
+            return res.get("command")
+        return None
+
+    def get_queue_count(self, process_name: str, process_type: str = "", queue_name: str = "Main") -> str:
+        """Poll the orchestrator for pending queue count."""
+        res = self.send_command("get_queue_count", {
+            "process_name": process_name,
+            "process_type": process_type,
+            "queue_name":   queue_name
+        })
+        if res.get("status") == "ok":
+            return str(res.get("count", "Unknown"))
+        return "Unknown"
+
+    def get_asset(self, name: str, process_name: str = "", default=None):
+        """Read one centrally-managed asset (config value or credential).
+
+        Assets live in the Orchestrator, so a portal password changes in ONE place
+        instead of being edited by hand in Config.xlsx on every bot machine, and
+        the change is audited.
+
+        Falls back to `default` when the Orchestrator has no such asset or is
+        unreachable, so a project can move across one value at a time rather than
+        needing every asset migrated before the bot will run.
+        """
+        if self.standalone:
+            return default
+        res = self.send_command("get_asset", {
+            "name": name,
+            "process_name": process_name or getattr(self, "_last_proc_name", ""),
+            "machine_name": _machine_identity().split(chr(92))[0],
+        })
+        if res.get("status") == "ok":
+            return res.get("value")
+        logger.debug(f"Asset '{name}' not served: {res.get('message')}")
+        return default
+
+    def get_assets(self, process_name: str = "") -> dict:
+        """Every asset of this project in one round trip. Returns {} on failure,
+        so callers can merge over their Config.xlsx values without branching."""
+        if self.standalone:
+            return {}
+        res = self.send_command("get_assets", {
+            "process_name": process_name or getattr(self, "_last_proc_name", ""),
+            "machine_name": _machine_identity().split(chr(92))[0],
+        })
+        if res.get("status") == "ok":
+            return res.get("assets") or {}
+        logger.debug(f"Assets not served: {res.get('message')}")
+        return {}
+
+    def put_file(self, key: str, data, process_name: str = "",
+                 bucket: str = "default", content_type: str = None,
+                 is_encrypted: bool = False) -> dict:
+        """Upload a file to the Orchestrator so it is attached to this project.
+
+        `data` may be bytes or a path to a local file. The key is a label such as
+        "invoices/2026-08/INV-1002.pdf" — it is stored as a name, never used as a
+        path on the server, so any shape is safe.
+
+        PHI: encrypt the bytes with this project's phi.key BEFORE calling, and
+        pass is_encrypted=True. The server stores what it is given and cannot
+        read an encrypted payload — uploading PHI in the clear would put it
+        somewhere the zero-knowledge model does not protect.
+        """
+        import base64 as _b64
+        if self.standalone:
+            return {"status": "error", "message": "Standalone mode: no Orchestrator storage"}
+        if isinstance(data, str):
+            with open(data, "rb") as _fh:
+                raw = _fh.read()
+        else:
+            raw = bytes(data)
+        return self.send_command("put_object", {
+            "process_name": process_name or getattr(self, "_last_proc_name", ""),
+            "machine_name": _machine_identity().split(chr(92))[0],
+            "key": key, "bucket": bucket, "content_type": content_type,
+            "is_encrypted": bool(is_encrypted),
+            "run_token": self.run_token,
+            "data_b64": _b64.b64encode(raw).decode("ascii"),
+        })
+
+    def get_file(self, key: str, process_name: str = "", bucket: str = "default",
+                 save_to: str = None):
+        """Download a stored file. Returns bytes, or writes to save_to and
+        returns the path. Returns None when the file is not there."""
+        import base64 as _b64
+        if self.standalone:
+            return None
+        res = self.send_command("get_object", {
+            "process_name": process_name or getattr(self, "_last_proc_name", ""),
+            "machine_name": _machine_identity().split(chr(92))[0],
+            "key": key, "bucket": bucket,
+        })
+        if res.get("status") != "ok":
+            logger.debug(f"File '{key}' not served: {res.get('message')}")
+            return None
+        raw = _b64.b64decode(res.get("data_b64") or "")
+        if save_to:
+            with open(save_to, "wb") as _fh:
+                _fh.write(raw)
+            return save_to
+        return raw
+
+    def list_files(self, process_name: str = "", bucket: str = None) -> list:
+        """Files stored for this project. Returns [] on failure."""
+        if self.standalone:
+            return []
+        res = self.send_command("list_objects", {
+            "process_name": process_name or getattr(self, "_last_proc_name", ""),
+            "machine_name": _machine_identity().split(chr(92))[0],
+            "bucket": bucket,
+        })
+        return res.get("objects") or [] if res.get("status") == "ok" else []
+
+    def ask_human(self, title: str, prompt: str = "", fields: list = None,
+                  context: dict = None, secure_context: dict = None,
+                  process_name: str = "", queue_item_id=None, priority: int = 50,
+                  expires_in_hours: int = None) -> int:
+        """Ask a person something this run cannot decide. Returns an action id.
+
+        `context` is shown to the reviewer as-is, so keep PHI out of it.
+        `secure_context` is for anything with patient data: on a Secure Cloud bot
+        it is encrypted with this project's phi.key before it leaves the machine,
+        and only the reviewer's browser can read it. The plain DbClient has no
+        key, so it REFUSES secure_context rather than sending PHI in the clear.
+
+        `fields` describes what to ask, e.g.
+            [{"name": "decision", "type": "choice",
+              "options": ["Approve", "Deny", "Send back"], "label": "What should we do?"}]
+
+        Don't block a machine waiting on this. Raise the action, then postpone
+        the transaction (`postpone_until`) and let the item come round again.
+        """
+        if self.standalone:
+            return 0
+        if secure_context and getattr(self, "_phi", None) is None:
+            # A plain DbClient has no phi.key, so there is nothing to encrypt with.
+            return self._refuse_phi("ask_human")
+        payload = {
+            "process_name": process_name or getattr(self, "_last_proc_name", ""),
+            "machine_name": _machine_identity().split(chr(92))[0],
+            "title": title, "prompt": prompt, "form_schema": fields or [],
+            "form_data": context or {}, "priority": priority,
+            "run_token": self.run_token, "queue_item_id": queue_item_id,
+        }
+        if secure_context:
+            # Carried only as far as _SecureDbClient.send_command, which encrypts
+            # it and removes it from the payload. It never reaches the network.
+            payload["secure_context"] = secure_context
+        if expires_in_hours:
+            from datetime import datetime as _dt, timezone as _tz, timedelta as _td
+            payload["expires_at"] = (
+                _dt.now(_tz.utc) + _td(hours=int(expires_in_hours))).isoformat()
+        res = self.send_command("create_action", payload)
+        if res.get("status") != "ok":
+            logger.error(f"Could not raise action '{title}': {res.get('message')}")
+            return 0
+        logger.info(f"Action #{res['action_id']} raised for review: {title}")
+        return res["action_id"]
+
+    def _refuse_phi(self, where: str) -> int:
+        # Reached only on a non-Secure project, which has no phi.key. Sending the
+        # data anyway would put PHI somewhere the zero-knowledge model does not
+        # cover, so refuse instead — a failed run is recoverable, a disclosure is not.
+        logger.critical(
+            f"{where}: secure_context needs a Secure Cloud project with phi.key. "
+            "Refusing to send patient data unencrypted.")
+        return 0
+
+    def check_action(self, action_id: int, process_name: str = "") -> dict:
+        """Has it been answered? Returns {"status", "outcome", "result"}.
+
+        status is Pending / Completed / Cancelled / Expired. Treat anything but
+        Completed as "no decision" — an expired action means nobody was
+        available, which the run has to handle itself.
+        """
+        if self.standalone or not action_id:
+            return {"status": "Unavailable", "outcome": None, "result": None}
+        res = self.send_command("get_action", {
+            "process_name": process_name or getattr(self, "_last_proc_name", ""),
+            "machine_name": _machine_identity().split(chr(92))[0],
+            "action_id": action_id,
+        })
+        if res.get("status") != "ok":
+            return {"status": "Unavailable", "outcome": None, "result": None,
+                    "message": res.get("message")}
+        return {"status": res.get("action_status"), "outcome": res.get("outcome"),
+                "result": res.get("result"), "result_secure": res.get("result_secure"),
+                "completed_at": res.get("completed_at")}
+
+    def wait_for_action(self, action_id: int, timeout_minutes: int = 30,
+                        poll_seconds: int = 20, process_name: str = "") -> dict:
+        """Block until answered or the timeout passes.
+
+        Only for a run that genuinely cannot proceed. It holds the machine for
+        the whole wait, so for anything a person may take hours over, raise the
+        action and postpone the transaction instead.
+        """
+        import time as _time
+        # Nothing to wait for: standalone has no Orchestrator, and action_id 0 is
+        # what ask_human returns when it could not raise the question. Without
+        # this the loop below sees "Unavailable" every poll, which is not a
+        # decision, and holds the machine for the whole timeout — thirty minutes
+        # by default — before returning the same nothing it had at the start.
+        if self.standalone or not action_id:
+            return {"status": "Unavailable", "outcome": None, "result": None}
+        deadline = _time.time() + max(1, int(timeout_minutes)) * 60
+        while _time.time() < deadline:
+            res = self.check_action(action_id, process_name)
+            if res.get("status") not in ("Pending", "Unavailable"):
+                return res
+            _time.sleep(max(5, int(poll_seconds)))
+        logger.warning(f"Action #{action_id} not answered within {timeout_minutes} min")
+        return {"status": "Pending", "outcome": None, "result": None}
+
+    def cancel_action(self, action_id: int, process_name: str = "") -> bool:
+        """Withdraw a question this run no longer needs answered."""
+        if self.standalone or not action_id:
+            return False
+        res = self.send_command("cancel_action", {
+            "process_name": process_name or getattr(self, "_last_proc_name", ""),
+            "machine_name": _machine_identity().split(chr(92))[0],
+            "action_id": action_id,
+        })
+        return res.get("status") == "ok"
+
+    def write_log(self, level: str, message: str) -> None:
+        """Push a log message to the token log file via the proxy."""
+        if not self.run_token:
+            return
+        self.send_command("write_run_log", {
+            "token":   self.run_token,
+            "level":   level.upper(),
+            "message": message,
+        })

rpa_bot_sdk_core-1.0.0/src/rpa_bot_sdk_core/init_all_settings.py

@@ -0,0 +1,19 @@
+import pandas as pd
+import math
+
+
+def init_all_settings(config_path: str = "data/Config.xlsx") -> dict:
+    """Load Settings and Constants sheets from Config.xlsx into a dict."""
+    config = {}
+    xls = pd.ExcelFile(config_path)
+    for sheet in xls.sheet_names:
+        df = pd.read_excel(xls, sheet_name=sheet)
+        if "Name" in df.columns and "Value" in df.columns:
+            for _, row in df.iterrows():
+                name  = row["Name"]
+                value = row["Value"]
+                if isinstance(name, str) and name.strip():
+                    if isinstance(value, float) and math.isnan(value):
+                        value = None
+                    config[name.strip()] = value
+    return config

rpa_bot_sdk_core-1.0.0/src/rpa_bot_sdk_core/pause_controller.py

@@ -0,0 +1,61 @@
+import logging
+import threading
+import time
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+class PauseController:
+    # Cooperative pause/stop controller shared across the bot run.
+    # It pauses safely at framework checkpoints and safe action wrappers.
+
+    def __init__(self, poll_seconds: float = 0.25):
+        self._pause_event = threading.Event()
+        self._stop_event = threading.Event()
+        self._poll_seconds = poll_seconds
+        self._pause_logged = False
+
+    def request_pause(self) -> None:
+        self._pause_event.set()
+
+    def request_resume(self) -> None:
+        self._pause_event.clear()
+        self._pause_logged = False
+
+    def request_stop(self) -> None:
+        self._stop_event.set()
+
+    def is_paused(self) -> bool:
+        return self._pause_event.is_set()
+
+    def is_stop_requested(self) -> bool:
+        return self._stop_event.is_set()
+
+    def checkpoint(self, label: str = "") -> None:
+        if self._stop_event.is_set():
+            raise KeyboardInterrupt(f"STOP requested at {label}".strip())
+
+        while self._pause_event.is_set():
+            if not self._pause_logged:
+                logger.warning(f"Bot paused at checkpoint: {label}")
+                self._pause_logged = True
+            time.sleep(self._poll_seconds)
+            if self._stop_event.is_set():
+                raise KeyboardInterrupt(f"STOP requested while paused at {label}".strip())
+
+        self._pause_logged = False
+
+
+def get_pause_controller(config_or_controller: Any):
+    if isinstance(config_or_controller, PauseController):
+        return config_or_controller
+    if isinstance(config_or_controller, dict):
+        return config_or_controller.get("_pause_controller")
+    return None
+
+
+def checkpoint(config_or_controller: Any, label: str = "") -> None:
+    controller = get_pause_controller(config_or_controller)
+    if controller:
+        controller.checkpoint(label)

rpa_bot_sdk_core-1.0.0/src/rpa_bot_sdk_core/safe_actions.py

@@ -0,0 +1,65 @@
+import time
+from typing import Any, Callable
+from .pause_controller import checkpoint
+
+
+def safe_sleep(config: dict, seconds: float, label: str = "sleep", interval: float = 0.25) -> None:
+    # Pause-aware replacement for time.sleep().
+    end_at = time.time() + float(seconds)
+    while time.time() < end_at:
+        checkpoint(config, label)
+        time.sleep(min(interval, max(0, end_at - time.time())))
+    checkpoint(config, label)
+
+
+def safe_click(config: dict, target: Any, label: str = "click", *args, **kwargs):
+    # Pause-aware click wrapper for Selenium elements or Playwright locators.
+    checkpoint(config, f"before {label}")
+    result = target.click(*args, **kwargs)
+    checkpoint(config, f"after {label}")
+    return result
+
+
+def safe_type_text(config: dict, target: Any, text: str, label: str = "type", delay: float = 0.03) -> None:
+    # Pause-aware character-by-character typing.
+    # Supports Selenium WebElement.send_keys() and Playwright Locator.type().
+    checkpoint(config, f"before {label}")
+    for ch in str(text):
+        checkpoint(config, label)
+        if hasattr(target, "type"):
+            target.type(ch, delay=0)
+        elif hasattr(target, "send_keys"):
+            target.send_keys(ch)
+        elif callable(target):
+            target(ch)
+        else:
+            raise TypeError("safe_type_text target must support type(), send_keys(), or be callable")
+        if delay:
+            safe_sleep(config, delay, label=label, interval=min(delay, 0.25))
+    checkpoint(config, f"after {label}")
+
+
+def safe_fill_text(config: dict, target: Any, text: str, label: str = "fill", delay: float = 0.03) -> None:
+    # Clear/fill field safely, then type with pause checkpoints.
+    checkpoint(config, f"before {label}")
+    if hasattr(target, "fill"):
+        target.fill("")
+    elif hasattr(target, "clear"):
+        target.clear()
+    safe_type_text(config, target, text, label=label, delay=delay)
+    checkpoint(config, f"after {label}")
+
+
+def safe_call(config: dict, fn: Callable, label: str = "call", *args, **kwargs):
+    # Pause-aware wrapper for any short atomic action.
+    checkpoint(config, f"before {label}")
+    result = fn(*args, **kwargs)
+    checkpoint(config, f"after {label}")
+    return result
+
+
+def safe_iter(config: dict, iterable, label: str = "loop"):
+    # Yield items from an iterable with pause checkpoints before each item.
+    for item in iterable:
+        checkpoint(config, label)
+        yield item

rpa_bot_sdk_core-1.0.0/src/rpa_bot_sdk_core/structured_logger.py

@@ -0,0 +1,130 @@
+import logging
+import json
+import os
+import queue
+import threading
+from datetime import datetime
+
+_COLORS = {
+    "DEBUG":    "\033[36m",
+    "INFO":     "\033[32m",
+    "WARNING":  "\033[33m",
+    "ERROR":    "\033[31m",
+    "CRITICAL": "\033[35m",
+}
+_RESET = "\033[0m"
+
+
+class _StructuredFormatter(logging.Formatter):
+    def __init__(self, run_id: str, use_json: bool = False, colorize: bool = True):
+        super().__init__()
+        self.run_id   = run_id
+        self.use_json = use_json
+        self.colorize = colorize
+
+    def format(self, record: logging.LogRecord) -> str:
+        base = {
+            "ts":     datetime.utcnow().isoformat() + "Z",
+            "level":  record.levelname,
+            "run_id": self.run_id,
+            "logger": record.name,
+            "msg":    record.getMessage(),
+        }
+        if hasattr(record, "txn_id"):
+            base["txn_id"] = record.txn_id
+        if hasattr(record, "state"):
+            base["state"] = record.state
+        if record.exc_info:
+            base["exc"] = self.formatException(record.exc_info)
+        if self.use_json:
+            return json.dumps(base, ensure_ascii=False)
+        color  = _COLORS.get(record.levelname, "") if self.colorize else ""
+        ts     = base["ts"][11:23]
+        prefix = f"[{ts}][{record.levelname:8}][{self.run_id}]"
+        return f"{color}{prefix} {record.getMessage()}{_RESET}"
+
+class ProxyLogHandler(logging.Handler):
+    """Forwards Python log records to the Orchestrator proxy via DbClient.write_log()."""
+
+    def __init__(self, db_client, level=logging.INFO):
+        super().__init__(level)
+        self._client = db_client
+        self._queue  = queue.Queue()
+        self._stop   = threading.Event()
+        self._thread = threading.Thread(target=self._worker, daemon=True, name="ProxyLogWorker")
+        self._thread.start()
+
+    def emit(self, record: logging.LogRecord) -> None:
+        try:
+            self._queue.put_nowait(record)
+        except Exception:
+            pass
+
+    def _worker(self) -> None:
+        while True:
+            try:
+                record = self._queue.get(timeout=0.5)
+            except queue.Empty:
+                if self._stop.is_set():
+                    break
+                continue
+            try:
+                msg = self.format(record)
+                res = self._client.send_command("write_run_log", {
+                    "token":   self._client.run_token,
+                    "level":   record.levelname.upper(),
+                    "message": msg,
+                })
+                if res and res.get("status") == "error":
+                    print(f"[PROXY LOG ERROR] Server rejected log: {res.get('message')}")
+            except Exception as e:
+                print(f"[PROXY LOG ERROR] Failed to send log: {e}")
+            finally:
+                self._queue.task_done()
+
+    def flush(self) -> None:
+        self._queue.join()
+
+    def close(self) -> None:
+        self._stop.set()
+        self._queue.join()
+        self._thread.join(timeout=5)
+        super().close()
+
+
+def attach_proxy_handler(db_client, log_level: str = "INFO", run_id: str = "") -> None:
+    """Attach a ProxyLogHandler to the root logger so all framework
+    log messages are forwarded to the orchestrator's token log file."""
+    level = getattr(logging, log_level.upper(), logging.INFO)
+    root = logging.getLogger()
+    for h in root.handlers[:]:
+        if isinstance(h, ProxyLogHandler):
+            h.close()
+            root.removeHandler(h)
+    # Standalone: there is no orchestrator to forward to. Skip the handler
+    # entirely rather than run its background thread for a no-op send.
+    if getattr(db_client, "standalone", False):
+        return
+    handler = ProxyLogHandler(db_client, level=level)
+
+    # Use the same formatter as the file/console so the dashboard looks identical
+    handler.setFormatter(_StructuredFormatter(run_id, use_json=False, colorize=False))
+
+    root.addHandler(handler)
+
+
+
+def setup_logging(log_file: str, run_id: str, log_level: str = "INFO") -> None:
+    level = getattr(logging, log_level.upper(), logging.INFO)
+    root  = logging.getLogger()
+    root.setLevel(level)
+    root.handlers.clear()
+    log_dir = os.path.dirname(log_file)
+    if log_dir:
+        os.makedirs(log_dir, exist_ok=True)
+    fh = logging.FileHandler(log_file, encoding="utf-8")
+    fh.setFormatter(_StructuredFormatter(run_id, use_json=True, colorize=False))
+    root.addHandler(fh)
+    ch = logging.StreamHandler()
+    ch.setFormatter(_StructuredFormatter(run_id, use_json=False, colorize=True))
+    root.addHandler(ch)

rpa_bot_sdk_core-1.0.0/src/rpa_bot_sdk_core/utils.py

@@ -0,0 +1,15 @@
+import logging, os
+logger = logging.getLogger(__name__)
+def take_screenshot(screenshot_dir: str = "logs", prefix: str = "error") -> str:
+    try:
+        import pyautogui
+        from datetime import datetime
+        os.makedirs(screenshot_dir, exist_ok=True)
+        ts   = datetime.now().strftime("%Y%m%d_%H%M%S")
+        dest = os.path.join(screenshot_dir, f"{prefix}_{ts}.png")
+        pyautogui.screenshot(dest)
+        logger.info(f"Screenshot: {dest}")
+        return dest
+    except Exception as e:
+        logger.error(f"Screenshot failed: {e}")
+        return "screenshot_failed"

rpa_bot_sdk_core-1.0.0/src/rpa_bot_sdk_core.egg-info/PKG-INFO

@@ -0,0 +1,31 @@
+Metadata-Version: 2.4
+Name: rpa-bot-sdk-core
+Version: 1.0.0
+Summary: Orchestrator bot-side core: server client, pause/stop, logging, config loading. Shared by rpa-bot-sdk-performer and rpa-bot-sdk-dispatcher.
+Author: Kasun Perera
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: pandas
+Requires-Dist: openpyxl
+Provides-Extra: sqlcipher
+Requires-Dist: sqlcipher3-binary; extra == "sqlcipher"
+Requires-Dist: keyring; extra == "sqlcipher"
+Provides-Extra: screenshot
+Requires-Dist: pyautogui; extra == "screenshot"
+
+# rpa-bot-sdk-core
+
+The Orchestrator bot-side code shared by every role: `DbClient` (server auth,
+queue, assets, storage, human-in-the-loop over HTTP, or a local SQLite queue
+in StandaloneMode), `PauseController`/`checkpoint`, structured logging,
+`init_all_settings()` (Config.xlsx loader), `take_screenshot()`, and the
+`safe_*` UI-action wrappers.
+
+Neither a Performer nor a Dispatcher project installs this directly — it's
+the shared dependency of [`rpa-bot-sdk-performer`](../performer/README.md)
+and [`rpa-bot-sdk-dispatcher`](../dispatcher/README.md), pulled in
+automatically by whichever of those two a project actually needs.
+
+Bump this package's version specifically when the server contract itself
+changes (a `db_client.py` field/action). A change confined to one role's own
+orchestration (e.g. `QueueManager`) belongs in that role's package instead.

rpa_bot_sdk_core-1.0.0/src/rpa_bot_sdk_core.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+README.md
+pyproject.toml
+src/rpa_bot_sdk_core/__init__.py
+src/rpa_bot_sdk_core/db_client.py
+src/rpa_bot_sdk_core/init_all_settings.py
+src/rpa_bot_sdk_core/pause_controller.py
+src/rpa_bot_sdk_core/safe_actions.py
+src/rpa_bot_sdk_core/structured_logger.py
+src/rpa_bot_sdk_core/utils.py
+src/rpa_bot_sdk_core.egg-info/PKG-INFO
+src/rpa_bot_sdk_core.egg-info/SOURCES.txt
+src/rpa_bot_sdk_core.egg-info/dependency_links.txt
+src/rpa_bot_sdk_core.egg-info/requires.txt
+src/rpa_bot_sdk_core.egg-info/top_level.txt

rpa_bot_sdk_core-1.0.0/src/rpa_bot_sdk_core.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

rpa_bot_sdk_core-1.0.0/src/rpa_bot_sdk_core.egg-info/requires.txt

@@ -0,0 +1,9 @@
+pandas
+openpyxl
+
+[screenshot]
+pyautogui
+
+[sqlcipher]
+sqlcipher3-binary
+keyring

rpa_bot_sdk_core-1.0.0/src/rpa_bot_sdk_core.egg-info/top_level.txt

@@ -0,0 +1 @@
+rpa_bot_sdk_core