levelapp 0.1.3__py3-none-any.whl → 0.1.4__py3-none-any.whl

levelapp/simulator/utils.py

@@ -1,13 +1,14 @@
 """
 'simulators/aspects.py': Utility functions for handling VLA interactions and requests.
 """
+import re
 import ast
 import json
 import httpx
 
 from uuid import UUID
 from string import Template
-from typing import Any, Dict, List, Union
+from typing import Any, Dict, List, Union, Iterable
 
 from pydantic import ValidationError
 
@@ -24,46 +25,139 @@ class UUIDEncoder(json.JSONEncoder):
         return json.JSONEncoder.default(self, obj)
 
 
-def extract_interaction_details(
-        response: str | Dict[str, Any],
-        template: Dict[str, Any],
-) -> InteractionResults:
+_PLACEHOLDER_RE = re.compile(r"\$\{([^}]+)\}")  # captures inner name(s) of ${...}
+
+
+def _traverse_path(d: Dict[str, Any], path: str):
+    """Traverse a dot-separated path (payload.metadata.budget) and return value or None."""
+    parts = path.split(".")
+    cur = d
+    try:
+        for p in parts:
+            if isinstance(cur, dict) and p in cur:
+                cur = cur[p]
+            else:
+                return None
+        return cur
+    except Exception:
+        return None
+
+
+def _recursive_find(container: Any, target_key: str):
+    """
+    Recursively search container (dicts/lists) for the first occurrence of target_key.
+    Returns the value if found, else None.
     """
-    Extract interaction details from a VLA response.
+    if isinstance(container, dict):
+        # direct hit
+        if target_key in container:
+            return container[target_key]
+        # recurse into values
+        for v in container.values():
+            found = _recursive_find(v, target_key)
+            if found is not None:
+                return found
+        return None
+
+    if isinstance(container, list):
+        for item in container:
+            found = _recursive_find(item, target_key)
+            if found is not None:
+                return found
+        return None
+
+    # not a container
+    return None
 
-    Args:
-        response (str): The response text from the VLA.
-        template (Dict[str, Any]): The response schema/template.
 
-    Returns:
-        InteractionResults: The extracted interaction details.
+def _extract_placeholders(template_str: str) -> Iterable[str]:
+    """Return list of placeholder names in a template string (inner contents of ${...})."""
+    return [m.group(1) for m in _PLACEHOLDER_RE.finditer(template_str)]
+
+
+def extract_interaction_details(
+    response: str | Dict[str, Any],
+    template: Dict[str, Any],
+) -> InteractionResults:
+    """
+    Parse response (str or dict), look up placeholders recursively in the response and
+    use Template.safe_substitute with a mapping built from those lookups.
     """
     try:
         response_dict = response if isinstance(response, dict) else json.loads(response)
-
+        print(f"response:\n{response_dict}\n--")
         if not isinstance(response_dict, dict):
             raise ValueError("Response is not a valid dictionary")
 
-        required_keys = {value.strip("${}") for value in template.values()}
-        if not required_keys.issubset(response_dict.keys()):
-            missing_keys = required_keys - response_dict.keys()
-            logger.warning(f"[extract_interaction_details] Missing data: {missing_keys}]")
-
-        output = {}
-        for k, v in template.items():
-            output[k] = Template(v).safe_substitute(response_dict)
-
-        raw_value = output.get("generated_metadata", {})
-        output["generated_metadata"] = ast.literal_eval(raw_value) if isinstance(raw_value, str) else raw_value
-
+        output: Dict[str, Any] = {}
+
+        for out_key, tpl_str in template.items():
+            # Build mapping for placeholders found in tpl_str
+            placeholders = _extract_placeholders(tpl_str)
+            mapping: Dict[str, str] = {}
+
+            for ph in placeholders:
+                value = None
+
+                # 1) If ph looks like a dotted path, try explicit path traversal first
+                if "." in ph:
+                    value = _traverse_path(response_dict, ph)
+
+                # 2) If not found yet, try recursive search for the bare key (last path segment)
+                if value is None:
+                    bare = ph.split(".")[-1]
+                    value = _recursive_find(response_dict, bare)
+
+                # Prepare mapping value for Template substitution:
+                # - dict/list -> JSON string (so substitution yields valid JSON text)
+                # - None -> empty string
+                # - otherwise -> str(value)
+                if isinstance(value, (dict, list)):
+                    try:
+                        mapping[ph] = json.dumps(value, ensure_ascii=False)
+                    except Exception:
+                        mapping[ph] = str(value)
+                elif value is None:
+                    mapping[ph] = ""
+                else:
+                    mapping[ph] = str(value)
+
+            # Perform substitution using Template (safe_substitute: missing keys left intact)
+            substituted = Template(tpl_str).safe_substitute(mapping)
+            output[out_key] = substituted
+
+        # Post-process generated_metadata if present: convert JSON text back to dict/list when possible
+        raw_meta = output.get("generated_metadata", {})
+        if isinstance(raw_meta, str) and raw_meta:
+            # Try json first (since we used json.dumps above for mapping)
+            try:
+                output["generated_metadata"] = json.loads(raw_meta)
+            except Exception:
+                # fallback to ast.literal_eval (handles Python dict strings)
+                try:
+                    output["generated_metadata"] = ast.literal_eval(raw_meta)
+                except Exception:
+                    # if parsing fails, keep the original raw string or use an empty dict
+                    output["generated_metadata"] = raw_meta
+
+        # If generated_metadata is empty string, normalize to {}
+        if output.get("generated_metadata") == "":
+            output["generated_metadata"] = {}
+
+        print(f"output:\n{output}\n---")
+        # Return validated model
         return InteractionResults.model_validate(output)
 
     except json.JSONDecodeError as e:
-        logger.error(f"[extract_interaction_details] Failed to extract details:\n{e}")
+        logger.error(f"[extract_interaction_details] Failed to parse JSON response: {e}")
         return InteractionResults()
 
     except ValidationError as e:
-        logger.exception(f"[extract_interaction_details] Failed to create an InteractionResults instance:\n{e}")
+        logger.exception(f"[extract_interaction_details] InteractionResults validation failed: {e}")
+        return InteractionResults()
+
+    except Exception as e:
+        logger.exception(f"[extract_interaction_details] Unexpected error: {e}")
         return InteractionResults()
 
 

{levelapp-0.1.3.dist-info → levelapp-0.1.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: levelapp
-Version: 0.1.3
+Version: 0.1.4
 Summary: LevelApp is an evaluation framework for AI/LLM-based software application. [Powered by Norma]
 Project-URL: Homepage, https://github.com/levelapp-org
 Project-URL: Repository, https://github.com/levelapp-org/levelapp-framework

{levelapp-0.1.3.dist-info → levelapp-0.1.4.dist-info}/RECORD

@@ -36,7 +36,7 @@ levelapp/repository/firestore.py,sha256=K9JgxsNCelAKtzTDv19c1dHRlitMeRzo7H3caTlK
 levelapp/simulator/__init__.py,sha256=8Dz8g7rbpBZX3WoknVmMVoWm_VT72ZL9BABOF1xFpqs,83
 levelapp/simulator/schemas.py,sha256=YGprtuRZ4m33WBD35xj1Ib5EbMTdDCOp-wCykf-Iz-4,3700
 levelapp/simulator/simulator.py,sha256=yreado12XMVEJ4N4cYj5m_bYVKU3BsOv5oQycB7wCFw,19889
-levelapp/simulator/utils.py,sha256=d1O4Q4Yl1lAAJWLJDiwNjwt0hD9bGlCan4a2G21E7yw,5930
+levelapp/simulator/utils.py,sha256=xZXdF24rrOm5RCp5ELk0wQxxGd70CahDT79cIC-XmlE,9589
 levelapp/workflow/__init__.py,sha256=27b2obG7ObhR43yd2uH-R0koRB7-DG8Emnvrq8EjsTA,193
 levelapp/workflow/base.py,sha256=1A_xKSBOmVjfMbRBcNhDK6G17SEjqRIm-XjMw45IPC4,5596
 levelapp/workflow/config.py,sha256=MlHt1PsXD09aukB93fvKTew0D8WD4_jdnO93Nn6b2U0,2923
@@ -44,7 +44,7 @@ levelapp/workflow/context.py,sha256=gjAZXHEdlsXqWY6DbXOfKXNbxQbahRPSnNzyWDqryPU,
 levelapp/workflow/factory.py,sha256=z1ttJmI59sU9HgOvPo3ixUJ_oPv838XgehfuOorlTt8,1634
 levelapp/workflow/registration.py,sha256=VHUHjLHXad5kjcKukaEOIf7hBZ09bT3HAzVmIT08aLo,359
 levelapp/workflow/runtime.py,sha256=cFyXNWXSuURKbrMDHdkTcjeItM9wHP-5DPljntwYL5g,686
-levelapp-0.1.3.dist-info/METADATA,sha256=wYFEgC4bRV2nfbxv8PHLwejyhtrfsbjOCIckQvPdPeA,12572
-levelapp-0.1.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-levelapp-0.1.3.dist-info/licenses/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-levelapp-0.1.3.dist-info/RECORD,,
+levelapp-0.1.4.dist-info/METADATA,sha256=zCmgM_evZ9Y0xcAX-so7foD_auO0I9PSzLGw0pL2HUY,12572
+levelapp-0.1.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+levelapp-0.1.4.dist-info/licenses/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+levelapp-0.1.4.dist-info/RECORD,,