unrealon 1.0.9__py3-none-any.whl → 1.1.1__py3-none-any.whl

unrealon_bridge/client/proxy.py

@@ -0,0 +1,70 @@
+"""
+Proxy management for Parser Bridge Client.
+"""
+
+from typing import Optional
+from unrealon_rpc.logging import get_logger
+
+from ..models import (
+    ProxyInfo, ProxyAllocateRequest, ProxyAllocateResponse,
+    ProxyReleaseRequest, ProxyReleaseResponse
+)
+
+logger = get_logger(__name__)
+
+
+class ProxyMixin:
+    """Mixin for proxy management functionality."""
+
+    async def request_proxy(self, proxy_type: str = "http", location: Optional[str] = None) -> ProxyInfo:
+        """
+        Request proxy allocation.
+
+        Args:
+            proxy_type: Type of proxy needed
+            location: Preferred proxy location
+
+        Returns:
+            Allocated proxy information
+        """
+        self._ensure_registered()
+
+        request = ProxyAllocateRequest(
+            parser_id=self.parser_id,
+            proxy_type=proxy_type,
+            location=location
+        )
+
+        result = await self.bridge_client.call_rpc(
+            method="proxy.allocate", 
+            params=request.model_dump()
+        )
+
+        response = ProxyAllocateResponse.model_validate(result)
+        
+        if response.success and response.proxy:
+            logger.info(f"Proxy allocated: {response.proxy.proxy_id} for {self.parser_id}")
+            return response.proxy
+        else:
+            raise RuntimeError(f"Proxy allocation failed: {response.error}")
+
+    async def release_proxy(self, proxy_id: str) -> None:
+        """
+        Release proxy allocation.
+
+        Args:
+            proxy_id: Proxy ID to release
+        """
+        request = ProxyReleaseRequest(proxy_id=proxy_id)
+        
+        result = await self.bridge_client.call_rpc(
+            method="proxy.release", 
+            params=request.model_dump()
+        )
+
+        response = ProxyReleaseResponse.model_validate(result)
+        
+        if response.success:
+            logger.info(f"Proxy released: {proxy_id}")
+        else:
+            logger.error(f"Proxy release failed: {response.error}")

unrealon_bridge/client/scheduler.py

@@ -0,0 +1,450 @@
+"""
+Scheduler client mixin for Parser Bridge Client.
+
+Provides scheduler-related functionality for parsers.
+"""
+
+from typing import Dict, Any, List, Optional
+from datetime import datetime
+
+from unrealon_rpc.logging import get_logger
+from unrealon_bridge.models.scheduler import (
+    ScheduledTask,
+    TaskParameters,
+    CronExpression,
+    TaskRetryConfig,
+    TaskExecutionResult,
+    ParserStatus,
+    SchedulerError,
+)
+
+logger = get_logger(__name__)
+
+
+class SchedulerMixin:
+    """Scheduler functionality mixin for Parser Bridge Client."""
+
+    async def create_scheduled_task(
+        self,
+        task_type: str,
+        parameters: TaskParameters,
+        cron_expression: Optional[str] = None,
+        scheduled_at: Optional[datetime] = None,
+        retry_config: Optional[TaskRetryConfig] = None,
+        priority: int = 5,
+        timeout_seconds: int = 300
+    ) -> Dict[str, Any]:
+        """
+        Create a new scheduled task.
+        
+        Args:
+            task_type: Type of task (command, scrape, parse, etc.)
+            parameters: Task parameters
+            cron_expression: Optional cron expression for recurring tasks
+            scheduled_at: Optional specific execution time
+            retry_config: Optional retry configuration
+            priority: Task priority (1-10, higher = more important)
+            timeout_seconds: Task timeout in seconds
+            
+        Returns:
+            Task creation response with task_id and scheduling info
+        """
+        try:
+            request_data = {
+                "parser_id": self.parser_id,
+                "task_type": task_type,
+                "parameters": parameters.model_dump(),
+                "priority": priority,
+                "timeout_seconds": timeout_seconds
+            }
+            
+            if cron_expression:
+                request_data["cron_expression"] = cron_expression
+            
+            if scheduled_at:
+                request_data["scheduled_at"] = scheduled_at.isoformat()
+            
+            if retry_config:
+                request_data["retry_config"] = retry_config.model_dump()
+            
+            response = await self.bridge_client.call_rpc(
+                method="scheduler.create_task",
+                params=request_data,
+                timeout=30
+            )
+            
+            logger.info(
+                f"Created scheduled task: {task_type}",
+                component="scheduler_client",
+                operation="create_task",
+                parser_id=self.parser_id,
+                task_type=task_type,
+                cron_expression=cron_expression
+            )
+            
+            return response
+            
+        except Exception as e:
+            logger.error(
+                f"Failed to create scheduled task: {e}",
+                component="scheduler_client",
+                operation="create_task",
+                error=e
+            )
+            raise SchedulerError(f"Failed to create scheduled task: {e}")
+
+    async def list_scheduled_tasks(
+        self,
+        task_type: Optional[str] = None,
+        status: Optional[str] = None,
+        limit: int = 100,
+        offset: int = 0
+    ) -> Dict[str, Any]:
+        """
+        List scheduled tasks for this parser.
+        
+        Args:
+            task_type: Optional filter by task type
+            status: Optional filter by status
+            limit: Maximum number of tasks to return
+            offset: Offset for pagination
+            
+        Returns:
+            List of scheduled tasks
+        """
+        try:
+            request_data = {
+                "parser_id": self.parser_id,
+                "limit": limit,
+                "offset": offset
+            }
+            
+            if task_type:
+                request_data["task_type"] = task_type
+            
+            if status:
+                request_data["status"] = status
+            
+            response = await self.bridge_client.call_rpc(
+                method="scheduler.list_tasks",
+                params=request_data,
+                timeout=30
+            )
+            
+            logger.info(
+                f"Listed scheduled tasks: {response.get('total_count', 0)} total",
+                component="scheduler_client",
+                operation="list_tasks",
+                parser_id=self.parser_id,
+                task_type=task_type,
+                status=status
+            )
+            
+            return response
+            
+        except Exception as e:
+            logger.error(
+                f"Failed to list scheduled tasks: {e}",
+                component="scheduler_client",
+                operation="list_tasks",
+                error=e
+            )
+            raise SchedulerError(f"Failed to list scheduled tasks: {e}")
+
+    async def get_task_status(self, task_id: str) -> Dict[str, Any]:
+        """
+        Get task status and execution history.
+        
+        Args:
+            task_id: Task ID to query
+            
+        Returns:
+            Task status and execution history
+        """
+        try:
+            response = await self.bridge_client.call_rpc(
+                method="scheduler.get_task",
+                params={"task_id": task_id},
+                timeout=30
+            )
+            
+            logger.info(
+                f"Retrieved task status: {task_id}",
+                component="scheduler_client",
+                operation="get_task",
+                task_id=task_id
+            )
+            
+            return response
+            
+        except Exception as e:
+            logger.error(
+                f"Failed to get task status: {e}",
+                component="scheduler_client",
+                operation="get_task",
+                error=e
+            )
+            raise SchedulerError(f"Failed to get task status: {e}")
+
+    async def cancel_scheduled_task(self, task_id: str) -> Dict[str, Any]:
+        """
+        Cancel a scheduled task.
+        
+        Args:
+            task_id: Task ID to cancel
+            
+        Returns:
+            Cancellation response
+        """
+        try:
+            response = await self.bridge_client.call_rpc(
+                method="scheduler.cancel_task",
+                params={"task_id": task_id},
+                timeout=30
+            )
+            
+            logger.info(
+                f"Cancelled scheduled task: {task_id}",
+                component="scheduler_client",
+                operation="cancel_task",
+                task_id=task_id
+            )
+            
+            return response
+            
+        except Exception as e:
+            logger.error(
+                f"Failed to cancel scheduled task: {e}",
+                component="scheduler_client",
+                operation="cancel_task",
+                error=e
+            )
+            raise SchedulerError(f"Failed to cancel scheduled task: {e}")
+
+    async def update_parser_status_for_scheduler(
+        self,
+        status: str,
+        current_task_id: Optional[str] = None,
+        capabilities: Optional[List[str]] = None
+    ) -> Dict[str, Any]:
+        """
+        Update parser status for scheduler.
+        
+        Args:
+            status: Parser status (online, offline, busy, error)
+            current_task_id: Currently executing task ID
+            capabilities: Parser capabilities
+            
+        Returns:
+            Status update response
+        """
+        try:
+            request_data = {
+                "parser_id": self.parser_id,
+                "status": status,
+                "last_seen": datetime.utcnow().isoformat()
+            }
+            
+            if current_task_id:
+                request_data["current_task_id"] = current_task_id
+            
+            if capabilities:
+                request_data["capabilities"] = capabilities
+            
+            response = await self.bridge_client.call_rpc(
+                method="scheduler.update_parser_status",
+                params=request_data,
+                timeout=30
+            )
+            
+            logger.info(
+                f"Updated parser status for scheduler: {status}",
+                component="scheduler_client",
+                operation="update_parser_status",
+                parser_id=self.parser_id,
+                status=status
+            )
+            
+            return response
+            
+        except Exception as e:
+            logger.error(
+                f"Failed to update parser status: {e}",
+                component="scheduler_client",
+                operation="update_parser_status",
+                error=e
+            )
+            raise SchedulerError(f"Failed to update parser status: {e}")
+
+    async def get_parser_scheduler_status(self) -> Dict[str, Any]:
+        """
+        Get parser status and active tasks from scheduler.
+        
+        Returns:
+            Parser status and active tasks
+        """
+        try:
+            response = await self.bridge_client.call_rpc(
+                method="scheduler.get_parser_status",
+                params={"parser_id": self.parser_id},
+                timeout=30
+            )
+            
+            logger.info(
+                f"Retrieved parser scheduler status",
+                component="scheduler_client",
+                operation="get_parser_status",
+                parser_id=self.parser_id
+            )
+            
+            return response
+            
+        except Exception as e:
+            logger.error(
+                f"Failed to get parser scheduler status: {e}",
+                component="scheduler_client",
+                operation="get_parser_status",
+                error=e
+            )
+            raise SchedulerError(f"Failed to get parser scheduler status: {e}")
+
+    async def get_scheduler_stats(self) -> Dict[str, Any]:
+        """
+        Get scheduler statistics.
+        
+        Returns:
+            Scheduler statistics
+        """
+        try:
+            response = await self.bridge_client.call_rpc(
+                method="scheduler.get_stats",
+                params={},
+                timeout=30
+            )
+            
+            logger.info(
+                "Retrieved scheduler statistics",
+                component="scheduler_client",
+                operation="get_stats"
+            )
+            
+            return response
+            
+        except Exception as e:
+            logger.error(
+                f"Failed to get scheduler stats: {e}",
+                component="scheduler_client",
+                operation="get_stats",
+                error=e
+            )
+            raise SchedulerError(f"Failed to get scheduler stats: {e}")
+
+    # Convenience methods for common task types
+    
+    async def schedule_scraping_task(
+        self,
+        target_url: str,
+        scraping_config: Dict[str, Any],
+        cron_expression: Optional[str] = None,
+        scheduled_at: Optional[datetime] = None,
+        priority: int = 5
+    ) -> Dict[str, Any]:
+        """
+        Schedule a scraping task.
+        
+        Args:
+            target_url: URL to scrape
+            scraping_config: Scraping configuration
+            cron_expression: Optional cron expression for recurring scraping
+            scheduled_at: Optional specific execution time
+            priority: Task priority
+            
+        Returns:
+            Task creation response
+        """
+        parameters = TaskParameters(
+            command_type="scrape",
+            parameters={
+                "target_url": target_url,
+                **{k: str(v) for k, v in scraping_config.items()}
+            }
+        )
+        
+        return await self.create_scheduled_task(
+            task_type="scrape",
+            parameters=parameters,
+            cron_expression=cron_expression,
+            scheduled_at=scheduled_at,
+            priority=priority
+        )
+
+    async def schedule_parsing_task(
+        self,
+        input_data: str,
+        parsing_config: Dict[str, Any],
+        cron_expression: Optional[str] = None,
+        scheduled_at: Optional[datetime] = None,
+        priority: int = 5
+    ) -> Dict[str, Any]:
+        """
+        Schedule a parsing task.
+        
+        Args:
+            input_data: Data to parse
+            parsing_config: Parsing configuration
+            cron_expression: Optional cron expression for recurring parsing
+            scheduled_at: Optional specific execution time
+            priority: Task priority
+            
+        Returns:
+            Task creation response
+        """
+        parameters = TaskParameters(
+            command_type="parse",
+            parameters={
+                "input_data": input_data,
+                **{k: str(v) for k, v in parsing_config.items()}
+            }
+        )
+        
+        return await self.create_scheduled_task(
+            task_type="parse",
+            parameters=parameters,
+            cron_expression=cron_expression,
+            scheduled_at=scheduled_at,
+            priority=priority
+        )
+
+    async def schedule_command_task(
+        self,
+        command_type: str,
+        command_params: Dict[str, Any],
+        cron_expression: Optional[str] = None,
+        scheduled_at: Optional[datetime] = None,
+        priority: int = 5
+    ) -> Dict[str, Any]:
+        """
+        Schedule a command execution task.
+        
+        Args:
+            command_type: Type of command to execute
+            command_params: Command parameters
+            cron_expression: Optional cron expression for recurring commands
+            scheduled_at: Optional specific execution time
+            priority: Task priority
+            
+        Returns:
+            Task creation response
+        """
+        parameters = TaskParameters(
+            command_type=command_type,
+            parameters={k: str(v) for k, v in command_params.items()}
+        )
+        
+        return await self.create_scheduled_task(
+            task_type="command",
+            parameters=parameters,
+            cron_expression=cron_expression,
+            scheduled_at=scheduled_at,
+            priority=priority
+        )

unrealon_bridge/client/session.py

@@ -0,0 +1,70 @@
+"""
+Session management for Parser Bridge Client.
+"""
+
+from typing import Optional
+from unrealon_rpc.logging import get_logger
+
+from ..models import (
+    SessionStartRequest, SessionStartResponse,
+    SessionEndRequest, SessionEndResponse
+)
+
+logger = get_logger(__name__)
+
+
+class SessionMixin:
+    """Mixin for session management functionality."""
+
+    async def start_session(self, session_type: str = "default", metadata: Optional[dict[str, str]] = None) -> str:
+        """
+        Start a new parser session.
+
+        Args:
+            session_type: Type of session
+            metadata: Session metadata
+
+        Returns:
+            Session ID
+        """
+        self._ensure_registered()
+
+        request = SessionStartRequest(
+            parser_id=self.parser_id,
+            session_type=session_type,
+            metadata=metadata
+        )
+
+        result = await self.bridge_client.call_rpc(
+            method="parser.start_session", 
+            params=request.model_dump()
+        )
+
+        response = SessionStartResponse.model_validate(result)
+        
+        if response.success and response.session:
+            self.session_id = response.session.session_id
+            logger.info(f"Session started: {self.session_id}")
+            return self.session_id
+        else:
+            raise RuntimeError(f"Session start failed: {response.error}")
+
+    async def end_session(self) -> None:
+        """End current parser session."""
+        if not self.session_id:
+            return
+
+        request = SessionEndRequest(session_id=self.session_id)
+
+        result = await self.bridge_client.call_rpc(
+            method="parser.end_session", 
+            params=request.model_dump()
+        )
+
+        response = SessionEndResponse.model_validate(result)
+        
+        if response.success:
+            logger.info(f"Session ended: {self.session_id}")
+            self.session_id = None
+        else:
+            logger.error(f"Session end failed: {response.error}")

unrealon_bridge/configs/__init__.py

@@ -0,0 +1,14 @@
+"""
+Bridge configuration module.
+
+Provides Pydantic2 configuration management for the bridge server.
+"""
+
+from .bridge_config import BridgeConfig, load_bridge_config, save_bridge_config, create_sample_config
+
+__all__ = [
+    "BridgeConfig",
+    "load_bridge_config", 
+    "save_bridge_config",
+    "create_sample_config"
+]