clerk-sdk 0.4.14__tar.gz → 0.4.16__tar.gz

{clerk_sdk-0.4.14/clerk_sdk.egg-info → clerk_sdk-0.4.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clerk-sdk
-Version: 0.4.14
+Version: 0.4.16
 Summary: Library for interacting with Clerk
 Home-page: https://github.com/F-ONE-Group/clerk_pypi
 Author: F-ONE Group

{clerk_sdk-0.4.14 → clerk_sdk-0.4.16}/clerk/__init__.py

@@ -1,4 +1,4 @@
 from .client import Clerk
 
 
-__version__ = "0.4.14"
+__version__ = "0.4.16"

{clerk_sdk-0.4.14 → clerk_sdk-0.4.16}/clerk/base.py

@@ -50,7 +50,7 @@ class BaseClerk(BaseModel):
         headers: Dict[str, str] = {},
         json: Dict[str, Any] = {},
         params: Dict[str, Any] = {},
-    ) -> StandardResponse[Dict[str, Any]]:
+    ) -> StandardResponse[Any]:
 
         merged_headers = {**self.headers, **headers}
         url = f"{self.base_url}{endpoint}"

{clerk_sdk-0.4.14 → clerk_sdk-0.4.16}/clerk/gui_automation/client.py

@@ -40,6 +40,11 @@ class RPAClerk(BaseClerk):
             json={"id": remote_device.id, "name": remote_device.name, "run_id": run_id},
         )
 
+    def get_wss_token(self) -> str:
+        endpoint = "/wss_token"
+        res = self.get_request(endpoint=endpoint)
+        return res.data[0]
+
     def get_coordinates(self, payload: Dict[str, Any]) -> Coords:
         endpoint = "/action_model/get_coordinates"
         try:

{clerk_sdk-0.4.14 → clerk_sdk-0.4.16}/clerk/gui_automation/client_actor/client_actor.py

@@ -1,12 +1,14 @@
 import asyncio
 import json
 import os
+import backoff
 from typing import Any, Dict, Union
 
+
 import pydantic
 import requests
 
-
+from websockets import WebSocketException
 from .model import (
     ExecutePayload,
     DeleteFilesExecutePayload,
@@ -15,12 +17,24 @@ from .model import (
     WindowExecutePayload,
     GetFileExecutePayload,
 )
-import backoff
 
 from .model import PerformActionResponse, ActionStates
 from .exception import PerformActionException, GetScreenError
 
 
+async def before_retry(details: Any):
+    from ..decorators.gui_automation import reconnect_ws
+
+    await reconnect_ws()
+
+
+@backoff.on_exception(
+    backoff.constant,
+    WebSocketException,
+    interval=1,
+    max_tries=5,
+    on_backoff=before_retry,
+)
 async def _perform_action_ws(payload: Dict[str, Any]) -> PerformActionResponse:
     """Perform an action over a WebSocket connection.
 
@@ -48,6 +62,8 @@ async def _perform_action_ws(payload: Dict[str, Any]) -> PerformActionResponse:
                 return PerformActionResponse(**json.loads(action_info))
             else:
                 raise RuntimeError("Received ACK != OK")
+        except WebSocketException as e:
+            raise e
         except asyncio.TimeoutError:
             raise RuntimeError("The ack message did not arrive.")
     else:

clerk_sdk-0.4.16/clerk/gui_automation/decorators/gui_automation.py

@@ -0,0 +1,113 @@
+import asyncio
+import functools
+import os
+import time
+from typing import Any, Callable, Dict, Sequence, Union
+
+from websockets.asyncio.client import connect, ClientConnection
+from websockets.protocol import State
+
+from clerk.gui_automation.client import RPAClerk
+from clerk.gui_automation.exceptions.agent_manager import (
+    ClientAvailabilityTimeout,
+    NoClientsAvailable,
+)
+from clerk.models.remote_device import RemoteDevice
+from clerk.decorator.models import ClerkCodePayload
+from clerk.utils import logger
+from ..exceptions.websocket import WebSocketConnectionFailed
+
+
+# Global handle to the live connection (if any)
+global_ws: Union[ClientConnection, None] = None
+
+clerk_client = RPAClerk()
+wss_uri = "wss://agent-manager.f-one.group/action"
+
+
+async def connect_to_ws(uri: str) -> ClientConnection:
+    # Same knobs as before, just via the new connect()
+    return await connect(uri, max_size=2**23, ping_timeout=3600)
+
+
+async def close_ws_connection(ws_conn: ClientConnection):
+    await ws_conn.close()
+
+
+async def reconnect_ws():
+    global global_ws
+
+    remote_device_name = os.getenv("REMOTE_DEVICE_NAME")
+    if not remote_device_name:
+        raise RuntimeError(
+            "REMOTE_DEVICE_NAME environmental variable is required for reconnecting WebSocket."
+        )
+    wss_token = clerk_client.get_wss_token()
+    uri = f"{wss_uri}/{remote_device_name}/publisher?token={wss_token}"
+    global_ws = await connect_to_ws(uri)
+
+
+def gui_automation():
+    """
+    Decorator that:
+      • Allocates a remote device,
+      • Opens a WebSocket to the agent manager,
+      • Passes control to the wrapped function,
+      • Cleans everything up afterwards.
+    """
+    remote_device_name: str | None = os.getenv("REMOTE_DEVICE_NAME")
+
+    if not remote_device_name:
+        raise ValueError("REMOTE_DEVICE_NAME environmental variable is required.")
+
+    wss_token = clerk_client.get_wss_token()
+
+    def decorator(func: Callable):
+        @functools.wraps(func)
+        def wrapper(
+            payload: ClerkCodePayload, *args: Sequence[Any], **kwargs: Dict[str, Any]
+        ):
+            global global_ws
+
+            os.environ["_document_id"] = payload.document.id
+            os.environ["_run_id"] = payload.run_id or ""
+
+            # Create a dedicated loop for the WebSocket work
+            event_loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(event_loop)
+
+            try:
+                task = event_loop.create_task(
+                    connect_to_ws(
+                        f"{wss_uri}/{remote_device_name}/publisher"
+                        f"?token={wss_token}"
+                    )
+                )
+                global_ws = event_loop.run_until_complete(task)
+
+                if global_ws and global_ws.state is State.OPEN:
+                    logger.debug("WebSocket connection established.")
+                    func_ret = func(payload, *args, **kwargs)
+                else:
+                    global_ws = None
+                    raise WebSocketConnectionFailed()
+
+            except Exception:
+                raise
+            finally:
+                os.environ.pop("_run_id", None)
+                os.environ.pop("_document_id", None)
+
+                if global_ws and global_ws.state is State.OPEN:
+                    close_task = event_loop.create_task(close_ws_connection(global_ws))
+                    event_loop.run_until_complete(close_task)
+                    logger.debug("WebSocket connection closed.")
+
+                event_loop.run_until_complete(event_loop.shutdown_asyncgens())
+                event_loop.close()
+
+            return func_ret
+
+        return wrapper
+
+    return decorator

{clerk_sdk-0.4.14 → clerk_sdk-0.4.16/clerk_sdk.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clerk-sdk
-Version: 0.4.14
+Version: 0.4.16
 Summary: Library for interacting with Clerk
 Home-page: https://github.com/F-ONE-Group/clerk_pypi
 Author: F-ONE Group

{clerk_sdk-0.4.14 → clerk_sdk-0.4.16}/setup.py

@@ -13,7 +13,7 @@ gui_requirements = get_requirements("./clerk/gui_automation")
 
 setup(
     name="clerk-sdk",
-    version="0.4.14",
+    version="0.4.16",
     description="Library for interacting with Clerk",
     long_description=open("README.md").read(),
     long_description_content_type="text/markdown",

clerk_sdk-0.4.14/clerk/gui_automation/decorators/gui_automation.py

@@ -1,150 +0,0 @@
-import asyncio
-import functools
-import os
-import time
-from typing import Callable, Union
-
-from websockets.asyncio.client import connect, ClientConnection
-from websockets.protocol import State
-
-from clerk.gui_automation.client import RPAClerk
-from clerk.gui_automation.exceptions.agent_manager import (
-    ClientAvailabilityTimeout,
-    NoClientsAvailable,
-)
-from clerk.models.remote_device import RemoteDevice
-from clerk.decorator.models import ClerkCodePayload
-from clerk.utils import logger
-from ..exceptions.websocket import WebSocketConnectionFailed
-
-
-# Global handle to the live connection (if any)
-global_ws: Union[ClientConnection, None] = None
-
-clerk_client = RPAClerk()
-wss_uri = "wss://agent-manager.f-one.group/action"
-
-REMOTE_DEVICE_ALLOCATION_TIMEOUT = int(
-    os.getenv("REMOTE_DEVICE_ALLOCATION_TIMEOUT", 60)
-)
-REMOTE_DEVICE_ALLOCATION_MAX_TRIES = int(
-    os.getenv("REMOTE_DEVICE_ALLOCATION_MAX_TRIES", 60)
-)
-
-
-def _allocate_remote_device(
-    clerk_client: RPAClerk, group_name: str, run_id: str
-) -> RemoteDevice:
-    remote_device = None
-    retries = 0
-
-    while True:
-        try:
-            remote_device = clerk_client.allocate_remote_device(
-                group_name=group_name, run_id=run_id
-            )
-            os.environ["REMOTE_DEVICE_ID"] = remote_device.id
-            os.environ["REMOTE_DEVICE_NAME"] = remote_device.name
-            logger.debug(f"Remote device allocated: {remote_device.name}")
-            return remote_device
-
-        except NoClientsAvailable:
-            logger.warning(
-                f"No clients are available for {group_name} group. Initiating a {REMOTE_DEVICE_ALLOCATION_TIMEOUT} seconds wait. Retry count: {retries}"
-            )
-            if retries >= REMOTE_DEVICE_ALLOCATION_MAX_TRIES:
-                raise ClientAvailabilityTimeout(
-                    f"No clients available for {group_name} group after {REMOTE_DEVICE_ALLOCATION_TIMEOUT * REMOTE_DEVICE_ALLOCATION_MAX_TRIES} seconds"
-                )
-            time.sleep(REMOTE_DEVICE_ALLOCATION_TIMEOUT)
-            retries += 1
-
-
-def _deallocate_target(
-    clerk_client: RPAClerk, remote_device: RemoteDevice, run_id: str
-):
-    clerk_client.deallocate_remote_device(remote_device=remote_device, run_id=run_id)
-    logger.debug("Remote device deallocated")
-    os.environ.pop("REMOTE_DEVICE_ID", None)
-    os.environ.pop("REMOTE_DEVICE_NAME", None)
-
-
-def gui_automation(
-    reserve_client: bool = False,
-):
-    """
-    Decorator that:
-      • Allocates a remote device,
-      • Opens a WebSocket to the agent manager,
-      • Passes control to the wrapped function,
-      • Cleans everything up afterwards.
-    """
-    group_name: str | None = os.getenv("REMOTE_DEVICE_GROUP")
-    if not group_name:
-        raise ValueError("REMOTE_DEVICE_GROUP environmental variable is required.")
-
-    async def connect_to_ws(uri: str) -> ClientConnection:
-        # Same knobs as before, just via the new connect()
-        return await connect(uri, max_size=2**23, ping_timeout=3600)
-
-    async def close_ws_connection(ws_conn: ClientConnection):
-        await ws_conn.close()
-
-    def decorator(func: Callable):
-        @functools.wraps(func)
-        def wrapper(payload: ClerkCodePayload, *args, **kwargs):
-            global global_ws
-            force_deallocate = False
-            os.environ["_document_id"] = payload.document.id
-            os.environ["_run_id"] = payload.run_id
-
-            remote_device = _allocate_remote_device(
-                clerk_client, group_name, payload.run_id
-            )
-
-            # Create a dedicated loop for the WebSocket work
-            event_loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(event_loop)
-
-            try:
-                task = event_loop.create_task(
-                    connect_to_ws(
-                        f"{wss_uri}/{remote_device.name}/publisher"
-                        f"?token={remote_device.wss_token}"
-                    )
-                )
-                global_ws = event_loop.run_until_complete(task)
-
-                if global_ws and global_ws.state is State.OPEN:
-                    logger.debug("WebSocket connection established.")
-                    func_ret = func(payload, *args, **kwargs)
-                else:
-                    global_ws = None
-                    raise WebSocketConnectionFailed()
-
-            except Exception as e:
-                force_deallocate = True
-                raise
-            finally:
-                os.environ.pop("_run_id", None)
-                os.environ.pop("_document_id", None)
-                if not reserve_client or force_deallocate:
-                    _deallocate_target(clerk_client, remote_device, payload.run_id)
-                else:
-                    logger.warning(
-                        f"The client stayed reserved for the this run id: {payload.run_id}"
-                    )
-
-                if global_ws and global_ws.state is State.OPEN:
-                    close_task = event_loop.create_task(close_ws_connection(global_ws))
-                    event_loop.run_until_complete(close_task)
-                    logger.debug("WebSocket connection closed.")
-
-                event_loop.run_until_complete(event_loop.shutdown_asyncgens())
-                event_loop.close()
-
-            return func_ret
-
-        return wrapper
-
-    return decorator