PyPI 官网下载 | arkitekt-0.1.22.tar.gz

from herre.auth import get_current_herre from arkitekt.threadvars import get_current_assign from PyQt5.QtCore import QObject, pyqtSignal from arkitekt.messages.postman.assign.assign_cancelled import AssignCancelledMessage from arkitekt.messages.postman.unassign.bounced_forwarded_unassign import BouncedForwardedUnassignMessage from arkitekt.messages.postman.provide.provide_transition import ProvideState, ProvideTransitionMessage from arkitekt.messages.postman.assign.assign_log import AssignLogMessage from arkitekt.messages.postman.assign.assign_critical import AssignCriticalMessage from arkitekt.messages.postman.assign.bounced_forwarded_assign import BouncedForwardedAssignMessage from arkitekt.messages.postman.assign.bounced_assign import BouncedAssignMessage from arkitekt.messages.postman.provide.provide_critical import ProvideCriticalMessage from arkitekt.messages.postman.log import LogLevel from arkitekt.messages.postman.provide.provide_log import ProvideLogMessage import asyncio from herre.wards.base import WardException from arkitekt.actors.actify import actify, define from arkitekt.actors.base import Actor from arkitekt.messages.postman.unprovide.bounced_unprovide import BouncedUnprovideMessage from arkitekt.messages.base import MessageDataModel, MessageModel from arkitekt.messages.postman.provide.bounced_provide import BouncedProvideMessage from arkitekt.schema.template import Template from arkitekt.schema.node import Node from arkitekt.packers.transpilers import Transpiler from typing import Callable, Dict, List, Tuple, Type from arkitekt.agents.base import Agent, AgentException, parse_params import logging from herre.console import get_current_console import uuid logger = logging.getLogger(__name__) def qt_to_async(insignal, outsignal, futureMap, function): def sync_function_in_qt_loop(reference, *args, **kwargs): returns = function(*args, **kwargs) print("Hallosss") if returns: if isinstance(returns, tuple): outsignal.emit(reference, *returns) else: outsignal.emit(reference, returns) else: outsignal.emit(reference) def set_future(*args): reference = args[0] print("Hallo", args) if len(args) == 1: print("Setting None") futureMap[reference].set_result(None) if len(args) == 2: print("Setting Result") futureMap[reference].set_result(args[1]) if len(args) > 2: print("Setting Result Tuple") futureMap[reference].set_result(*args[1]) insignal.connect(sync_function_in_qt_loop) outsignal.connect(set_future) async def wrapped(*args, **kwargs): loop = asyncio.get_event_loop() reference = str(uuid.uuid4()) future = loop.create_future() futureMap[reference] = future insignal.emit(reference, *args, **kwargs) return await future return wrapped class QtAgentGeneralWorker(QObject): provideInSignal = pyqtSignal(str, BouncedProvideMessage) provideOutSignal = pyqtSignal(str) provideErrorSignal = pyqtSignal(str, Exception) assignInSignal = pyqtSignal(str,tuple, dict) assignOutSignal = pyqtSignal(str, tuple) assignErrorSignal = pyqtSignal(str, Exception) unprovideInSignal = pyqtSignal(str, BouncedProvideMessage) unprovideOutSignal = pyqtSignal(str) unprovideErrorSignal = pyqtSignal(str, Exception) def __init__(self, *args, qt_assign=None, loop= None, qt_on_provide = None, qt_on_unprovide = None, **kwargs) -> None: super().__init__(*args, **kwargs) self.assignInSignal.connect(self.assign_function_in_qtloop) # insignal will be set dymaically by qt agent self.assignOutSignal.connect(self.set_assign_future_qtloop) self.assignErrorSignal.connect(self.set_error_future_qtloop) self.provideInSignal.connect(self.provide_function_in_qtloop) self.provideOutSignal.connect(self.set_provide_future_qtloop) self.provideErrorSignal.connect(self.set_error_future_qtloop) self.unprovideInSignal.connect(self.unprovide_function_in_qtloop) self.unprovideOutSignal.connect(self.set_unprovide_future_qtloop) self.unprovideErrorSignal.connect(self.set_error_future_qtloop) self.futureMap = {} self.loop = loop or get_current_herre().loop self.qt_assign = qt_assign assert self.qt_assign is not None, "You need to provide an assign Function" self.qt_on_provide = qt_on_provide self.qt_on_unprovide = qt_on_unprovide def provide_function_in_qtloop(self, reference, *args, **kwargs): try: returns = self.qt_on_provide(*args, **kwargs) if self.qt_on_provide else None self.provideOutSignal.emit(reference) except Exception as e: self.provideErrorSignal.emit(reference, e) def unprovide_function_in_qtloop(self, reference, *args, **kwargs): try: returns = self.qt_on_unprovide(*args, **kwargs) if self.qt_on_unprovide else None self.unprovideOutSignal.emit(reference) except Exception as e: self.unprovideErrorSignal.emit(reference, e) def set_provide_future_qtloop(self, reference): self.loop.call_soon_threadsafe(self.futureMap[reference].set_result, None) def set_unprovide_future_qtloop(self, reference): self.loop.call_soon_threadsafe(self.futureMap[reference].set_result, None) def set_assign_future_qtloop(self, reference, returns): if len(returns) == 1: print("Setting None") self.loop.call_soon_threadsafe(self.futureMap[reference].set_result, returns[0]) if len(returns) >= 2: print("Setting Result") self.loop.call_soon_threadsafe(self.futureMap[reference].set_result, returns) def assign_function_in_qtloop(self, reference, args, kwargs): try: returns = self.qt_assign(*args, **kwargs) if isinstance(returns, tuple): self.assignOutSignal.emit(reference, returns) else: self.assignOutSignal.emit(reference, (returns,)) except Exception as e: self.assignErrorSignal.emit(reference, e) def set_error_future_qtloop(self, reference, exception): self.loop.call_soon_threadsafe(self.futureMap[reference].set_exception, exception) async def on_provide(self, message): print(self, message) reference = str(uuid.uuid4()) future = self.loop.create_future() self.futureMap[reference] = future self.provideInSignal.emit(reference, message) return await future async def on_unprovide(self,message): reference = str(uuid.uuid4()) future = self.loop.create_future() self.futureMap[reference] = future self.unprovideInSignal.emit(reference,message) return await future async def assign(self, *args, **kwargs): reference = str(uuid.uuid4()) future = self.loop.create_future() self.futureMap[reference] = future self.assignInSignal.emit(reference, args, kwargs) return await future class QtAgent(Agent): ACTOR_PENDING_MESSAGE = "Actor is Pending" def __init__(self, qtApp, *args, strict=False, **kwargs) -> None: super().__init__(*args, **kwargs) self.potentialNodes: List[Tuple[Node, Callable]] = [] self.potentialTemplates: List[Tuple[Node, Callable]] = [] self.approvedTemplates: List[Tuple[Template, Callable]] = [] self.approvedActors: Dict[str, Type[Actor]] = {} self.strict = strict self.qtApp = qtApp self.assignFutures = {} self.provideFutures = {} self.unprovideFutures = {} self.appWorkers = {} # Running Actors indexed by their ID self.runningActors: Dict[str, Actor] = {} self.run