Cleaned colang directory

Author: tgasser-nv

nemoguardrails/colang/v1_0/lang/comd_parser.py

@@ -360,21 +360,22 @@ def parse_md_file(file_name, content=None):
                 continue
 
             # Make sure we have the type of the symbol in the name of the symbol
-            sym = _get_typed_symbol_name(sym, symbol_type)
+            if sym is not None:
+                sym = _get_typed_symbol_name(sym, symbol_type)
 
-            # For objects, we translate the "string" type to "kb:Object:prop|partial"
-            param_type = _get_param_type(parts[1])
-            if symbol_type == "object" and param_type in ["string", "text"]:
-                object_name = split_max(sym, ":", 1)[1]
-                param_type = f"kb:{object_name}:{parts[0]}|partial"
+                # For objects, we translate the "string" type to "kb:Object:prop|partial"
+                param_type = _get_param_type(parts[1])
+                if symbol_type == "object" and param_type in ["string", "text"]:
+                    object_name = split_max(sym, ":", 1)[1]
+                    param_type = f"kb:{object_name}:{parts[0]}|partial"
 
-            # TODO: figure out a cleaner way to deal with this
-            # For the "type:time" type, we transform it into "lookup:time"
-            if param_type == "type:time":
-                param_type = "lookup:time"
+                # TODO: figure out a cleaner way to deal with this
+                # For the "type:time" type, we transform it into "lookup:time"
+                if param_type == "type:time":
+                    param_type = "lookup:time"
 
-            result["mappings"].append((f"{sym}:{parts[0]}", param_type))
-            symbol_params.append(parts[0])
+                result["mappings"].append((f"{sym}:{parts[0]}", param_type))
+                symbol_params.append(parts[0])
 
         elif line.startswith("-") or line.startswith("*"):
             if sym is None:

nemoguardrails/colang/v1_0/lang/coyml_parser.py

@@ -420,14 +420,20 @@ def _extract_elements(items: List) -> List[dict]:
             # for `if` flow elements, we have to go recursively
             if element["_type"] == "if":
                 if_element = element
-                then_elements = _extract_elements(if_element["then"])
-                else_elements = _extract_elements(if_element["else"])
+                then_items = (
+                    if_element["then"] if isinstance(if_element["then"], list) else []
+                )
+                else_items = (
+                    if_element["else"] if isinstance(if_element["else"], list) else []
+                )
+                then_elements = _extract_elements(then_items)
+                else_elements = _extract_elements(else_items)
 
                 # Remove the raw info
                 del if_element["then"]
                 del if_element["else"]
 
-                if_element["_next_else"] = len(then_elements) + 1
+                if_element["_next_else"] = str(len(then_elements) + 1)
 
                 # Add the "if"
                 elements.append(if_element)
@@ -437,30 +443,35 @@ def _extract_elements(items: List) -> List[dict]:
 
                 # if we have "else" elements, we need to adjust also add a jump
                 if len(else_elements) > 0:
-                    elements.append({"_type": "jump", "_next": len(else_elements) + 1})
-                    if_element["_next_else"] += 1
+                    elements.append(
+                        {"_type": "jump", "_next": str(len(else_elements) + 1)}
+                    )
+                    if_element["_next_else"] = str(int(if_element["_next_else"]) + 1)
 
                     # Add the "else" elements
                     elements.extend(else_elements)
 
             # WHILE
             elif element["_type"] == "while":
                 while_element = element
-                do_elements = _extract_elements(while_element["do"])
+                do_items = (
+                    while_element["do"] if isinstance(while_element["do"], list) else []
+                )
+                do_elements = _extract_elements(do_items)
                 n = len(do_elements)
 
                 # Remove the raw info
                 del while_element["do"]
 
                 # On break we have to skip n elements and 1 jump, hence we go to n+2
-                while_element["_next_on_break"] = n + 2
+                while_element["_next_on_break"] = str(n + 2)
 
                 # We need to compute the jumps on break and on continue for each element
                 for j in range(n):
                     # however, we make sure we don't override an inner loop
                     if "_next_on_break" not in do_elements[j]:
-                        do_elements[j]["_next_on_break"] = n + 1 - j
-                        do_elements[j]["_next_on_continue"] = -1 * j - 1
+                        do_elements[j]["_next_on_break"] = str(n + 1 - j)
+                        do_elements[j]["_next_on_continue"] = str(-1 * j - 1)
 
                 # Add the "while"
                 elements.append(while_element)
@@ -500,7 +511,7 @@ def _extract_elements(items: List) -> List[dict]:
             branch_element = {
                 "_type": "branch",
                 # these are the relative positions to the current position
-                "branch_heads": [],
+                "branch_heads": [],  # type: ignore
             }
             branch_element_pos = len(elements)
             elements.append(branch_element)
@@ -520,7 +531,7 @@ def _extract_elements(items: List) -> List[dict]:
                         branch_element["_source_mapping"] = branch_path[0]["_source_mapping"]
 
                 # Create the jump element
-                jump_element = {"_type": "jump", "_next": 1}
+                jump_element = {"_type": "jump", "_next": 1}  # type: ignore
 
                 # We compute how far we need to jump based on the remaining branches
                 j = branch_idx + 1

nemoguardrails/colang/v1_0/lang/utils.py

@@ -86,11 +86,14 @@ def get_numbered_lines(content: str):
     current_comment = None
     multiline_string = False
     current_string = None
+    multiline_indentation = 0
     while i < len(raw_lines):
         raw_line = raw_lines[i].strip()
 
         # handle multiline string
         if multiline_string:
+            if current_string is None:
+                current_string = ""
             current_string += "\n" + raw_line
             if raw_line.endswith('"'):
                 multiline_string = False
@@ -139,6 +142,8 @@ def get_numbered_lines(content: str):
             continue
 
         if multiline_comment:
+            if current_comment is None:
+                current_comment = ""
             if raw_line.endswith('"""'):
                 current_comment += "\n" + raw_line[0:-3]
                 multiline_comment = False

nemoguardrails/colang/v1_0/runtime/runtime.py

@@ -659,7 +659,8 @@ async def _process_start_action(self, events: List[dict]) -> List[dict]:
         if isinstance(result, ActionResult):
             return_value = result.return_value
             return_events = result.events
-            context_updates.update(result.context_updates)
+            if result.context_updates is not None:
+                context_updates.update(result.context_updates)
 
         # If we have an action result key, we also record the update.
         if action_result_key:
@@ -730,10 +731,17 @@ async def _get_action_resp(
                             )
                     except Exception as e:
                         log.info(f"Exception {e} while making request to {action_name}")
+                        if not isinstance(result, dict):
+                            result = {"value": result}
                         return result, status
 
         except Exception as e:
             log.info(f"Failed to get response from {action_name} due to exception {e}")
+
+        # Ensure result is a dict as expected by the return type
+        if not isinstance(result, dict):
+            result = {"value": result}
+
         return result, status
 
     async def _process_start_flow(self, events: List[dict], processing_log: List[dict]) -> List[dict]:

nemoguardrails/colang/v1_0/runtime/sliding.py

@@ -14,7 +14,10 @@
 # limitations under the License.
 
 import logging
-from typing import Optional
+from typing import TYPE_CHECKING, Optional
+
+if TYPE_CHECKING:
+    from nemoguardrails.colang.v1_0.runtime.flows import FlowConfig, State
 
 from nemoguardrails.colang.v1_0.runtime.eval import eval_expression
 

nemoguardrails/colang/v2_x/lang/colang_ast.py

@@ -77,13 +77,17 @@ def get(self, key, default_value=None):
 
     def __eq__(self, other):
         if isinstance(other, self.__class__):
-            return self.__hash__() == other.__hash__()
+            return self.hash() == other.hash()
         return NotImplemented
 
     def hash(self):
         """Return the hash for the current object."""
         return hash(_make_hashable(self))
 
+    def __hash__(self):
+        """Return the hash for the current object."""
+        return self.hash()
+
 
 ElementType = Union[Element, dict]
 

nemoguardrails/colang/v2_x/lang/expansion.py

@@ -106,7 +106,12 @@ def expand_elements(
                 if e.args[0]:
                     error = e.args[0]
 
-                if hasattr(element, "_source") and element._source:
+                if (
+                    not isinstance(element, dict)
+                    and hasattr(element, "_source")
+                    and element._source is not None
+                    and hasattr(element._source, "line")
+                ):
                     # TODO: Resolve source line to Colang file level
                     raise ColangSyntaxError(error + f" on source line {element._source.line}")
                 else:
@@ -413,10 +418,15 @@ def _expand_match_element(
 
                 for idx, element in enumerate(and_group["elements"]):
                     new_elements.append(event_label_elements[idx])
+                    # Ensure element is valid for SpecOp
+                    if isinstance(element, (dict, Spec)):
+                        spec_element: Union[dict, Spec] = element
+                    else:
+                        spec_element = {}
                     new_elements.append(
                         SpecOp(
                             op="match",
-                            spec=element,
+                            spec=spec_element,
                         )
                     )
                     new_elements.append(goto_end_element)
@@ -433,8 +443,8 @@ def _expand_match_element(
 
         else:
             # Multiple and-groups combined by or
-            fork_uid: str = new_var_uuid()
-            fork_element = ForkHead(fork_uid=fork_uid)
+            or_fork_uid: str = new_var_uuid()
+            fork_element = ForkHead(fork_uid=or_fork_uid)
             group_label_elements: List[Label] = []
             failure_label_name = f"failure_label_{new_var_uuid()}"
             failure_label_element = Label(name=failure_label_name)
@@ -463,12 +473,12 @@ def _expand_match_element(
 
             new_elements.append(failure_label_element)
             new_elements.append(WaitForHeads(number=len(or_group)))
-            new_elements.append(MergeHeads(fork_uid=fork_uid))
+            new_elements.append(MergeHeads(fork_uid=or_fork_uid))
             new_elements.append(CatchPatternFailure(label=None))
             new_elements.append(Abort())
 
             new_elements.append(end_label_element)
-            new_elements.append(MergeHeads(fork_uid=fork_uid))
+            new_elements.append(MergeHeads(fork_uid=or_fork_uid))
             new_elements.append(CatchPatternFailure(label=None))
 
     else:

nemoguardrails/colang/v2_x/lang/transformer.py

@@ -168,15 +168,17 @@ def _flow_def(self, children: dict, meta: Meta) -> Flow:
 
                 assert member_name_el["_type"] == "var_name"
                 member_name = member_name_el["elements"][0][1:]
-                member_def = FlowReturnMemberDef(name=member_name)
+                return_member_def_obj = FlowReturnMemberDef(name=member_name)
 
                 # If we have a default value, we also use that
                 if len(return_member_def["elements"]) == 2:
                     default_value_el = return_member_def["elements"][1]
                     assert default_value_el["_type"] == "expr"
-                    member_def.default_value_expr = default_value_el["elements"][0]
+                    return_member_def_obj.default_value_expr = default_value_el[
+                        "elements"
+                    ][0]
 
-                return_member_defs.append(member_def)
+                return_member_defs.append(return_member_def_obj)
 
         elements[0:0] = [
             SpecOp(
@@ -546,7 +548,7 @@ def _non_var_spec_and(self, children: list, meta: Meta) -> dict:
             val["_source"] = self.__source(meta)
         return val
 
-    def __default__(self, data, children: list, meta: Meta) -> dict:
+    def __default__(self, data, children: list, meta: Meta) -> Any:
         """Default function that is called if there is no attribute matching ``data``
 
         Can be overridden. Defaults to creating

nemoguardrails/colang/v2_x/lang/utils.py

@@ -18,7 +18,7 @@
 
 
 def dataclass_to_dict(obj: Any) -> Any:
-    if is_dataclass(obj):
+    if is_dataclass(obj) and not isinstance(obj, type):
         return {k: dataclass_to_dict(v) for k, v in asdict(obj).items()}
     elif isinstance(obj, list):
         return [dataclass_to_dict(v) for v in obj]

nemoguardrails/colang/v2_x/runtime/eval.py

@@ -202,7 +202,8 @@ def _regex_findall(pattern: str, string: str) -> List[str]:
 def _pretty_str(data: Any) -> str:
     if isinstance(data, (dict, list, set)):
         string = json.dumps(data, indent=4)
-        return SimplifyFormatter().format(string)
+        # SimplifyFormatter.format() accepts string as well as LogRecord
+        return str(SimplifyFormatter().format(string))  # type: ignore
     return str(data)
 
 
@@ -245,27 +246,27 @@ def _get_type(val: Any) -> str:
 
 def _less_than_operator(v_ref: Any) -> ComparisonExpression:
     """Create less then comparison expression."""
-    return ComparisonExpression(lambda val, v_ref=v_ref: val < v_ref, v_ref)
+    return ComparisonExpression(lambda val: val < v_ref, v_ref)
 
 
 def _equal_or_less_than_operator(v_ref: Any) -> ComparisonExpression:
     """Create equal or less than comparison expression."""
-    return ComparisonExpression(lambda val, val_ref=v_ref: val <= val_ref, v_ref)
+    return ComparisonExpression(lambda val: val <= v_ref, v_ref)
 
 
 def _greater_than_operator(v_ref: Any) -> ComparisonExpression:
     """Create less then comparison expression."""
-    return ComparisonExpression(lambda val, val_ref=v_ref: val > val_ref, v_ref)
+    return ComparisonExpression(lambda val: val > v_ref, v_ref)
 
 
 def _equal_or_greater_than_operator(v_ref: Any) -> ComparisonExpression:
     """Create equal or less than comparison expression."""
-    return ComparisonExpression(lambda val, val_ref=v_ref: val >= val_ref, v_ref)
+    return ComparisonExpression(lambda val: val >= v_ref, v_ref)
 
 
 def _not_equal_to_operator(v_ref: Any) -> ComparisonExpression:
     """Create a not equal comparison expression."""
-    return ComparisonExpression(lambda val, val_ref=v_ref: val != val_ref, v_ref)
+    return ComparisonExpression(lambda val: val != v_ref, v_ref)
 
 
 def _flows_info(state: State, flow_instance_uid: Optional[str] = None) -> dict: