rpaforge-core 0.3.6__tar.gz

rpaforge_core-0.3.6/PKG-INFO

@@ -0,0 +1,90 @@
+Metadata-Version: 2.4
+Name: rpaforge-core
+Version: 0.3.6
+Summary: Native Python execution engine
+Author: RPAForge Contributors
+License: Apache-2.0
+Project-URL: Homepage, https://github.com/chelslava/rpaforge
+Project-URL: Repository, https://github.com/chelslava/rpaforge.git
+Project-URL: Issues, https://github.com/chelslava/rpaforge/issues
+Keywords: rpa,automation,debugger,execution-engine
+Classifier: Development Status :: 3 - Alpha
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: psutil>=5.9.0
+Provides-Extra: subprocess
+Requires-Dist: psutil>=5.9; extra == "subprocess"
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0; extra == "dev"
+Requires-Dist: ruff>=0.15.0; extra == "dev"
+Requires-Dist: mypy>=1.0; extra == "dev"
+Requires-Dist: psutil>=5.9; extra == "dev"
+
+[🇷🇺 Русский](README.ru.md)
+
+# RPAForge Core
+
+[![PyPI version](https://badge.fury.io/py/rpaforge-core.svg)](https://badge.fury.io/py/rpaforge-core)
+[![Python Support](https://img.shields.io/pypi/pyversions/rpaforge-core.svg)](https://pypi.org/project/rpaforge-core/)
+[![License](https://img.shields.io/github/license/chelslava/rpaforge)](LICENSE)
+
+Core engine for RPAForge — native Python execution with full debugging, recording, and IPC bridge capabilities.
+
+## Installation
+
+```bash
+pip install rpaforge-core
+```
+
+## Usage
+
+```python
+from rpaforge import StudioEngine
+from rpaforge_libraries.DesktopUI import DesktopUI
+
+engine = StudioEngine()
+engine.executor.register_library("DesktopUI", DesktopUI())
+
+builder = engine.create_process("Notepad Automation")
+builder.add_task("Open and Type", [
+    ("DesktopUI.Open Application", {"executable": "notepad.exe"}),
+    ("DesktopUI.Wait For Window",  {"title": "Notepad", "timeout": "10s"}),
+    ("DesktopUI.Input Text",       {"text": "Hello from RPAForge!"}),
+    ("DesktopUI.Close Window",     {}),
+])
+
+result = engine.run(builder.build())
+print(f"Status: {result.status}")
+```
+
+## Features
+
+- **Engine**: Native Python execution with topology validation and code generation
+- **Debugger**: Breakpoints, step over/into/out, variable inspection, call stack
+- **Recorder**: Record user actions to automation diagrams
+- **IPC Bridge**: Asyncio JSON-RPC server for Electron ↔ Python communication
+
+## Development
+
+```bash
+# Install in development mode
+pip install -e .
+
+# Run tests
+pytest tests/ -v
+
+# Format code
+ruff format src/
+```
+
+## License
+
+Apache License 2.0

rpaforge_core-0.3.6/README.md

@@ -0,0 +1,60 @@
+[🇷🇺 Русский](README.ru.md)
+
+# RPAForge Core
+
+[![PyPI version](https://badge.fury.io/py/rpaforge-core.svg)](https://badge.fury.io/py/rpaforge-core)
+[![Python Support](https://img.shields.io/pypi/pyversions/rpaforge-core.svg)](https://pypi.org/project/rpaforge-core/)
+[![License](https://img.shields.io/github/license/chelslava/rpaforge)](LICENSE)
+
+Core engine for RPAForge — native Python execution with full debugging, recording, and IPC bridge capabilities.
+
+## Installation
+
+```bash
+pip install rpaforge-core
+```
+
+## Usage
+
+```python
+from rpaforge import StudioEngine
+from rpaforge_libraries.DesktopUI import DesktopUI
+
+engine = StudioEngine()
+engine.executor.register_library("DesktopUI", DesktopUI())
+
+builder = engine.create_process("Notepad Automation")
+builder.add_task("Open and Type", [
+    ("DesktopUI.Open Application", {"executable": "notepad.exe"}),
+    ("DesktopUI.Wait For Window",  {"title": "Notepad", "timeout": "10s"}),
+    ("DesktopUI.Input Text",       {"text": "Hello from RPAForge!"}),
+    ("DesktopUI.Close Window",     {}),
+])
+
+result = engine.run(builder.build())
+print(f"Status: {result.status}")
+```
+
+## Features
+
+- **Engine**: Native Python execution with topology validation and code generation
+- **Debugger**: Breakpoints, step over/into/out, variable inspection, call stack
+- **Recorder**: Record user actions to automation diagrams
+- **IPC Bridge**: Asyncio JSON-RPC server for Electron ↔ Python communication
+
+## Development
+
+```bash
+# Install in development mode
+pip install -e .
+
+# Run tests
+pytest tests/ -v
+
+# Format code
+ruff format src/
+```
+
+## License
+
+Apache License 2.0

rpaforge_core-0.3.6/pyproject.toml

@@ -0,0 +1,53 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "rpaforge-core"
+version = "0.3.6"
+description = "Native Python execution engine"
+readme = "README.md"
+license = {text = "Apache-2.0"}
+requires-python = ">=3.10"
+authors = [
+    {name = "RPAForge Contributors"}
+]
+keywords = [
+    "rpa",
+    "automation",
+    "debugger",
+    "execution-engine",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "License :: OSI Approved :: Apache Software License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Typing :: Typed",
+]
+dependencies = [
+    "psutil>=5.9.0",
+]
+
+[project.optional-dependencies]
+subprocess = [
+    "psutil>=5.9",
+]
+dev = [
+    "pytest>=8.0",
+    "pytest-cov>=4.0",
+    "ruff>=0.15.0",
+    "mypy>=1.0",
+    "psutil>=5.9",
+]
+
+[project.urls]
+Homepage = "https://github.com/chelslava/rpaforge"
+Repository = "https://github.com/chelslava/rpaforge.git"
+Issues = "https://github.com/chelslava/rpaforge/issues"
+
+[tool.setuptools.packages.find]
+where = ["src"]

rpaforge_core-0.3.6/setup.cfg

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

rpaforge_core-0.3.6/src/rpaforge/__init__.py

@@ -0,0 +1,23 @@
+"""
+RPAForge Core - Open Source RPA Studio Engine.
+
+Native Python execution engine without Robot Framework dependencies.
+"""
+
+from rpaforge.bridge import BridgeServer
+from rpaforge.codegen import CodeGenerator
+from rpaforge.core.runner import (
+    Breakpoint,
+    ProcessRunner,
+    RunnerState,
+    StudioEngine,
+)
+
+__all__ = [
+    "StudioEngine",
+    "ProcessRunner",
+    "Breakpoint",
+    "RunnerState",
+    "BridgeServer",
+    "CodeGenerator",
+]

rpaforge_core-0.3.6/src/rpaforge/bridge/__init__.py

@@ -0,0 +1,57 @@
+"""
+RPAForge Bridge Module.
+
+IPC communication between Electron UI and Python Engine.
+"""
+
+from __future__ import annotations
+
+from rpaforge.bridge.events import (
+    BreakpointHitEvent,
+    BridgeEvent,
+    CallStackChangedEvent,
+    ErrorEvent,
+    EventType,
+    KeywordFinishedEvent,
+    KeywordStartedEvent,
+    LogEvent,
+    ProcessFinishedEvent,
+    ProcessPausedEvent,
+    ProcessResumedEvent,
+    ProcessStartedEvent,
+    VariablesChangedEvent,
+)
+from rpaforge.bridge.handlers import BridgeHandlers
+from rpaforge.bridge.protocol import (
+    JSONRPCError,
+    JSONRPCErrorCode,
+    JSONRPCNotification,
+    JSONRPCRequest,
+    JSONRPCResponse,
+    parse_message,
+)
+from rpaforge.bridge.server import BridgeServer
+
+__all__ = [
+    "BridgeServer",
+    "BridgeHandlers",
+    "BridgeEvent",
+    "EventType",
+    "LogEvent",
+    "BreakpointHitEvent",
+    "ProcessStartedEvent",
+    "ProcessFinishedEvent",
+    "ProcessPausedEvent",
+    "ProcessResumedEvent",
+    "VariablesChangedEvent",
+    "CallStackChangedEvent",
+    "KeywordStartedEvent",
+    "KeywordFinishedEvent",
+    "ErrorEvent",
+    "JSONRPCRequest",
+    "JSONRPCResponse",
+    "JSONRPCNotification",
+    "JSONRPCError",
+    "JSONRPCErrorCode",
+    "parse_message",
+]

rpaforge_core-0.3.6/src/rpaforge/bridge/__main__.py

@@ -0,0 +1,8 @@
+"""RPAForge Bridge Server module."""
+
+from rpaforge.bridge.server import main
+
+if __name__ == "__main__":
+    import asyncio
+
+    asyncio.run(main())

rpaforge_core-0.3.6/src/rpaforge/bridge/events.py

@@ -0,0 +1,308 @@
+"""
+RPAForge Bridge Events.
+
+Event types for IPC communication between Python engine and UI.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from enum import Enum
+from typing import Any
+
+
+class EventType(str, Enum):
+    """Types of events that can be emitted."""
+
+    LOG = "log"
+    BREAKPOINT_HIT = "breakpointHit"
+    PROCESS_STARTED = "processStarted"
+    PROCESS_FINISHED = "processFinished"
+    PROCESS_STOPPED = "processStopped"
+    PROCESS_PAUSED = "processPaused"
+    PROCESS_RESUMED = "processResumed"
+    VARIABLES_CHANGED = "variablesChanged"
+    CALL_STACK_CHANGED = "callStackChanged"
+    KEYWORD_STARTED = "keywordStarted"
+    KEYWORD_FINISHED = "keywordFinished"
+    ERROR = "error"
+
+
+@dataclass
+class BridgeEvent:
+    """Base class for bridge events."""
+
+    timestamp: datetime = field(default_factory=datetime.now)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {"type": self.event_type(), "timestamp": self.timestamp.isoformat()}
+
+    @classmethod
+    def event_type(cls) -> str:
+        """Return the event type string."""
+        return "event"
+
+
+@dataclass
+class LogEvent(BridgeEvent):
+    """Event for log messages."""
+
+    level: str = "info"
+    message: str = ""
+    source: str | None = None
+    run_id: str = ""
+
+    @classmethod
+    def event_type(cls) -> str:
+        return EventType.LOG.value
+
+    def to_dict(self) -> dict[str, Any]:
+        result = super().to_dict()
+        result.update(
+            {
+                "level": self.level,
+                "message": self.message,
+                "runId": self.run_id,
+            }
+        )
+        if self.source:
+            result["source"] = self.source
+        return result
+
+
+@dataclass
+class BreakpointHitEvent(BridgeEvent):
+    """Event when a breakpoint is hit."""
+
+    breakpoint_id: str = ""
+    file: str = ""
+    line: int = 0
+    condition: str | None = None
+
+    @classmethod
+    def event_type(cls) -> str:
+        return EventType.BREAKPOINT_HIT.value
+
+    def to_dict(self) -> dict[str, Any]:
+        result = super().to_dict()
+        result.update(
+            {
+                "breakpointId": self.breakpoint_id,
+                "file": self.file,
+                "line": self.line,
+            }
+        )
+        if self.condition:
+            result["condition"] = self.condition
+        return result
+
+
+@dataclass
+class ProcessStartedEvent(BridgeEvent):
+    """Event when a process starts."""
+
+    process_id: str = ""
+    name: str = ""
+    run_id: str = ""
+
+    @classmethod
+    def event_type(cls) -> str:
+        return EventType.PROCESS_STARTED.value
+
+    def to_dict(self) -> dict[str, Any]:
+        result = super().to_dict()
+        result.update(
+            {
+                "processId": self.process_id,
+                "name": self.name,
+                "runId": self.run_id,
+            }
+        )
+        return result
+
+
+@dataclass
+class ProcessFinishedEvent(BridgeEvent):
+    """Event when a process finishes."""
+
+    status: str = "pass"
+    duration: float = 0.0
+    message: str | None = None
+
+    @classmethod
+    def event_type(cls) -> str:
+        return EventType.PROCESS_FINISHED.value
+
+    def to_dict(self) -> dict[str, Any]:
+        result = super().to_dict()
+        result.update(
+            {
+                "status": self.status,
+                "duration": self.duration,
+            }
+        )
+        if self.message:
+            result["message"] = self.message
+        return result
+
+
+@dataclass
+class ProcessStoppedEvent(BridgeEvent):
+    """Event when a process is stopped/cancelled by user."""
+
+    reason: str = "user"
+
+    @classmethod
+    def event_type(cls) -> str:
+        return EventType.PROCESS_STOPPED.value
+
+    def to_dict(self) -> dict[str, Any]:
+        result = super().to_dict()
+        result["reason"] = self.reason
+        return result
+
+
+@dataclass
+class VariablesChangedEvent(BridgeEvent):
+    """Event when variables change."""
+
+    variables: list[dict[str, Any]] = field(default_factory=list)
+
+    @classmethod
+    def event_type(cls) -> str:
+        return EventType.VARIABLES_CHANGED.value
+
+    def to_dict(self) -> dict[str, Any]:
+        result = super().to_dict()
+        result["variables"] = self.variables
+        return result
+
+
+@dataclass
+class CallStackChangedEvent(BridgeEvent):
+    """Event when call stack changes."""
+
+    call_stack: list[dict[str, Any]] = field(default_factory=list)
+
+    @classmethod
+    def event_type(cls) -> str:
+        return EventType.CALL_STACK_CHANGED.value
+
+    def to_dict(self) -> dict[str, Any]:
+        result = super().to_dict()
+        result["callStack"] = self.call_stack
+        return result
+
+
+@dataclass
+class KeywordStartedEvent(BridgeEvent):
+    """Event when a keyword starts."""
+
+    name: str = ""
+    file: str = ""
+    line: int = 0
+    args: list[Any] = field(default_factory=list)
+
+    @classmethod
+    def event_type(cls) -> str:
+        return EventType.KEYWORD_STARTED.value
+
+    def to_dict(self) -> dict[str, Any]:
+        result = super().to_dict()
+        result.update(
+            {
+                "name": self.name,
+                "file": self.file,
+                "line": self.line,
+                "args": self.args,
+            }
+        )
+        return result
+
+
+@dataclass
+class KeywordFinishedEvent(BridgeEvent):
+    """Event when a keyword finishes."""
+
+    name: str = ""
+    status: str = "pass"
+    result: Any | None = None
+
+    @classmethod
+    def event_type(cls) -> str:
+        return EventType.KEYWORD_FINISHED.value
+
+    def to_dict(self) -> dict[str, Any]:
+        result = super().to_dict()
+        result.update(
+            {
+                "name": self.name,
+                "status": self.status,
+            }
+        )
+        if self.result is not None:
+            result["result"] = self.result
+        return result
+
+
+@dataclass
+class ErrorEvent(BridgeEvent):
+    """Event for errors."""
+
+    code: int = 0
+    message: str = ""
+    details: str | None = None
+
+    @classmethod
+    def event_type(cls) -> str:
+        return EventType.ERROR.value
+
+    def to_dict(self) -> dict[str, Any]:
+        result = super().to_dict()
+        result.update(
+            {
+                "code": self.code,
+                "message": self.message,
+            }
+        )
+        if self.details:
+            result["details"] = self.details
+        return result
+
+
+@dataclass
+class ProcessPausedEvent(BridgeEvent):
+    """Event when a process pauses at breakpoint or step."""
+
+    file: str | None = None
+    line: int | None = None
+    node_id: str | None = None
+    reason: str = "breakpoint"
+
+    @classmethod
+    def event_type(cls) -> str:
+        return EventType.PROCESS_PAUSED.value
+
+    def to_dict(self) -> dict[str, Any]:
+        result = super().to_dict()
+        result["reason"] = self.reason
+        if self.file is not None:
+            result["file"] = self.file
+        if self.line is not None:
+            result["line"] = self.line
+        if self.node_id is not None:
+            result["nodeId"] = self.node_id
+        return result
+
+
+@dataclass
+class ProcessResumedEvent(BridgeEvent):
+    """Event when a process resumes from pause."""
+
+    @classmethod
+    def event_type(cls) -> str:
+        return EventType.PROCESS_RESUMED.value
+
+    def to_dict(self) -> dict[str, Any]:
+        return super().to_dict()