batautomate 0.1.0__tar.gz

batautomate-0.1.0/PKG-INFO

@@ -0,0 +1,95 @@
+Metadata-Version: 2.4
+Name: batautomate
+Version: 0.1.0
+Summary: Core execution engine and standard action libraries for BAT Automate RPA platform
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: playwright>=1.40.0
+Requires-Dist: pandas>=2.0.0
+Requires-Dist: openpyxl>=3.1.0
+Requires-Dist: requests>=2.28.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+
+# bat-core
+
+Execution Runtime Engine and Standard Action Libraries for BAT Automate RPA Platform.
+
+## Directory Structure
+
+```text
+bat-core/
+├── pyproject.toml          # Project configuration & dependencies
+├── requirements.txt        # Package dependencies list
+├── README.md               # Documentation
+├── bat_core/               # Core Python Package
+│   ├── __init__.py
+│   ├── cli.py              # CLI Runner
+│   ├── models/             # Flow & Execution Models (Pydantic)
+│   │   ├── __init__.py
+│   │   ├── flow.py
+│   │   └── context.py
+│   ├── engine/             # Flow Interpreter & Evaluator Engine
+│   │   ├── __init__.py
+│   │   ├── interpreter.py
+│   │   ├── evaluator.py
+│   │   └── logger.py
+│   └── actions/            # Action Libraries & Registry
+│       ├── __init__.py
+│       ├── base.py
+│       ├── registry.py
+│       ├── logic.py
+│       ├── data_excel.py
+│       ├── web_playwright.py
+│       └── http_api.py
+├── examples/               # Sample Flow JSON files
+│   └── sample_flow.json
+└── tests/                  # Unit Tests
+    └── test_engine.py
+```
+
+---
+
+## คู่มือการใช้งานและการสั่งรันคำสั่ง (CLI Execution Guide)
+
+โมดูล `bat-core` สามารถสั่งรันกระบวนการอัตโนมัติ (RPA Flow) ผ่าน Command Line Interface (CLI) ได้ดังนี้:
+
+### 1. การติดตั้งแบบ Editable (สำหรับการพัฒนา)
+
+ติดตั้ง Package และ Dependencies ในสภาพแวดล้อม Python:
+```powershell
+pip install -e .
+```
+
+### 2. รูปแบบคำสั่งการรันพื้นฐาน
+
+รันผ่านสคริปต์ Python Module:
+```powershell
+python -m bat_core.cli run examples/sample_flow.json
+```
+
+หรือรันผ่านคำสั่ง CLI สั้น (เมื่อทำการติดตั้ง Package แล้ว):
+```powershell
+bat-core run examples/sample_flow.json
+```
+
+### 3. ตัวเลือกและพารามิเตอร์เสริม (CLI Options)
+
+- **`--vars` (Override / Inject Variables):** ส่งค่าตัวแปรจากภายนอกเข้าไปใน Flow รูปแบบ JSON String
+  ```powershell
+  python -m bat_core.cli run examples/sample_flow.json --vars "{\"target_url\": \"https://httpbin.org/get\"}"
+  ```
+
+- **`--log-dir` (Save Execution Logs):** กำหนดไดเรกทอรีสำหรับบันทึกไฟล์ JSON Execution Log
+  ```powershell
+  python -m bat_core.cli run examples/sample_flow.json --log-dir "./logs"
+  ```
+
+### 4. การรันชุดทดสอบ (Unit Testing)
+
+ทดสอบความถูกต้องของระบบและ Action ทั้งหมด:
+```powershell
+python -m pytest tests/
+```
+

batautomate-0.1.0/README.md

@@ -0,0 +1,81 @@
+# bat-core
+
+Execution Runtime Engine and Standard Action Libraries for BAT Automate RPA Platform.
+
+## Directory Structure
+
+```text
+bat-core/
+├── pyproject.toml          # Project configuration & dependencies
+├── requirements.txt        # Package dependencies list
+├── README.md               # Documentation
+├── bat_core/               # Core Python Package
+│   ├── __init__.py
+│   ├── cli.py              # CLI Runner
+│   ├── models/             # Flow & Execution Models (Pydantic)
+│   │   ├── __init__.py
+│   │   ├── flow.py
+│   │   └── context.py
+│   ├── engine/             # Flow Interpreter & Evaluator Engine
+│   │   ├── __init__.py
+│   │   ├── interpreter.py
+│   │   ├── evaluator.py
+│   │   └── logger.py
+│   └── actions/            # Action Libraries & Registry
+│       ├── __init__.py
+│       ├── base.py
+│       ├── registry.py
+│       ├── logic.py
+│       ├── data_excel.py
+│       ├── web_playwright.py
+│       └── http_api.py
+├── examples/               # Sample Flow JSON files
+│   └── sample_flow.json
+└── tests/                  # Unit Tests
+    └── test_engine.py
+```
+
+---
+
+## คู่มือการใช้งานและการสั่งรันคำสั่ง (CLI Execution Guide)
+
+โมดูล `bat-core` สามารถสั่งรันกระบวนการอัตโนมัติ (RPA Flow) ผ่าน Command Line Interface (CLI) ได้ดังนี้:
+
+### 1. การติดตั้งแบบ Editable (สำหรับการพัฒนา)
+
+ติดตั้ง Package และ Dependencies ในสภาพแวดล้อม Python:
+```powershell
+pip install -e .
+```
+
+### 2. รูปแบบคำสั่งการรันพื้นฐาน
+
+รันผ่านสคริปต์ Python Module:
+```powershell
+python -m bat_core.cli run examples/sample_flow.json
+```
+
+หรือรันผ่านคำสั่ง CLI สั้น (เมื่อทำการติดตั้ง Package แล้ว):
+```powershell
+bat-core run examples/sample_flow.json
+```
+
+### 3. ตัวเลือกและพารามิเตอร์เสริม (CLI Options)
+
+- **`--vars` (Override / Inject Variables):** ส่งค่าตัวแปรจากภายนอกเข้าไปใน Flow รูปแบบ JSON String
+  ```powershell
+  python -m bat_core.cli run examples/sample_flow.json --vars "{\"target_url\": \"https://httpbin.org/get\"}"
+  ```
+
+- **`--log-dir` (Save Execution Logs):** กำหนดไดเรกทอรีสำหรับบันทึกไฟล์ JSON Execution Log
+  ```powershell
+  python -m bat_core.cli run examples/sample_flow.json --log-dir "./logs"
+  ```
+
+### 4. การรันชุดทดสอบ (Unit Testing)
+
+ทดสอบความถูกต้องของระบบและ Action ทั้งหมด:
+```powershell
+python -m pytest tests/
+```
+

batautomate-0.1.0/bat_core/__init__.py

@@ -0,0 +1,5 @@
+"""
+bat-core: Core Execution Engine for BAT Automate RPA Platform
+"""
+
+__version__ = "0.1.0"

batautomate-0.1.0/bat_core/actions/__init__.py

@@ -0,0 +1,17 @@
+"""
+Actions registry and standard action implementations.
+"""
+
+from .base import BaseAction
+from .registry import ActionRegistry, register_action
+from . import logic, data_excel, web_playwright, http_api
+
+__all__ = [
+    "BaseAction",
+    "ActionRegistry",
+    "register_action",
+    "logic",
+    "data_excel",
+    "web_playwright",
+    "http_api",
+]

batautomate-0.1.0/bat_core/actions/base.py

@@ -0,0 +1,20 @@
+from abc import ABC, abstractmethod
+from typing import Any, Dict
+
+from ..models.context import ExecutionContext
+
+
+class BaseAction(ABC):
+    """
+    Abstract base class for all BAT Automate Actions.
+    """
+
+    action_type: str = "base"
+
+    @abstractmethod
+    def execute(self, parameters: Dict[str, Any], context: ExecutionContext) -> Any:
+        """
+        Executes the action with given parameters and context.
+        Returns output data to be stored or used by downstream steps.
+        """
+        pass

batautomate-0.1.0/bat_core/actions/data_excel.py

@@ -0,0 +1,39 @@
+from pathlib import Path
+from typing import Any, Dict
+import pandas as pd
+
+from .base import BaseAction
+from .registry import register_action
+from ..models.context import ExecutionContext
+
+
+@register_action("excel.read")
+class ExcelReadAction(BaseAction):
+    def execute(self, parameters: Dict[str, Any], context: ExecutionContext) -> Any:
+        file_path = parameters.get("file_path")
+        sheet_name = parameters.get("sheet_name", 0)
+        
+        if not file_path or not Path(file_path).exists():
+            raise FileNotFoundError(f"Excel file not found: {file_path}")
+
+        df = pd.read_excel(file_path, sheet_name=sheet_name)
+        records = df.to_dict(orient="records")
+        return records
+
+
+@register_action("excel.write")
+class ExcelWriteAction(BaseAction):
+    def execute(self, parameters: Dict[str, Any], context: ExecutionContext) -> Any:
+        file_path = parameters.get("file_path")
+        data = parameters.get("data", [])
+        sheet_name = parameters.get("sheet_name", "Sheet1")
+
+        if isinstance(data, list):
+            df = pd.DataFrame(data)
+        elif isinstance(data, dict):
+            df = pd.DataFrame([data])
+        else:
+            raise ValueError("Data for excel.write must be a list of dicts or a dict.")
+
+        df.to_excel(file_path, sheet_name=sheet_name, index=False)
+        return {"rows_written": len(df), "file_path": file_path}

batautomate-0.1.0/bat_core/actions/http_api.py

@@ -0,0 +1,36 @@
+from typing import Any, Dict
+import requests
+
+from .base import BaseAction
+from .registry import register_action
+from ..models.context import ExecutionContext
+
+
+@register_action("http.request")
+class HttpRequestAction(BaseAction):
+    def execute(self, parameters: Dict[str, Any], context: ExecutionContext) -> Any:
+        url = parameters.get("url")
+        method = parameters.get("method", "GET").upper()
+        headers = parameters.get("headers", {})
+        payload = parameters.get("payload")
+        timeout = parameters.get("timeout", 30)
+
+        response = requests.request(
+            method=method,
+            url=url,
+            headers=headers,
+            json=payload if isinstance(payload, dict) else None,
+            data=payload if isinstance(payload, str) else None,
+            timeout=timeout
+        )
+
+        try:
+            body = response.json()
+        except Exception:
+            body = response.text
+
+        return {
+            "status_code": response.status_code,
+            "headers": dict(response.headers),
+            "body": body
+        }

batautomate-0.1.0/bat_core/actions/logic.py

@@ -0,0 +1,24 @@
+import time
+from typing import Any, Dict
+
+from .base import BaseAction
+from .registry import register_action
+from ..models.context import ExecutionContext
+
+
+@register_action("logic.set_variable")
+class SetVariableAction(BaseAction):
+    def execute(self, parameters: Dict[str, Any], context: ExecutionContext) -> Any:
+        name = parameters.get("name")
+        value = parameters.get("value")
+        if name:
+            context.set_variable(name, value)
+        return value
+
+
+@register_action("logic.delay")
+class DelayAction(BaseAction):
+    def execute(self, parameters: Dict[str, Any], context: ExecutionContext) -> Any:
+        seconds = float(parameters.get("seconds", 1.0))
+        time.sleep(seconds)
+        return {"delayed_seconds": seconds}

batautomate-0.1.0/bat_core/actions/registry.py

@@ -0,0 +1,32 @@
+from typing import Dict, Type
+from .base import BaseAction
+
+
+class ActionRegistry:
+    """
+    Registry mapping action string names (e.g. 'excel.read', 'logic.set_variable') to Action Classes.
+    """
+
+    _registry: Dict[str, Type[BaseAction]] = {}
+
+    @classmethod
+    def register(cls, action_type: str, action_class: Type[BaseAction]) -> None:
+        cls._registry[action_type] = action_class
+
+    @classmethod
+    def get(cls, action_type: str) -> Type[BaseAction]:
+        if action_type not in cls._registry:
+            raise KeyError(f"Action '{action_type}' is not registered in ActionRegistry.")
+        return cls._registry[action_type]
+
+    @classmethod
+    def list_actions(cls) -> Dict[str, Type[BaseAction]]:
+        return dict(cls._registry)
+
+
+def register_action(action_type: str):
+    def decorator(cls: Type[BaseAction]):
+        cls.action_type = action_type
+        ActionRegistry.register(action_type, cls)
+        return cls
+    return decorator

batautomate-0.1.0/bat_core/actions/web_playwright.py

@@ -0,0 +1,27 @@
+from typing import Any, Dict
+from .base import BaseAction
+from .registry import register_action
+from ..models.context import ExecutionContext
+
+
+@register_action("web.open")
+class WebOpenAction(BaseAction):
+    def execute(self, parameters: Dict[str, Any], context: ExecutionContext) -> Any:
+        url = parameters.get("url")
+        headless = parameters.get("headless", True)
+        return {"action": "web.open", "url": url, "headless": headless, "status": "simulated"}
+
+
+@register_action("web.click")
+class WebClickAction(BaseAction):
+    def execute(self, parameters: Dict[str, Any], context: ExecutionContext) -> Any:
+        selector = parameters.get("selector")
+        return {"action": "web.click", "selector": selector, "status": "simulated"}
+
+
+@register_action("web.type")
+class WebTypeAction(BaseAction):
+    def execute(self, parameters: Dict[str, Any], context: ExecutionContext) -> Any:
+        selector = parameters.get("selector")
+        text = parameters.get("text")
+        return {"action": "web.type", "selector": selector, "text": text, "status": "simulated"}

batautomate-0.1.0/bat_core/cli.py

@@ -0,0 +1,56 @@
+import argparse
+import json
+import sys
+from pathlib import Path
+
+from .models.flow import FlowDefinition
+from .engine.interpreter import FlowInterpreter
+from .engine.logger import ExecutionLogger
+
+
+def main():
+    parser = argparse.ArgumentParser(description="bat-core CLI Runner")
+    subparsers = parser.add_subparsers(dest="command", help="Available commands")
+
+    run_parser = subparsers.add_parser("run", help="Run a Flow JSON file")
+    run_parser.add_argument("flow_file", help="Path to flow.json file")
+    run_parser.add_argument("--vars", help="Optional JSON string of variables to override", default=None)
+    run_parser.add_argument("--log-dir", help="Directory to save execution JSON logs", default=None)
+
+    args = parser.parse_args()
+
+    if args.command == "run":
+        flow_path = Path(args.flow_file)
+        if not flow_path.exists():
+            print(f"Error: Flow file '{args.flow_file}' does not exist.", file=sys.stderr)
+            sys.exit(1)
+
+        try:
+            content = flow_path.read_text(encoding="utf-8")
+            raw_json = json.loads(content)
+            flow_def = FlowDefinition.model_validate(raw_json)
+        except Exception as e:
+            print(f"Error parsing flow JSON: {str(e)}", file=sys.stderr)
+            sys.exit(1)
+
+        extra_vars = {}
+        if args.vars:
+            try:
+                extra_vars = json.loads(args.vars)
+            except Exception as e:
+                print(f"Error parsing --vars JSON: {str(e)}", file=sys.stderr)
+                sys.exit(1)
+
+        logger = ExecutionLogger(log_dir=args.log_dir)
+        interpreter = FlowInterpreter(logger=logger)
+        context = interpreter.run_flow(flow_def, initial_vars=extra_vars)
+
+        if context.has_error:
+            sys.exit(1)
+        sys.exit(0)
+    else:
+        parser.print_help()
+
+
+if __name__ == "__main__":
+    main()

batautomate-0.1.0/bat_core/engine/__init__.py

@@ -0,0 +1,13 @@
+"""
+Flow execution engine, evaluator, logger, and interpreter.
+"""
+
+from .evaluator import VariableEvaluator
+from .logger import ExecutionLogger
+from .interpreter import FlowInterpreter
+
+__all__ = [
+    "VariableEvaluator",
+    "ExecutionLogger",
+    "FlowInterpreter",
+]

batautomate-0.1.0/bat_core/engine/evaluator.py

@@ -0,0 +1,55 @@
+import os
+import re
+from typing import Any, Dict
+
+
+class VariableEvaluator:
+    """
+    Evaluates variable expressions in string formats such as ${var_name} or ${env.ENV_VAR}.
+    Also handles dictionary key traversal like ${row.Name}.
+    """
+
+    PATTERN = re.compile(r"\$\{([^}]+)\}")
+
+    @classmethod
+    def evaluate_value(cls, value: Any, context_vars: Dict[str, Any]) -> Any:
+        if isinstance(value, str):
+            match = cls.PATTERN.fullmatch(value.strip())
+            if match:
+                var_expr = match.group(1).strip()
+                return cls._resolve_expr(var_expr, context_vars)
+            
+            def replace_match(m):
+                resolved = cls._resolve_expr(m.group(1).strip(), context_vars)
+                return str(resolved) if resolved is not None else ""
+
+            return cls.PATTERN.sub(replace_match, value)
+
+        elif isinstance(value, dict):
+            return {k: cls.evaluate_value(v, context_vars) for k, v in value.items()}
+        elif isinstance(value, list):
+            return [cls.evaluate_value(v, context_vars) for v in value]
+        else:
+            return value
+
+    @classmethod
+    def _resolve_expr(cls, expr: str, context_vars: Dict[str, Any]) -> Any:
+        if expr.startswith("env."):
+            env_key = expr[4:]
+            return os.getenv(env_key, "")
+
+        parts = expr.split(".")
+        root_key = parts[0]
+
+        if root_key not in context_vars:
+            return None
+
+        current = context_vars[root_key]
+        for part in parts[1:]:
+            if isinstance(current, dict):
+                current = current.get(part)
+            elif hasattr(current, part):
+                current = getattr(current, part)
+            else:
+                return None
+        return current

batautomate-0.1.0/bat_core/engine/interpreter.py

@@ -0,0 +1,134 @@
+from datetime import datetime
+from typing import Any, Dict, Optional
+
+from .evaluator import VariableEvaluator
+from .logger import ExecutionLogger
+from ..actions.registry import ActionRegistry
+from ..models.context import ExecutionContext, StepResult
+from ..models.flow import FlowDefinition, Step
+
+
+class FlowInterpreter:
+    """
+    Interpreter that parses FlowDefinition, evaluates expressions, and executes steps sequentially.
+    """
+
+    def __init__(self, logger: Optional[ExecutionLogger] = None):
+        self.logger = logger or ExecutionLogger()
+
+    def run_flow(self, flow_def: FlowDefinition, initial_vars: Optional[Dict[str, Any]] = None) -> ExecutionContext:
+        context = ExecutionContext(flow_name=flow_def.name)
+
+        if flow_def.variables:
+            for k, v in flow_def.variables.items():
+                context.set_variable(k, v)
+
+        if initial_vars:
+            for k, v in initial_vars.items():
+                context.set_variable(k, v)
+
+        start_time = datetime.now()
+
+        try:
+            for step in flow_def.steps:
+                self._execute_step(step, context)
+            context.is_completed = True
+        except Exception as e:
+            context.has_error = True
+            self.logger.logger.error(f"Flow execution failed with unhandled exception: {str(e)}")
+
+        end_time = datetime.now()
+        total_duration = (end_time - start_time).total_seconds()
+
+        context.metrics.total_steps = len(context.step_results)
+        context.metrics.successful_steps = sum(1 for r in context.step_results if r.status == "success")
+        context.metrics.failed_steps = sum(1 for r in context.step_results if r.status == "failed")
+        context.metrics.skipped_steps = sum(1 for r in context.step_results if r.status == "skipped")
+        context.metrics.total_duration_seconds = total_duration
+
+        self.logger.log_execution_summary(context)
+        return context
+
+    def _execute_step(self, step: Step, context: ExecutionContext) -> None:
+        self.logger.log_step_start(step.id, step.name, step.action)
+        start_time = datetime.now()
+
+        evaluated_params = VariableEvaluator.evaluate_value(step.parameters, context.variables)
+
+        if step.action == "logic.loop":
+            self._handle_loop_step(step, evaluated_params, context, start_time)
+            return
+
+        try:
+            action_cls = ActionRegistry.get(step.action)
+            action_instance = action_cls()
+            output = action_instance.execute(evaluated_params, context)
+
+            if step.output_var and output is not None:
+                context.set_variable(step.output_var, output)
+
+            end_time = datetime.now()
+            duration = (end_time - start_time).total_seconds()
+
+            result = StepResult(
+                step_id=step.id,
+                step_name=step.name,
+                status="success",
+                start_time=start_time,
+                end_time=end_time,
+                duration_seconds=duration,
+                output=output
+            )
+            context.step_results.append(result)
+            self.logger.log_step_result(result)
+
+        except Exception as e:
+            end_time = datetime.now()
+            duration = (end_time - start_time).total_seconds()
+            error_type = "Business" if "Business" in type(e).__name__ else "Technical"
+
+            result = StepResult(
+                step_id=step.id,
+                step_name=step.name,
+                status="failed",
+                start_time=start_time,
+                end_time=end_time,
+                duration_seconds=duration,
+                error_message=str(e),
+                error_type=error_type
+            )
+            context.step_results.append(result)
+            self.logger.log_step_result(result)
+
+            if step.error_handler and step.error_handler.on_error == "continue":
+                return
+            raise e
+
+    def _handle_loop_step(self, step: Step, evaluated_params: Dict[str, Any], context: ExecutionContext, start_time: datetime) -> None:
+        items = evaluated_params.get("items", [])
+        item_var = evaluated_params.get("item_var", "item")
+        sub_steps = step.sub_steps or []
+
+        if not isinstance(items, list):
+            items = [items]
+
+        for index, item in enumerate(items):
+            context.set_variable(item_var, item)
+            context.set_variable(f"{item_var}_index", index)
+            for sub_step in sub_steps:
+                self._execute_step(sub_step, context)
+
+        end_time = datetime.now()
+        duration = (end_time - start_time).total_seconds()
+
+        result = StepResult(
+            step_id=step.id,
+            step_name=step.name,
+            status="success",
+            start_time=start_time,
+            end_time=end_time,
+            duration_seconds=duration,
+            output={"total_items_processed": len(items)}
+        )
+        context.step_results.append(result)
+        self.logger.log_step_result(result)

batautomate-0.1.0/bat_core/engine/logger.py

@@ -0,0 +1,55 @@
+import json
+import logging
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+from ..models.context import ExecutionContext, StepResult
+
+
+class ExecutionLogger:
+    """
+    Structured logger for recording flow execution steps and metrics.
+    Prints to console and outputs structured JSON logs.
+    """
+
+    def __init__(self, log_dir: Optional[str] = None):
+        self.logger = logging.getLogger("bat_core")
+        self.logger.setLevel(logging.INFO)
+        if not self.logger.handlers:
+            handler = logging.StreamHandler()
+            formatter = logging.Formatter("[%(asctime)s] [%(levelname)s] %(message)s")
+            handler.setFormatter(formatter)
+            self.logger.addHandler(handler)
+
+        self.log_dir = Path(log_dir) if log_dir else None
+        if self.log_dir:
+            self.log_dir.mkdir(parents=True, exist_ok=True)
+
+    def log_step_start(self, step_id: str, step_name: str, action: str) -> None:
+        self.logger.info(f"Starting Step [{step_id}] '{step_name}' (Action: {action})")
+
+    def log_step_result(self, result: StepResult) -> None:
+        status_upper = result.status.upper()
+        if result.status == "success":
+            self.logger.info(
+                f"Completed Step [{result.step_id}] '{result.step_name}' in {result.duration_seconds:.3f}s"
+            )
+        elif result.status == "failed":
+            self.logger.error(
+                f"Failed Step [{result.step_id}] '{result.step_name}' - [{result.error_type} Error]: {result.error_message}"
+            )
+        else:
+            self.logger.warning(f"Skipped Step [{result.step_id}] '{result.step_name}'")
+
+    def log_execution_summary(self, context: ExecutionContext) -> None:
+        m = context.metrics
+        self.logger.info("=== Flow Execution Summary ===")
+        self.logger.info(f"Flow Name: {context.flow_name}")
+        self.logger.info(f"Total Steps: {m.total_steps} (Success: {m.successful_steps}, Failed: {m.failed_steps}, Skipped: {m.skipped_steps})")
+        self.logger.info(f"Total Duration: {m.total_duration_seconds:.2f}s")
+
+        if self.log_dir:
+            log_file = self.log_dir / f"log_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
+            log_file.write_text(json.dumps(context.model_dump(mode="json"), indent=2), encoding="utf-8")
+            self.logger.info(f"Saved JSON log to: {log_file}")

batautomate-0.1.0/bat_core/models/__init__.py

@@ -0,0 +1,17 @@
+"""
+Data models for Flow definitions and execution contexts.
+"""
+
+from .flow import FlowDefinition, Step, ActionConfig, VariableDefinition, ErrorHandlerConfig
+from .context import ExecutionContext, StepResult, ExecutionMetrics
+
+__all__ = [
+    "FlowDefinition",
+    "Step",
+    "ActionConfig",
+    "VariableDefinition",
+    "ErrorHandlerConfig",
+    "ExecutionContext",
+    "StepResult",
+    "ExecutionMetrics",
+]

batautomate-0.1.0/bat_core/models/context.py

@@ -0,0 +1,41 @@
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+from pydantic import BaseModel, Field
+
+
+class StepResult(BaseModel):
+    step_id: str
+    step_name: str
+    status: str  # success, failed, skipped
+    start_time: datetime
+    end_time: datetime
+    duration_seconds: float
+    output: Optional[Any] = None
+    error_message: Optional[str] = None
+    error_type: Optional[str] = None  # Technical, Business
+
+
+class ExecutionMetrics(BaseModel):
+    total_steps: int = 0
+    successful_steps: int = 0
+    failed_steps: int = 0
+    skipped_steps: int = 0
+    total_duration_seconds: float = 0.0
+    hours_saved: float = 0.0
+    cost_saved: float = 0.0
+
+
+class ExecutionContext(BaseModel):
+    flow_name: str
+    start_time: datetime = Field(default_factory=datetime.now)
+    variables: Dict[str, Any] = Field(default_factory=dict)
+    step_results: List[StepResult] = Field(default_factory=list)
+    metrics: ExecutionMetrics = Field(default_factory=ExecutionMetrics)
+    is_completed: bool = False
+    has_error: bool = False
+
+    def set_variable(self, name: str, value: Any) -> None:
+        self.variables[name] = value
+
+    def get_variable(self, name: str, default: Any = None) -> Any:
+        return self.variables.get(name, default)

batautomate-0.1.0/bat_core/models/flow.py

@@ -0,0 +1,44 @@
+from typing import Any, Dict, List, Optional
+from pydantic import BaseModel, Field
+
+
+class VariableDefinition(BaseModel):
+    name: str
+    value: Any
+    description: Optional[str] = None
+
+
+class ErrorHandlerConfig(BaseModel):
+    on_error: str = "stop"  # stop, continue, retry
+    max_retries: int = 0
+    retry_interval: float = 1.0
+    fallback_step_id: Optional[str] = None
+
+
+class Step(BaseModel):
+    id: str
+    name: str
+    action: str
+    parameters: Dict[str, Any] = Field(default_factory=dict)
+    output_var: Optional[str] = None
+    sub_steps: Optional[List["Step"]] = None
+    error_handler: Optional[ErrorHandlerConfig] = None
+    condition: Optional[str] = None
+
+
+Step.model_rebuild()
+
+
+class ActionConfig(BaseModel):
+    name: str
+    action_class: str
+    module: str
+    description: Optional[str] = None
+
+
+class FlowDefinition(BaseModel):
+    name: str
+    description: Optional[str] = None
+    version: str = "1.0.0"
+    variables: Dict[str, Any] = Field(default_factory=dict)
+    steps: List[Step] = Field(default_factory=list)

batautomate-0.1.0/batautomate.egg-info/PKG-INFO

@@ -0,0 +1,95 @@
+Metadata-Version: 2.4
+Name: batautomate
+Version: 0.1.0
+Summary: Core execution engine and standard action libraries for BAT Automate RPA platform
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: playwright>=1.40.0
+Requires-Dist: pandas>=2.0.0
+Requires-Dist: openpyxl>=3.1.0
+Requires-Dist: requests>=2.28.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+
+# bat-core
+
+Execution Runtime Engine and Standard Action Libraries for BAT Automate RPA Platform.
+
+## Directory Structure
+
+```text
+bat-core/
+├── pyproject.toml          # Project configuration & dependencies
+├── requirements.txt        # Package dependencies list
+├── README.md               # Documentation
+├── bat_core/               # Core Python Package
+│   ├── __init__.py
+│   ├── cli.py              # CLI Runner
+│   ├── models/             # Flow & Execution Models (Pydantic)
+│   │   ├── __init__.py
+│   │   ├── flow.py
+│   │   └── context.py
+│   ├── engine/             # Flow Interpreter & Evaluator Engine
+│   │   ├── __init__.py
+│   │   ├── interpreter.py
+│   │   ├── evaluator.py
+│   │   └── logger.py
+│   └── actions/            # Action Libraries & Registry
+│       ├── __init__.py
+│       ├── base.py
+│       ├── registry.py
+│       ├── logic.py
+│       ├── data_excel.py
+│       ├── web_playwright.py
+│       └── http_api.py
+├── examples/               # Sample Flow JSON files
+│   └── sample_flow.json
+└── tests/                  # Unit Tests
+    └── test_engine.py
+```
+
+---
+
+## คู่มือการใช้งานและการสั่งรันคำสั่ง (CLI Execution Guide)
+
+โมดูล `bat-core` สามารถสั่งรันกระบวนการอัตโนมัติ (RPA Flow) ผ่าน Command Line Interface (CLI) ได้ดังนี้:
+
+### 1. การติดตั้งแบบ Editable (สำหรับการพัฒนา)
+
+ติดตั้ง Package และ Dependencies ในสภาพแวดล้อม Python:
+```powershell
+pip install -e .
+```
+
+### 2. รูปแบบคำสั่งการรันพื้นฐาน
+
+รันผ่านสคริปต์ Python Module:
+```powershell
+python -m bat_core.cli run examples/sample_flow.json
+```
+
+หรือรันผ่านคำสั่ง CLI สั้น (เมื่อทำการติดตั้ง Package แล้ว):
+```powershell
+bat-core run examples/sample_flow.json
+```
+
+### 3. ตัวเลือกและพารามิเตอร์เสริม (CLI Options)
+
+- **`--vars` (Override / Inject Variables):** ส่งค่าตัวแปรจากภายนอกเข้าไปใน Flow รูปแบบ JSON String
+  ```powershell
+  python -m bat_core.cli run examples/sample_flow.json --vars "{\"target_url\": \"https://httpbin.org/get\"}"
+  ```
+
+- **`--log-dir` (Save Execution Logs):** กำหนดไดเรกทอรีสำหรับบันทึกไฟล์ JSON Execution Log
+  ```powershell
+  python -m bat_core.cli run examples/sample_flow.json --log-dir "./logs"
+  ```
+
+### 4. การรันชุดทดสอบ (Unit Testing)
+
+ทดสอบความถูกต้องของระบบและ Action ทั้งหมด:
+```powershell
+python -m pytest tests/
+```
+

batautomate-0.1.0/batautomate.egg-info/SOURCES.txt

@@ -0,0 +1,25 @@
+README.md
+pyproject.toml
+bat_core/__init__.py
+bat_core/cli.py
+bat_core/actions/__init__.py
+bat_core/actions/base.py
+bat_core/actions/data_excel.py
+bat_core/actions/http_api.py
+bat_core/actions/logic.py
+bat_core/actions/registry.py
+bat_core/actions/web_playwright.py
+bat_core/engine/__init__.py
+bat_core/engine/evaluator.py
+bat_core/engine/interpreter.py
+bat_core/engine/logger.py
+bat_core/models/__init__.py
+bat_core/models/context.py
+bat_core/models/flow.py
+batautomate.egg-info/PKG-INFO
+batautomate.egg-info/SOURCES.txt
+batautomate.egg-info/dependency_links.txt
+batautomate.egg-info/entry_points.txt
+batautomate.egg-info/requires.txt
+batautomate.egg-info/top_level.txt
+tests/test_engine.py

batautomate-0.1.0/batautomate.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

batautomate-0.1.0/batautomate.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+bat-core = bat_core.cli:main

batautomate-0.1.0/batautomate.egg-info/requires.txt

@@ -0,0 +1,8 @@
+pydantic>=2.0.0
+playwright>=1.40.0
+pandas>=2.0.0
+openpyxl>=3.1.0
+requests>=2.28.0
+
+[dev]
+pytest>=7.0.0

batautomate-0.1.0/batautomate.egg-info/top_level.txt

@@ -0,0 +1 @@
+bat_core

batautomate-0.1.0/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "batautomate"
+version = "0.1.0"
+description = "Core execution engine and standard action libraries for BAT Automate RPA platform"
+readme = {file = "README.md", content-type = "text/markdown"}
+requires-python = ">=3.10"
+dependencies = [
+    "pydantic>=2.0.0",
+    "playwright>=1.40.0",
+    "pandas>=2.0.0",
+    "openpyxl>=3.1.0",
+    "requests>=2.28.0"
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0.0"
+]
+
+[project.scripts]
+bat-core = "bat_core.cli:main"

batautomate-0.1.0/setup.cfg

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

batautomate-0.1.0/tests/test_engine.py

@@ -0,0 +1,54 @@
+import json
+from pathlib import Path
+import pytest
+from bat_core.models.flow import FlowDefinition, Step
+from bat_core.engine.interpreter import FlowInterpreter
+from bat_core.engine.evaluator import VariableEvaluator
+
+
+def test_variable_evaluator():
+    vars_ctx = {"name": "BAT", "details": {"version": "1.0"}}
+    val = VariableEvaluator.evaluate_value("Hello ${name} v${details.version}", vars_ctx)
+    assert val == "Hello BAT v1.0"
+
+
+def test_interpreter_basic_run():
+    flow = FlowDefinition(
+        name="Test Flow",
+        variables={"msg": "hello"},
+        steps=[
+            Step(
+                id="s1",
+                name="Set Variable",
+                action="logic.set_variable",
+                parameters={"name": "res", "value": "${msg}_world"},
+                output_var="res"
+            )
+        ]
+    )
+
+    interpreter = FlowInterpreter()
+    ctx = interpreter.run_flow(flow)
+
+    assert ctx.is_completed is True
+    assert ctx.has_error is False
+    assert ctx.get_variable("res") == "hello_world"
+    assert len(ctx.step_results) == 1
+    assert ctx.step_results[0].status == "success"
+
+
+def test_interpreter_load_sample_flow_json():
+    json_path = Path(__file__).parent.parent / "examples" / "sample_flow.json"
+    assert json_path.exists()
+
+    content = json_path.read_text(encoding="utf-8")
+    raw_json = json.loads(content)
+    flow_def = FlowDefinition.model_validate(raw_json)
+
+    interpreter = FlowInterpreter()
+    ctx = interpreter.run_flow(flow_def)
+
+    assert ctx.is_completed is True
+    assert ctx.has_error is False
+    assert len(ctx.step_results) == 3
+