versionhq 1.2.1.22__py3-none-any.whl → 1.2.2.0__py3-none-any.whl

versionhq/task_graph/model.py

@@ -6,13 +6,14 @@ import uuid
 import networkx as nx
 import matplotlib.pyplot as plt
 from abc import ABC
+from concurrent.futures import Future
 from typing import List, Any, Optional, Callable, Dict, Type, Tuple
 
 from pydantic import BaseModel, InstanceOf, Field, UUID4, field_validator
 from pydantic_core import PydanticCustomError
 
-from versionhq.task.model import Task, TaskOutput
 from versionhq.agent.model import Agent
+from versionhq.task.model import Task, TaskOutput
 from versionhq._utils.logger import Logger
 
 
@@ -62,20 +63,23 @@ class Node(BaseModel):
     def is_independent(self) -> bool:
         return not self.in_degree_nodes and not self.out_degree_nodes
 
-    def handle_task_execution(self, agent: Agent = None, context: str = None, format: Type[BaseModel] = None) -> TaskOutput | None:
-        """
-        Start task execution and update status accordingly.
-        """
+    def handle_task_execution(self, agent: Agent = None, context: str = None, response_format: Type[BaseModel] = None) -> TaskOutput | None:
+        """Executes the task and updates its status"""
 
         self.status = TaskStatus.IN_PROGRESS
 
         if not self.task:
-            Logger(verbose=True).log(level="error", message="Missing a task to execute. We'll return None.", color="red")
+            Logger().log(level="error", message="Missing a task to execute. We'll return None.", color="red")
             self.status = TaskStatus.ERROR
             return None
 
-        self.task.pydantic_output = self.task.pydantic_output if self.task.pydantic_output else format if type(format) == BaseModel else None
+        agent = agent if agent else self.assigned_to
+        self.task.pydantic_output = self.task.pydantic_output if self.task.pydantic_output else response_format if type(response_format) == BaseModel else None
         res = self.task.execute(agent=agent, context=context)
+
+        if isinstance(res, Future): # activate async
+            res = res.result()
+
         self.status = TaskStatus.COMPLETED if res else TaskStatus.ERROR
         return res
 
@@ -179,7 +183,7 @@ class Edge(BaseModel):
                     return False
 
 
-    def activate(self, format: Type[BaseModel] = None) -> TaskOutput | None:
+    def activate(self, response_format: Type[BaseModel] = None) -> TaskOutput | None:
         """
         Activates the edge to initiate task execution of the target node.
         """
@@ -197,7 +201,7 @@ class Edge(BaseModel):
             time.sleep(self.lag)
 
         context = self.source.task.output.raw if self.data_transfer else None
-        res = self.target.handle_task_execution(context=context, format=format)
+        res = self.target.handle_task_execution(context=context, response_format=response_format)
         return res
 
 
@@ -207,14 +211,13 @@ class Graph(ABC, BaseModel):
     """
     directed: bool = Field(default=False, description="Whether the graph is directed")
     graph: Type[nx.Graph] = Field(default=None)
-    nodes: Dict[str, Node] = Field(default_factory=dict, description="identifier: Node - for the sake of ")
+    nodes: Dict[str, Node] = Field(default_factory=dict, description="{node_identifier: Node}")
     edges: Dict[str, Edge] = Field(default_factory=dict)
 
     def __init__(self, directed: bool = False, **kwargs):
         super().__init__(directed=directed, **kwargs)
         self.graph = nx.DiGraph(directed=True) if self.directed else nx.Graph()
 
-
     def _return_node_object(self, node_identifier) -> Node | None:
         match = [v for k, v in self.nodes.items() if k == node_identifier]
 
@@ -262,9 +265,7 @@ class Graph(ABC, BaseModel):
         return [v for v in self.nodes.values() if v.out_degrees == 0 and v.in_degrees > 0]
 
     def find_critical_end_node(self) -> Node | None:
-        """
-        Find a critical end node from all the end nodes to lead a conclusion of the entire graph.
-        """
+        """Finds a critical end node from all the end nodes to lead a conclusion of the entire graph."""
         end_nodes = self.find_end_nodes()
         if not end_nodes:
             return None
@@ -276,7 +277,6 @@ class Graph(ABC, BaseModel):
         critical_edge = max(edges, key=lambda item: item['weight']) if edges else None
         return critical_edge.target if critical_edge else None
 
-
     def find_path(self, source: Optional[str] | None, target: str, weight: Optional[Any] | None) -> Any:
         try:
             return nx.shortest_path(self.graph, source=source, target=target, weight=weight)
@@ -309,8 +309,7 @@ class Graph(ABC, BaseModel):
         critical_path = max(all_paths, key=all_paths.get)
         critical_duration = all_paths[critical_path]
 
-        return list(critical_path), critical_duration, all_paths
-
+        return list(set(critical_path)), critical_duration, all_paths
 
     def is_circled(self, node: Node) -> bool:
         """Check if there's a path from the node to itself and return bool."""
@@ -325,8 +324,8 @@ class TaskGraph(Graph):
     id: UUID4 = Field(default_factory=uuid.uuid4, frozen=True)
     should_reform: bool = Field(default=False)
     outputs: Dict[str, TaskOutput] = Field(default_factory=dict, description="stores node identifier and TaskOutput")
-    concl_template: Optional[Dict[str, Any] | Type[BaseModel]] = Field(default=None, description="stores a format of `concl` either in Pydantic model or JSON dict")
-    concl: Any = Field(default=None, description="store the final result of the entire task graph")
+    concl_template: Optional[Dict[str, Any] | Type[BaseModel]] = Field(default=None, description="stores final response format in Pydantic class or JSON dict")
+    concl: Optional[TaskOutput] = Field(default=None, description="stores the final or latest conclusion of the entire task graph")
 
 
     def _save(self, title: str, abs_file_path: str = None) -> None:
@@ -373,7 +372,7 @@ class TaskGraph(Graph):
             return task_node
 
 
-    def add_dependency(self, source_node_identifier: str, target_node_identifier: str, **edge_attributes) -> None:
+    def add_dependency(self, source: str, target: str, **edge_attributes) -> None:
         """
         Add an edge that connect task 1 (source) and task 2 (target) using task_node.name as an identifier
         """
@@ -389,7 +388,7 @@ class TaskGraph(Graph):
             else:
                 pass
 
-        self.add_edge(source_node_identifier, target_node_identifier, edge)
+        self.add_edge(source, target, edge)
 
 
     def get_task_status(self, identifier: str) -> TaskStatus | None:
@@ -484,7 +483,7 @@ class TaskGraph(Graph):
         plt.show(block=False)
 
 
-    def activate(self, target_node_identifier: Optional[str] = None) -> Tuple[TaskOutput | None, Dict[str, TaskOutput]]:
+    def activate(self, target: Optional[str] = None) -> Tuple[TaskOutput | None, Dict[str, TaskOutput]]:
         """
         Starts to execute all nodes in the graph or a specific node if the target is given, following the given conditons of the edge obeject.
         Then returns tuple of the last task output and all task outputs (self.outputs)
@@ -492,24 +491,24 @@ class TaskGraph(Graph):
 
         Logger().log(color="blue", message=f"Start to activate the graph: {str(self.id)}", level="info")
 
-        if target_node_identifier:
-            if not [k for k in self.nodes.keys() if k == target_node_identifier]:
-                Logger().log(level="error", message=f"The node {str(target_node_identifier)} is not in the graph.", color="red")
-                return None
+        if target:
+            if not [k for k in self.nodes.keys() if k == target]:
+                Logger().log(level="error", message=f"The node {str(target)} is not in the graph.", color="red")
+                return None, None
 
             # find a shortest path to each in-degree node of the node and see if dependency met.
-            node = self._return_node_object(target_node_identifier)
+            node = self._return_node_object(target)
             sources = node.in_degrees
             edge_status = []
             res = None
 
             for item in sources:
-                edge = self.find_path(source=item, target=target_node_identifier)
+                edge = self.find_path(source=item, target=target)
                 edge_status.append(dict(edge=edge if edge else None, dep_met=edge.dependency_met() if edge else False))
 
             if len([item for item in edge_status if item["dep_met"] == True]) == len(sources):
                 res = node.handle_task_execution()
-                self.outputs.update({ target_node_identifier: res })
+                self.outputs.update({ target: res })
 
             return res, self.outputs
 
@@ -524,40 +523,35 @@ class TaskGraph(Graph):
             critical_path, _, _ = self.find_critical_path()
             res = None
 
-            # When all nodes are completed, return the output of the critical end node or end node.
             if end_nodes and len([node for node in end_nodes if node.status == TaskStatus.COMPLETED]) == len(end_nodes):
-                if critical_end_node:
-                    return critical_end_node.task.output, self.outputs
-                else:
-                    return [v.task.output for k, v in end_nodes.items()][0], self.outputs
+                res = self.concl if self.concl else critical_end_node.task.output if critical_end_node else  [v.task.output for v in end_nodes.values()][0]
 
-            # Else, execute nodes connected with the critical_path
             elif critical_path:
-                for item in critical_path:
-                    edge = [v for k, v in self.edges.items() if item in k]
-                    if edge:
-                        edge = edge[0]
-
-                        if edge.target.status == TaskStatus.COMPLETED:
-                            res = edge.target.output
+                nodes = [v for k, v in self.nodes.items() if k in critical_path]
+                if nodes:
+                    for node in nodes:
+                        if node.status == TaskStatus.COMPLETED:
+                            res = node.task.output
 
                         else:
-                            res = edge.activate()
-                            node_identifier = edge.target.identifier
-                            self.outputs.update({ node_identifier: res })
+                            res = node.handle_task_execution()
+                            self.outputs.update({ node.identifier: res })
 
                             if not res and start_nodes:
                                 for node in start_nodes:
                                     res = node.handle_task_execution()
                                     self.outputs.update({ node.identifier: res })
+                else:
+                    for k, edge in self.edges.items():
+                        res = edge.activate()
+                        node_identifier = edge.target.identifier
+                        self.outputs.update({ node_identifier: res })
 
-            # If no critical paths in the graph, simply start from the start nodes.
             elif start_nodes:
                 for node in start_nodes:
                     res = node.handle_task_execution()
                     self.outputs.update({ node.identifier: res })
 
-            # If none of above is applicable, try to activate all the edges.
             else:
                 for k, edge in self.edges.items():
                     res = edge.activate()
@@ -566,5 +560,36 @@ class TaskGraph(Graph):
 
             self.concl = res
             self.concl_template = self.concl_template if self.concl_template else res.pydantic.__class__ if res.pydantic else None
-            # last_task_output = [v for v in self.outputs.values()][len([v for v in self.outputs.values()]) - 1] if [v for v in self.outputs.values()] else None
+             # last_task_output = [v for v in self.outputs.values()][len([v for v in self.outputs.values()]) - 1] if [v for v in self.outputs.values()] else None
             return res, self.outputs
+
+
+    def evaluate(self, eval_criteria: List[str] = None):
+        """Evaluates the conclusion based on the given eval criteria."""
+
+        if not isinstance(self.concl, TaskOutput):
+            return None
+
+        tasks = [v.task for v in self.nodes.values() if v.task and v.task.id == self.concl.task_id]
+        task = tasks[0] if tasks else None
+
+        if not task:
+            return None
+
+        if not task.eval_criteria:
+            task.eval_criteria = eval_criteria
+
+        eval = self.concl.evaluate(task=task)
+        return eval
+
+
+    @property
+    def usage(self) -> Tuple[int, float]:
+        """Returns aggregate number of consumed tokens and job latency in ms during the activation"""
+
+        tokens, latency = 0, 0
+        for v in self.outputs.values():
+            tokens += v._tokens
+            latency += v.latency
+
+        return tokens, latency

{versionhq-1.2.1.22.dist-info → versionhq-1.2.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: versionhq
-Version: 1.2.1.22
+Version: 1.2.2.0
 Summary: An agentic orchestration framework for building agent networks that handle task automation.
 Author-email: Kuriko Iwai <kuriko@versi0n.io>
 License: MIT License
@@ -259,7 +259,7 @@ agent.update(
       task="YOUR AMAZING TASK OVERVIEW",
       expected_outcome="YOUR OUTCOME EXPECTATION",
    )
-   res = network.launch()
+   res, _ = network.launch()
    ```
 
 This will form a network with multiple agents on `Formation` and return `TaskOutput` object with output in JSON, plane text, Pydantic model format with evaluation.
@@ -290,15 +290,16 @@ task = vhq.Task(
    callback_kwargs=dict(message="Hi! Here is the result: ")
 )
 
-res = task.execute(context="amazing context to consider.")
-print(res)
+res = task.execute(context="context to consider")
+
+assert isinstance(res, vhq.TaskOutput)
 ```
 
 
 This will return a `TaskOutput` object that stores response in plane text, JSON, and Pydantic model: `CustomOutput` formats with a callback result, tool output (if given), and evaluation results (if given).
 
 ```python
-res == TaskOutput(
+res == vhq.TaskOutput(
    task_id=UUID('<TASK UUID>'),
    raw='{\"test1\":\"random str\", \"test2\":[\"str item 1\", \"str item 2\", \"str item 3\"]}',
    json_dict={'test1': 'random str', 'test2': ['str item 1', 'str item 2', 'str item 3']},
@@ -337,9 +338,9 @@ network =vhq.AgentNetwork(
       vhq.Member(agent=agent_b, is_manager=True, tasks=[task_2]), # Agent B as a manager
    ],
 )
-res = network.launch()
+res, _ = network.launch()
 
-assert isinstance(res, vhq.NetworkOutput)
+assert isinstance(res, vhq.TaskOutput)
 assert not [item for item in task_1.processed_agents if "vhq-Delegated-Agent" == item]
 assert [item for item in task_1.processed_agents if "agent b" == item]
 ```

{versionhq-1.2.1.22.dist-info → versionhq-1.2.2.0.dist-info}/RECORD

@@ -1,20 +1,20 @@
-versionhq/__init__.py,sha256=xiTq9nfM7wVDAPecl79IUIeaU4m48he7azr1WZ962W4,2892
-versionhq/_utils/__init__.py,sha256=dzoZr4cBlh-2QZuPzTdehPUCe9lP1dmRtauD7qTjUaA,158
+versionhq/__init__.py,sha256=uh8uc3vSkOPeiz6MBNYdjJeCzH_KPMN-x5Xp5MWyOPo,2857
+versionhq/_utils/__init__.py,sha256=d-vYVcORZKG-kkLe_fzE8VbViDpAk9DDOKe2fVK25ew,178
 versionhq/_utils/i18n.py,sha256=TwA_PnYfDLA6VqlUDPuybdV9lgi3Frh_ASsb_X8jJo8,1483
 versionhq/_utils/logger.py,sha256=iHxGjm3BvUo5dHKLU88_pc0Z45wzSHOjyJGQkb7OADk,3255
 versionhq/_utils/process_config.py,sha256=YTGY_erW335RfceQfzS18YAqq-AAb-iSvKSjN7noD2E,782
-versionhq/_utils/usage_metrics.py,sha256=NXF18dn5NNvGK7EsQ4AAghpR8ppYOjMx6ABenLLHnmM,1066
+versionhq/_utils/usage_metrics.py,sha256=xgYGRW3OTuK9EJyi3QYJeYcJl7dL27olcWaLo_7B3JE,2246
 versionhq/_utils/vars.py,sha256=bZ5Dx_bFKlt3hi4-NNGXqdk7B23If_WaTIju2fiTyPQ,57
 versionhq/agent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-versionhq/agent/inhouse_agents.py,sha256=vupO1viYqVb7sKohIE1zThu6JArhh5JLo5LBeSnh0kM,2534
-versionhq/agent/model.py,sha256=2GzZW9io5yHKXHvJJMq53ZjIP9pCK4_ubH-KdMYmsKw,26542
+versionhq/agent/inhouse_agents.py,sha256=WAbyog-6pKwa8ru9u_KJgD_ViTLv4ZRECks1Znch47E,2638
+versionhq/agent/model.py,sha256=cYplMaQXHocFeZGZ1WIZ5npZ_Edokj3qFPBE9PiBxHw,25285
 versionhq/agent/parser.py,sha256=riG0dkdQCxH7uJ0AbdVdg7WvL0BXhUgJht0VtQvxJBc,4082
 versionhq/agent/rpm_controller.py,sha256=grezIxyBci_lDlwAlgWFRyR5KOocXeOhYkgN02dNFNE,2360
 versionhq/agent/TEMPLATES/Backstory.py,sha256=IAhGnnt6VUMe3wO6IzeyZPDNu7XE7Uiu3VEXUreOcKs,532
 versionhq/agent/TEMPLATES/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 versionhq/agent_network/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 versionhq/agent_network/formation.py,sha256=7iGw20Dj2sFLAho6yfrdmonAwFcxINBDGFr2RU-Qz3s,7505
-versionhq/agent_network/model.py,sha256=hjtYIopAN52nStcM6TlV0b6ulRMrmzKH7jIkzNmZHDE,19265
+versionhq/agent_network/model.py,sha256=93VVOtON6_TEren4FnWfLtUGl_T6DLVA0BhZgY9yhIA,19059
 versionhq/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 versionhq/clients/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 versionhq/clients/customer/__init__.py,sha256=-YXh1FQfvpfLacK8SUC7bD7Wx_eIEi4yrkCC_cUasFg,217
@@ -32,28 +32,27 @@ versionhq/knowledge/source_docling.py,sha256=mg7bgvKePHn2LlA_XzSFCbS0zOo9xfu_aNO
 versionhq/knowledge/storage.py,sha256=7oxCg3W9mFjYH1YmuH9kFtTbNxquzYFjuUjd_TlsB9E,8170
 versionhq/llm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 versionhq/llm/llm_vars.py,sha256=wjQK20cKvph6Vq1v71o4d16zBGcHlwq0bzOT_zWno7w,7041
-versionhq/llm/model.py,sha256=wlzDUMEyIOm808d1vzqu9gmbB4ch-s_EUvwFR60gR80,17177
+versionhq/llm/model.py,sha256=HIBmf8FYV6-cDbZK1ZBu6z3dmF0ZUbKbCelfwxMlgyY,17177
 versionhq/memory/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 versionhq/memory/contextual_memory.py,sha256=WeDujcEp4oud30OusXSPPNrMEQP-vGrt1mcfYopQruU,3483
-versionhq/memory/model.py,sha256=MPO8dDP5eAuk9td6bMOq5j2huLzCADFJDrTujHhcWQY,8150
+versionhq/memory/model.py,sha256=VQR1229t7GQPMItlGAHLtJrb6LrZfSoRA1DRW4z0SOU,8234
 versionhq/storage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 versionhq/storage/base.py,sha256=p-Jas0fXQan_qotnRD6seQxrT2lj-uw9-SmHQhdppcs,355
 versionhq/storage/ltm_sqlite_storage.py,sha256=wdUiuwHfJocdk0UGqyrdU4S5Nae1rgsoRNu3LWmGFcI,3951
 versionhq/storage/mem0_storage.py,sha256=ZY8MELBWaINRv9YuRW5MxH7dj2cII-L0i3xSD6o1-2M,3781
 versionhq/storage/rag_storage.py,sha256=bS2eE874obarYl-4hT6ZWYWTRsqtfuGpKgKzERmM6Uo,7433
-versionhq/storage/task_output_storage.py,sha256=E1t_Fkt78dPYIOl3MP7LfQ8oGtjlzxBuSNq_8ZXKho8,4573
-versionhq/storage/utils.py,sha256=ByYXPoEIGJYLUqz-DWjbCAnneNrH1otiYbp12SCILpM,747
+versionhq/storage/task_output_storage.py,sha256=M8vInLJ5idGAq17w1juHKXtyPyF-B-rK_P8UcqD-Px8,5357
+versionhq/storage/utils.py,sha256=r5ghA_ktdR2IuzlzKqZYCjsNxztEMzyhWLneA4cFuWY,748
 versionhq/task/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-versionhq/task/evaluate.py,sha256=WdUgjbZL62XrxyWe5MTz29scfzwmuAHGxJ7GvAB8Fmk,3954
+versionhq/task/evaluation.py,sha256=mHLNabuvSbi9FGfblomr41vlc3quTHsugH3-3qQmcDw,4461
 versionhq/task/formatter.py,sha256=N8Kmk9vtrMtBdgJ8J7RmlKNMdZWSmV8O1bDexmCWgU0,643
-versionhq/task/log_handler.py,sha256=LT7YnO7gcPR9IZS7eRvMjnHh8crMBFtqduxd8dxIbkk,1680
-versionhq/task/model.py,sha256=KshCysteol3ggfotZMfFn192dMYALg8lvjiGpyLUVQA,28948
+versionhq/task/model.py,sha256=8qBxRgqMs_b8IZA45_gAU1uc5S5w9hdnyRG-Vwm8bVM,28901
 versionhq/task/structured_response.py,sha256=4q-hQPu7oMMHHXEzh9YW4SJ7N5eCZ7OfZ65juyl_jCI,5000
-versionhq/task/TEMPLATES/Description.py,sha256=V-4kh8xpQTKOcDMi2xnuP-fcNk6kuoz1_5tYBlDLQWQ,420
+versionhq/task/TEMPLATES/Description.py,sha256=EkwJHc65G32MjWyn3rcp0ATmMaVPHuYKaykyByU5r4g,751
 versionhq/task_graph/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 versionhq/task_graph/colors.py,sha256=naJCx4Vho4iuJtbW8USUXb-M5uYvd5ds2p8qbjUfRus,669
-versionhq/task_graph/draft.py,sha256=AuQ2X-T5xuQ2ipMiAqeh9Pjm6I2fIf952pBQRYqdaog,5131
-versionhq/task_graph/model.py,sha256=njyHQyHrVTZP46iVkC6YvuMnGcS40vOy1wszRtf7DHY,23971
+versionhq/task_graph/draft.py,sha256=l18XacRsbDhAv6CvKMnUMI26IDuizA1UNWHbL1q5gn4,5099
+versionhq/task_graph/model.py,sha256=53D_Bd-Uz6fv5Y1iVVDX1wzqcabE1BmLzqEO0oL8wrs,24628
 versionhq/tool/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 versionhq/tool/cache_handler.py,sha256=iL8FH7X0G-cdT0uhJwzuhLDaadTXOdfybZcDy151-es,1085
 versionhq/tool/composio_tool.py,sha256=IATfsEnF_1RPJyGtPBmAtEJh5XPcgDHpyG3SUR461Og,8572
@@ -61,8 +60,8 @@ versionhq/tool/composio_tool_vars.py,sha256=FvBuEXsOQUYnN7RTFxT20kAkiEYkxWKkiVtg
 versionhq/tool/decorator.py,sha256=C4ZM7Xi2gwtEMaSeRo-geo_g_MAkY77WkSLkAuY0AyI,1205
 versionhq/tool/model.py,sha256=PO4zNWBZcJhYVur381YL1dy6zqurio2jWjtbxOxZMGI,12194
 versionhq/tool/tool_handler.py,sha256=2m41K8qo5bGCCbwMFferEjT-XZ-mE9F0mDUOBkgivOI,1416
-versionhq-1.2.1.22.dist-info/LICENSE,sha256=cRoGGdM73IiDs6nDWKqPlgSv7aR4n-qBXYnJlCMHCeE,1082
-versionhq-1.2.1.22.dist-info/METADATA,sha256=2NuRqQKWkFVJpQVfjjMLLUmKeIH2FqK9UWHt0KsC8Wk,22033
-versionhq-1.2.1.22.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-versionhq-1.2.1.22.dist-info/top_level.txt,sha256=DClQwxDWqIUGeRJkA8vBlgeNsYZs4_nJWMonzFt5Wj0,10
-versionhq-1.2.1.22.dist-info/RECORD,,
+versionhq-1.2.2.0.dist-info/LICENSE,sha256=cRoGGdM73IiDs6nDWKqPlgSv7aR4n-qBXYnJlCMHCeE,1082
+versionhq-1.2.2.0.dist-info/METADATA,sha256=dEEdYYA25P_WeaIrGwXDKdXmlWSgWcl-pMGEleVuaU0,22059
+versionhq-1.2.2.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+versionhq-1.2.2.0.dist-info/top_level.txt,sha256=DClQwxDWqIUGeRJkA8vBlgeNsYZs4_nJWMonzFt5Wj0,10
+versionhq-1.2.2.0.dist-info/RECORD,,

versionhq/task/log_handler.py

@@ -1,59 +0,0 @@
-from datetime import datetime
-from typing import Any, Dict, List, Optional
-
-from pydantic import BaseModel, Field
-
-from versionhq.storage.task_output_storage import TaskOutputSQLiteStorage
-
-
-class ExecutionLog(BaseModel):
-    task_id: str
-    output: Dict[str, Any]
-    timestamp: datetime = Field(default_factory=datetime.now)
-    task_index: int
-    inputs: Dict[str, Any] = Field(default_factory=dict)
-    was_replayed: bool = False
-
-    def __getitem__(self, key: str) -> Any:
-        return getattr(self, key)
-
-
-
-class TaskOutputStorageHandler:
-
-    def __init__(self):
-        self.storage = TaskOutputSQLiteStorage()
-
-
-    def update(self, task, task_index: int, was_replayed: bool = False, inputs: Dict[str, Any] = {}) -> None:
-        """
-        task: task instance
-        """
-        saved_outputs = self.load()
-        if saved_outputs is None:
-            raise ValueError("Logs cannot be None")
-
-        self.add(task, task_index, was_replayed, inputs)
-
-
-    def add(self, task, task_index: int, was_replayed: bool = False, inputs: Dict[str, Any] = {}) -> None:
-        from versionhq.task.model import Task
-
-        output_to_store = dict()
-
-        if isinstance(task, Task):
-            output_to_store = dict(
-                description=str(task.description),
-                raw=str(task.output.raw),
-                responsible_agent=str(task.processed_agents),
-            )
-
-        self.storage.add(task=task, output=output_to_store, task_index=task_index, was_replayed=was_replayed, inputs=inputs)
-
-
-    def reset(self) -> None:
-        self.storage.delete_all()
-
-
-    def load(self) -> Optional[List[Dict[str, Any]]]:
-        return self.storage.load()