Final cleanups

Author: tgasser-nv

nemoguardrails/colang/runtime.py

@@ -32,33 +32,34 @@ def __init__(self, config: RailsConfig, verbose: bool = False):
         self.verbose = verbose
 
         # Register the actions with the dispatcher.
+        paths = config.imported_paths
+        import_paths = list(paths.values()) if paths else None
         self.action_dispatcher = ActionDispatcher(
             config_path=config.config_path,
-            import_paths=list(
-                config.imported_paths.values() if config.imported_paths else []
-            ),
+            import_paths=import_paths,
         )
 
         if hasattr(self, "_run_output_rails_in_parallel_streaming"):
             self.action_dispatcher.register_action(
-                getattr(self, "_run_output_rails_in_parallel_streaming"),
+                self._run_output_rails_in_parallel_streaming,  # type: ignore[attr-defined]
                 name="run_output_rails_in_parallel_streaming",
             )
 
         if hasattr(self, "_run_flows_in_parallel"):
             self.action_dispatcher.register_action(
-                getattr(self, "_run_flows_in_parallel"), name="run_flows_in_parallel"
+                self._run_flows_in_parallel,  # type: ignore[attr-defined]
+                name="run_flows_in_parallel",
             )
 
         if hasattr(self, "_run_input_rails_in_parallel"):
             self.action_dispatcher.register_action(
-                getattr(self, "_run_input_rails_in_parallel"),
+                self._run_input_rails_in_parallel,  # type: ignore[attr-defined]
                 name="run_input_rails_in_parallel",
             )
 
         if hasattr(self, "_run_output_rails_in_parallel"):
             self.action_dispatcher.register_action(
-                getattr(self, "_run_output_rails_in_parallel"),
+                self._run_output_rails_in_parallel,  # type: ignore[attr-defined]
                 name="run_output_rails_in_parallel",
             )
 

nemoguardrails/colang/v1_0/lang/comd_parser.py

@@ -362,22 +362,24 @@ def parse_md_file(file_name, content=None):
                 continue
 
             # Make sure we have the type of the symbol in the name of the symbol
-            if sym is not None:
-                sym = _get_typed_symbol_name(sym, symbol_type)
+            if not sym or not isinstance(sym, str):
+                raise ValueError(f"sym must be a non-empty string, found {sym}")
+
+            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: