refactor(business-rules): rule_name -> business_rule_name

Internal parameters, locals, _RunTarget's field, the name validator
(_validate_business_rule_name) and its constants now say
business_rule_name, matching the wire's businessRuleName and
BusinessRuleRunResult.business_rule_name. The public run(name, input)
and its error messages are unchanged.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: ashishupadhyay88

packages/uipath-platform/src/uipath/platform/business_rules/_business_rules_service.py

@@ -29,8 +29,8 @@
 _EVALUATE_ENDPOINT = Endpoint("businessrules_/v1/business-rules/evaluate")
 
 _MAX_INPUT_KEYS = 256
-_MAX_RULE_NAME_LENGTH = 256
-_FORBIDDEN_RULE_NAME_PARTS = ("/", "\\", "..", "%")
+_MAX_BUSINESS_RULE_NAME_LENGTH = 256
+_FORBIDDEN_BUSINESS_RULE_NAME_PARTS = ("/", "\\", "..", "%")
 
 
 @dataclass(frozen=True)
@@ -41,7 +41,7 @@ class _RunTarget:
     send, or a path still to look up.
     """
 
-    rule_name: str
+    business_rule_name: str
     folder_key: Optional[str]
     folder_path: Optional[str]
 
@@ -124,7 +124,7 @@ def run(
         """
         run_target = self._prepare_run(name, input, folder_key, folder_path)
         request_spec = self._evaluate_spec(
-            run_target.rule_name,
+            run_target.business_rule_name,
             input,
             folder_key=self._resolve_folder_key(run_target),
             version=version,
@@ -175,7 +175,7 @@ async def run_async(
         """
         run_target = self._prepare_run(name, input, folder_key, folder_path)
         request_spec = self._evaluate_spec(
-            run_target.rule_name,
+            run_target.business_rule_name,
             input,
             folder_key=await self._resolve_folder_key_async(run_target),
             version=version,
@@ -189,7 +189,7 @@ async def run_async(
 
     def _prepare_run(
         self,
-        rule_name: str,
+        business_rule_name: str,
         rule_input: Dict[str, Any],
         folder_key: Optional[str],
         folder_path: Optional[str],
@@ -199,13 +199,15 @@ def _prepare_run(
         Applies a binding, validates the arguments and picks the folder, so only
         the folder lookup and the request itself differ between the two.
         """
-        rule_name, folder_key, folder_path = self._apply_binding(
-            rule_name, folder_key, folder_path
+        business_rule_name, folder_key, folder_path = self._apply_binding(
+            business_rule_name, folder_key, folder_path
         )
-        _validate_run_arguments(rule_name, rule_input)
+        _validate_run_arguments(business_rule_name, rule_input)
         selected_key, selected_path = self._select_folder(folder_key, folder_path)
         return _RunTarget(
-            rule_name=rule_name, folder_key=selected_key, folder_path=selected_path
+            business_rule_name=business_rule_name,
+            folder_key=selected_key,
+            folder_path=selected_path,
         )
 
     @resource_override(resource_type="businessRule")
@@ -217,21 +219,27 @@ def _overridden_resource(
         return name, folder_path
 
     def _apply_binding(
-        self, rule_name: str, folder_key: Optional[str], folder_path: Optional[str]
+        self,
+        business_rule_name: str,
+        folder_key: Optional[str],
+        folder_path: Optional[str],
     ) -> Tuple[str, Optional[str], Optional[str]]:
         """Apply a businessRule binding, if one remaps this rule.
 
         The binding names a folder by path. When it applies, that folder
         replaces whichever folder the caller gave, including a folder_key, which
         the override decorator alone would leave in place next to the new path.
         """
-        bound_rule_name, bound_folder_path = self._overridden_resource(
-            rule_name, folder_path=folder_path
+        bound_business_rule_name, bound_folder_path = self._overridden_resource(
+            business_rule_name, folder_path=folder_path
+        )
+        is_remapped = (bound_business_rule_name, bound_folder_path) != (
+            business_rule_name,
+            folder_path,
         )
-        is_remapped = (bound_rule_name, bound_folder_path) != (rule_name, folder_path)
         if is_remapped and bound_folder_path:
             folder_key = None
-        return bound_rule_name, folder_key, bound_folder_path
+        return bound_business_rule_name, folder_key, bound_folder_path
 
     def _select_folder(
         self, folder_key: Optional[str], folder_path: Optional[str]
@@ -279,7 +287,7 @@ async def _resolve_folder_key_async(self, run_target: _RunTarget) -> str:
 
     def _evaluate_spec(
         self,
-        rule_name: str,
+        business_rule_name: str,
         rule_input: Dict[str, Any],
         *,
         folder_key: str,
@@ -290,7 +298,7 @@ def _evaluate_spec(
         # The service resolves the rule in this folder and files the run's trace
         # and audit record under it.
         request_body: Dict[str, Any] = {
-            "businessRuleName": rule_name,
+            "businessRuleName": business_rule_name,
             "input": rule_input,
         }
         if _has_value(version):
@@ -377,22 +385,26 @@ def _has_value(text: Optional[str]) -> bool:
     return bool(text and text.strip())
 
 
-def _validate_run_arguments(rule_name: str, rule_input: Dict[str, Any]) -> None:
-    _validate_rule_name(rule_name)
+def _validate_run_arguments(
+    business_rule_name: str, rule_input: Dict[str, Any]
+) -> None:
+    _validate_business_rule_name(business_rule_name)
     _validate_input(rule_input)
 
 
-def _validate_rule_name(rule_name: str) -> None:
-    if not _has_value(rule_name):
+def _validate_business_rule_name(business_rule_name: str) -> None:
+    if not _has_value(business_rule_name):
         raise ValueError("name must be specified")
-    if len(rule_name) > _MAX_RULE_NAME_LENGTH:
-        raise ValueError(f"name must not exceed {_MAX_RULE_NAME_LENGTH} characters")
-    for forbidden_part in _FORBIDDEN_RULE_NAME_PARTS:
-        if forbidden_part in rule_name:
+    if len(business_rule_name) > _MAX_BUSINESS_RULE_NAME_LENGTH:
+        raise ValueError(
+            f"name must not exceed {_MAX_BUSINESS_RULE_NAME_LENGTH} characters"
+        )
+    for forbidden_part in _FORBIDDEN_BUSINESS_RULE_NAME_PARTS:
+        if forbidden_part in business_rule_name:
             raise ValueError(f"name must not contain '{forbidden_part}'")
     # Control characters only (Unicode category Cc), as the .NET client checks;
     # a non-breaking or zero-width space is allowed in a name.
-    if any(unicodedata.category(character) == "Cc" for character in rule_name):
+    if any(unicodedata.category(character) == "Cc" for character in business_rule_name):
         raise ValueError("name must not contain control characters")
 
 

packages/uipath-platform/tests/services/test_business_rules_service.py

@@ -82,7 +82,7 @@ def _single_decision_result(**outputs: Any) -> dict[str, Any]:
 
 class TestRunContext:
     @pytest.mark.parametrize(
-        "rule_name",
+        "business_rule_name",
         [
             "",
             "   ",
@@ -97,31 +97,31 @@ class TestRunContext:
         ],
     )
     def test_rejects_unsafe_rule_names(
-        self, service: BusinessRulesService, rule_name: str
+        self, service: BusinessRulesService, business_rule_name: str
     ) -> None:
         with pytest.raises(ValueError, match="name"):
-            service.run(rule_name, {}, folder_key=FOLDER_KEY)
+            service.run(business_rule_name, {}, folder_key=FOLDER_KEY)
 
     @pytest.mark.parametrize(
-        "rule_name",
+        "business_rule_name",
         ["Loan\u00a0Pricing", "Loan\u200bPricing", "Préstamo Tarifa", "贷款定价"],
     )
     def test_accepts_names_the_dotnet_client_accepts(
         self,
         httpx_mock: HTTPXMock,
         service: BusinessRulesService,
         evaluate_url: str,
-        rule_name: str,
+        business_rule_name: str,
     ) -> None:
         # Only control characters are refused, as in the .NET client: a
         # non-breaking space pasted into a name is not one.
         httpx_mock.add_response(url=evaluate_url, json=_service_response())
 
-        service.run(rule_name, {}, folder_key=FOLDER_KEY)
+        service.run(business_rule_name, {}, folder_key=FOLDER_KEY)
 
         request = httpx_mock.get_request()
         assert request is not None
-        assert json.loads(request.content)["businessRuleName"] == rule_name
+        assert json.loads(request.content)["businessRuleName"] == business_rule_name
 
     @pytest.mark.parametrize("value", [["age", 14], "age=14", 14])
     def test_rejects_non_mapping_input(