quantalogic 0.33.0__tar.gz → 0.33.1__tar.gz

{quantalogic-0.33.0 → quantalogic-0.33.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: quantalogic
-Version: 0.33.0
+Version: 0.33.1
 Summary: QuantaLogic ReAct Agents
 Author: Raphaël MANSUY
 Author-email: raphael.mansuy@gmail.com

{quantalogic-0.33.0 → quantalogic-0.33.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "quantalogic"
-version = "0.33.0"
+version = "0.33.1"
 description = "QuantaLogic ReAct Agents"
 authors = ["Raphaël MANSUY <raphael.mansuy@gmail.com>"]
 readme = "README.md"

{quantalogic-0.33.0 → quantalogic-0.33.1}/quantalogic/agent.py

@@ -417,9 +417,18 @@ class Agent(BaseModel):
         if not content or not isinstance(content, str):
             return {}
 
+        # Extract action 
         xml_parser = ToleranceXMLParser()
+        action = xml_parser.extract_elements(text=content, element_names=["action"])
+
         tool_names = self.tools.tool_names()
-        return xml_parser.extract_elements(text=content, element_names=tool_names)
+
+        if action:
+            return xml_parser.extract_elements(text=action["action"], element_names=tool_names)
+        else:
+            # Fallback to extracting tool usage directly
+            return xml_parser.extract_elements(text=content, element_names=tool_names)
+
 
     def _parse_tool_arguments(self, tool, tool_input: str) -> dict:
         """Parse the tool arguments from the tool input."""
@@ -511,11 +520,8 @@ class Agent(BaseModel):
         formatted_response = formatted_response = (
             "# Analysis and Next Action Decision Point\n\n"
             f"📊 Progress: Iteration {iteration}/{self.max_iterations}\n\n"
-            "## Current Context\n"
-            f"```\n{self.task_to_solve_summary}```\n\n"
-            f"## Latest Tool {last_exectured_tool} Execution Result:\n"
-            f"Variable: ${variable_name}$\n"
-            f"```\n{response_display}```\n\n"
+            "## Global Task summary:\n"
+            f"```\n\n{self.task_to_solve_summary}```\n\n"
             "## Available Resources\n"
             f"🛠️ Tools:\n{self._get_tools_names_prompt()}\n\n"
             f"📦 Variables:\n{self._get_variable_prompt()}\n\n"
@@ -528,6 +534,9 @@ class Agent(BaseModel):
             "Provide TWO markdown-formatted XML blocks:\n"
             "1. Your analysis of the progression resulting from the execution of the tool in <thinking> tags, don't include <context_analysis/>\n"
             "2. Your tool execution plan in <tool_name> tags\n\n"
+            "## Last executed action result\n"
+            f"Last executed tool {last_exectured_tool} Execution Result:\n"
+            f"\n<{variable_name}>\n{response_display}\n</{variable_name}>\n"
             "## Response Format\n"
             "```xml\n"
             "<thinking>\n"
@@ -545,8 +554,10 @@ class Agent(BaseModel):
             "- Respond ONLY with the two XML blocks\n"
             "- No additional commentary\n"
             "- If previous step failed, revise approach\n"
-            "- Ensure variable interpolation syntax is correct\n"
-            "- Utilize the <task_complete> tool to indicate task completion, display the result or if the task is deemed unfeasible.")
+            "- Use interpolated variables ($variable_name$) where required in tool calls, to minimize token usage, if possible\n"
+            "- strictly follow the required arguments for each tool as defined in system prompt\n"
+            "- Utilize <action><task_complete><answer>...</answer></task_complete><action> to indicate task completion, display the result or if the task is deemed unfeasible."
+        )
 
         return formatted_response
 

quantalogic-0.33.1/quantalogic/console_print_events.py

@@ -0,0 +1,65 @@
+from typing import Any
+
+from rich import box
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
+from rich.tree import Tree
+
+
+def console_print_events(event: str, data: dict[str, Any] | None = None):
+    """Print events with elegant compact formatting."""
+    console = Console()
+
+    # Stylish no-data presentation
+    if not data:
+        console.print(
+            Panel.fit(
+                Text(f"ⓘ No event data", justify="center", style="italic cyan"),
+                title=f"✨ {event}",
+                border_style="cyan",
+                box=box.ROUNDED,
+                padding=(0, 2),
+            )
+        )
+        return
+
+    # Enhanced tree rendering with subtle decorations
+    def render_tree(data: dict[str, Any], tree: Tree) -> None:
+        for key, value in data.items():
+            key_text = Text(f"◈ {key}", style="bright_magenta")
+            if isinstance(value, dict):
+                branch = tree.add(key_text)
+                render_tree(value, branch)
+            elif isinstance(value, list):
+                branch = tree.add(key_text)
+                for item in value:
+                    if isinstance(item, dict):
+                        sub_branch = branch.add(Text("○", style="cyan"))
+                        render_tree(item, sub_branch)
+                    else:
+                        branch.add(Text(f"• {item}", style="dim green"))
+            else:
+                tree.add(Text.assemble(
+                    key_text, 
+                    (" → ", "dim"), 
+                    str(value), style="bright_white"
+                ))
+
+    # Create a compact tree with subtle styling
+    tree = Tree("", guide_style="dim cyan", hide_root=True)
+    render_tree(data, tree)
+
+    # Elegant panel design
+    console.print(
+        Panel(
+            tree,
+            title=f"🎯 [bold bright_cyan]{event}[/]",
+            border_style="bright_blue",
+            box=box.DOUBLE_EDGE,
+            padding=(0, 1),
+            subtitle=f"[dim]Items: {len(data)}[/dim]",
+            subtitle_align="right",
+        ),
+        no_wrap=True
+    )

{quantalogic-0.33.0 → quantalogic-0.33.1}/quantalogic/prompts.py

@@ -39,7 +39,7 @@ Task Format: <task>task_description</task>
     <!-- ONGOING OPERATIONS -->
     • 🔄 Analyze Last Operation Results: Result, Impact, Effectiveness
     • 📊 Progress Map: Completed%, Remaining%, Blockers
-    • 💾 Variable State: $var: value pairs
+    • 💾 Variable State: $var: short description of the content of each variable.
     • 📈 Performance Metrics: Speed, Quality, Resource Usage
   </execution_analysis>
 

{quantalogic-0.33.0 → quantalogic-0.33.1}/quantalogic/xml_parser.py

@@ -7,7 +7,6 @@ with support for handling malformed XML and CDATA sections.
 import html
 import re
 from collections import defaultdict
-from functools import lru_cache
 from typing import Self
 
 from loguru import logger
@@ -53,29 +52,22 @@ class ToleranceXMLParser:
     """
 
     # Default mappings for element name normalization
-    DEFAULT_NAME_MAP = {
-        "o": "output",
-        "i": "input",
-        "opt": "optional"
-    }
+    DEFAULT_NAME_MAP = {"o": "output", "i": "input", "opt": "optional"}
 
     def __init__(self: Self) -> None:
         """Initialize the parser with regex patterns for matching XML-like elements."""
         # Pattern for matching individual XML elements with better whitespace handling
-        self.element_pattern = re.compile(
-            r"<\s*([^/>]+?)\s*>(.*?)(?:</\s*\1\s*>|<\s*\1\s*>)",
-            re.DOTALL
-        )
+        self.element_pattern = re.compile(r"<\s*([^/>]+?)\s*>(.*?)(?:</\s*\1\s*>|<\s*\1\s*>)", re.DOTALL)
         # Pattern for matching CDATA sections
         self.cdata_pattern = re.compile(r"<!\[CDATA\[(.*?)]]>", re.DOTALL)
         logger.debug("Initialized ToleranceXMLParser with regex patterns")
 
     def _validate_input(self, text: str) -> None:
         """Validate input text before processing.
-        
+
         Args:
             text: Input text to validate.
-            
+
         Raises:
             ValueError: If input text is invalid.
         """
@@ -120,7 +112,6 @@ class ToleranceXMLParser:
         # Only unescape HTML entities, preserve everything else exactly as is
         return html.unescape(content)
 
-    @lru_cache(maxsize=128)
     def _map_element_name(self: Self, name: str) -> str:
         """Map element names to their canonical form.
 
@@ -134,10 +125,10 @@ class ToleranceXMLParser:
 
     def _build_element_pattern(self, element_name: str) -> re.Pattern[str]:
         """Build regex pattern for finding specific XML elements.
-        
+
         Args:
             element_name: Name of the element to match.
-            
+
         Returns:
             Compiled regex pattern for matching the element.
         """
@@ -145,53 +136,45 @@ class ToleranceXMLParser:
         cdata_section = r"(?:<!\[CDATA\[.*?]]>)?"
         content_pattern = f"({non_cdata}{cdata_section}{non_cdata})"
         closing_pattern = "(?:</\1>|<\1>)"
-        
-        return re.compile(
-            f"<{element_name}>{content_pattern}{closing_pattern}",
-            re.DOTALL
-        )
+
+        return re.compile(f"<{element_name}>{content_pattern}{closing_pattern}", re.DOTALL)
 
     def _find_all_elements(self, text: str) -> list[tuple[str, str]]:
         """Find all XML elements in text.
-        
+
         Args:
             text: Input text to search.
-            
+
         Returns:
             List of tuples containing element names and their content.
         """
-        return [(match.group(1), match.group(2) or "") 
-                for match in self.element_pattern.finditer(text)]
+        return [(match.group(1), match.group(2) or "") for match in self.element_pattern.finditer(text)]
 
     def _process_element_content(self, content: str, preserve_cdata: bool) -> str:
         """Process content of a single element.
-        
+
         Args:
             content: Raw element content.
             preserve_cdata: Whether to preserve CDATA sections.
-            
+
         Returns:
             Processed content string.
         """
         content, cdata_sections = self._extract_and_remove_cdata(content, preserve_cdata)
         content = self._clean_content(content)
-        
+
         # If content is empty but we have CDATA sections and we're not preserving them
         if not content.strip() and cdata_sections and not preserve_cdata:
             return cdata_sections[0]
         return content
 
-    def _process_elements(
-        self, 
-        elements: list[tuple[str, str]], 
-        preserve_cdata: bool
-    ) -> dict[str, str]:
+    def _process_elements(self, elements: list[tuple[str, str]], preserve_cdata: bool) -> dict[str, str]:
         """Process found elements and handle CDATA sections.
-        
+
         Args:
             elements: List of element name and content tuples.
             preserve_cdata: Whether to preserve CDATA sections.
-            
+
         Returns:
             Dictionary mapping element names to their processed content.
         """
@@ -199,12 +182,12 @@ class ToleranceXMLParser:
         for name, content in elements:
             name = self._map_element_name(name)
             result[name] = self._process_element_content(content, preserve_cdata)
-            
+
             # Handle nested elements
             nested_elements = self._find_all_elements(content)
             nested_results = self._process_elements(nested_elements, preserve_cdata)
             result.update(nested_results)
-            
+
         return dict(result)
 
     def _extract_element_content(self: Self, text: str, preserve_cdata: bool = False) -> dict[str, str]:
@@ -301,3 +284,22 @@ class ToleranceXMLParser:
             error_msg = error_msg + f"\n{text}\n"
             logger.error(error_msg)
             raise ValueError(error_msg)
+
+
+if __name__ == "__main__":
+    xml_content = """
+<action>
+    <task_complete>
+        <answer>Hello</answer>
+    </task_complete>
+</action>
+"""
+
+    parser = ToleranceXMLParser()
+    parsed_values = parser.extract_elements(xml_content)
+    print(parsed_values)
+    if "action" in parsed_values:
+        print(parsed_values["action"])
+    action = parser.extract_elements(text=xml_content, element_names=["action"])
+    print(action["action"])
+

quantalogic-0.33.0/quantalogic/console_print_events.py

@@ -1,66 +0,0 @@
-from typing import Any
-
-from rich import box
-from rich.console import Console
-from rich.panel import Panel
-from rich.tree import Tree
-
-
-def console_print_events(event: str, data: dict[str, Any] | None = None):
-    """Print events with rich formatting.
-
-    Args:
-        event (str): Name of the event.
-        data (Dict[str, Any], optional): Additional event data. Defaults to None.
-    """
-    console = Console()
-
-    # Define panel title with enhanced styling
-    panel_title = f"[bold cyan]Event: {event}[/bold cyan]"
-
-    if not data:
-        # Display a friendly message when no data is available
-        console.print(
-            Panel(
-                "[italic yellow]No additional event data available.[/italic yellow]",
-                title=panel_title,
-                border_style="dim",
-                expand=True,
-                padding=(1, 2),
-            )
-        )
-        return
-
-    # Function to render nested dictionaries as a tree
-    def render_tree(data: dict[str, any], tree: Tree):
-        for key, value in data.items():
-            if isinstance(value, dict):
-                branch = tree.add(f"[bold magenta]{key}[/bold magenta]")
-                render_tree(value, branch)
-            elif isinstance(value, list):
-                branch = tree.add(f"[bold magenta]{key}[/bold magenta]")
-                for index, item in enumerate(value, start=1):
-                    if isinstance(item, dict):
-                        sub_branch = branch.add(f"[cyan]Item {index}[/cyan]")
-                        render_tree(item, sub_branch)
-                    else:
-                        branch.add(f"[green]{item}[/green]")
-            else:
-                tree.add(f"[bold yellow]{key}[/bold yellow]: [white]{value}[/white]")
-
-    # Create a Tree to represent nested data
-    tree = Tree(f"[bold blue]{event} Details[/bold blue]", guide_style="bold bright_blue")
-
-    render_tree(data, tree)
-
-    # Create a panel to display the tree
-    panel = Panel(
-        tree,
-        title=panel_title,
-        border_style="bright_blue",
-        padding=(1, 2),
-        box=box.ROUNDED,
-        expand=True,
-    )
-
-    console.print(panel)