oocana-python-executor 0.16.13__tar.gz → 0.16.14__tar.gz

{oocana_python_executor-0.16.13 → oocana_python_executor-0.16.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: oocana-python-executor
-Version: 0.16.13
+Version: 0.16.14
 Summary: a client subscribe mqtt topic to execute oocana's block
 Author-Email: l1shen <lishen1635@gmail.com>, yleaf <11785335+leavesster@users.noreply.github.com>
 License: MIT

{oocana_python_executor-0.16.13 → oocana_python_executor-0.16.14}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "oocana-python-executor"
-version = "0.16.13"
+version = "0.16.14"
 authors = [
     { name = "l1shen", email = "lishen1635@gmail.com" },
     { name = "yleaf", email = "11785335+leavesster@users.noreply.github.com" },

{oocana_python_executor-0.16.13 → oocana_python_executor-0.16.14}/python_executor/context.py

@@ -1,4 +1,6 @@
 import logging
+
+from .credential import replace_credential
 from oocana import Mainframe, Context, StoreKey, BlockInfo, BinValueDict, VarValueDict, InputHandleDef, is_bin_value, is_var_value
 from typing import Dict
 from .secret import replace_secret
@@ -24,6 +26,7 @@ def createContext(
             inputs_def_handles[k] = InputHandleDef(**v)
 
         inputs = replace_secret(inputs, inputs_def_handles, node_props.get("inputs_def_patch"))
+        inputs = replace_credential(inputs, inputs_def_handles)
 
         for k, v in inputs.items():
             input_def = inputs_def_handles.get(k)

oocana_python_executor-0.16.14/python_executor/credential.py

@@ -0,0 +1,43 @@
+from typing import Any, Dict
+from oocana import InputHandleDef
+class CredentialInput:
+    def __init__(self, type: str, value: str):
+        self.type = type
+        self.value = value
+
+def generate_credential_input(credential_path: str) -> CredentialInput | None:
+    """Generate a CredentialInput from a credential path string.
+
+    The credential path should be in the format `${{OO_CREDENTIAL:type,id}}`. If the format is incorrect,
+    the function returns None.
+    """
+
+    if not (credential_path.startswith("${{OO_CREDENTIAL:") and credential_path.endswith("}}")):
+        return None
+
+    credential_path = credential_path.removeprefix("${{OO_CREDENTIAL:").removesuffix("}}")
+    if credential_path:
+        try:
+            type, id = credential_path.split(",", maxsplit=1)
+            return CredentialInput(type, id)
+        except ValueError:
+            return None
+    return None
+
+def replace_credential(
+    inputs: Any,
+    input_def: Dict[str, InputHandleDef] | None = None,
+) -> Any:
+    if not isinstance(inputs, dict):
+        return inputs
+
+    assert isinstance(inputs, dict)
+
+    for k, v in inputs.items():
+        current_input_def = input_def.get(k) if input_def else None
+        if current_input_def is None:
+            continue
+        if isinstance(v, str) and current_input_def.is_credential_handle():
+            cred_input = generate_credential_input(v)
+            inputs[k] = cred_input
+    return inputs

oocana_python_executor-0.16.14/tests/test_credential.py

@@ -0,0 +1,102 @@
+import unittest
+from python_executor.credential import replace_credential, CredentialInput, generate_credential_input
+from oocana import InputHandleDef
+from typing import cast
+
+ORIGIN_VALUE = "Custom,credential_id"
+
+class TestCredential(unittest.TestCase):
+
+    def test_credential_fallback(self):
+        """Test credential fallback when not a credential handle"""
+        v = replace_credential({
+            "c": "aaaa"
+        }, {
+            "c": InputHandleDef(handle="c", json_schema={
+                "contentMediaType": "oomol/credential"
+            }, value=None)
+        })
+        # Should return CredentialInput when parsed successfully
+        cred_input = generate_credential_input("aaaa")
+        self.assertIsNone(cred_input)
+        self.assertIsNone(v.get("c"))
+
+    def test_replace_credential(self):
+        """Test basic credential replacement"""
+        v = replace_credential({
+            "c": f'${{{{OO_CREDENTIAL:{ORIGIN_VALUE}}}}}'
+        }, {
+            "c": InputHandleDef(handle="c", json_schema={
+                "contentMediaType": "oomol/credential"
+            }, value=None)
+        })
+        cred_input = v.get("c")
+        self.assertIsInstance(cred_input, CredentialInput)
+        self.assertEqual(cred_input.type, "Custom")
+        self.assertEqual(cred_input.value, "credential_id")
+
+
+    def test_credential_without_content_media(self):
+        """Test multiple credentials replacement"""
+        v = replace_credential({
+            "c": f'${{{{OO_CREDENTIAL:{ORIGIN_VALUE}}}}}',
+            "a": f'${{{{OO_CREDENTIAL:{ORIGIN_VALUE}}}}}'
+        }, {
+            "c": InputHandleDef(handle="c", json_schema={
+                "contentMediaType": "oomol/credential"
+            }, value=None)
+        })
+        cred_input_c = v.get("c")
+        cred_input_a = v.get("a")
+
+        self.assertIsInstance(cred_input_c, CredentialInput)
+        self.assertEqual(cred_input_c.type, "Custom")
+
+        # 'a' should remain unchanged since no input_def for it
+        self.assertEqual(cred_input_a, f'${{{{OO_CREDENTIAL:{ORIGIN_VALUE}}}}}')
+
+    def test_credential_in_other_string(self):
+        """Test credential pattern inside other string (should not be replaced)"""
+        no_replace_value = f'${{{{OO_CREDENTIAL:{ORIGIN_VALUE}}}}}_bbb'
+        v = replace_credential({
+            "c": no_replace_value
+        }, {
+            "c": InputHandleDef(handle="c", json_schema={
+                "contentMediaType": "oomol/credential"
+            }, value=None)
+        })
+        # Should not be replaced because it doesn't match exact format
+        self.assertEqual(v.get("c"), None)
+
+    def test_generate_credential_input_valid(self):
+        """Test valid credential input generation"""
+        result = generate_credential_input("${{OO_CREDENTIAL:AWS,my_credential_id}}")
+        self.assertIsInstance(result, CredentialInput)
+        result = cast(CredentialInput, result)
+        self.assertEqual(result.type, "AWS")
+        self.assertEqual(result.value, "my_credential_id")
+
+    def test_generate_credential_input_invalid_format(self):
+        """Test invalid credential input format"""
+        # Missing prefix
+        result = generate_credential_input("AWS,my_credential_id")
+        self.assertIsNone(result)
+
+        # Missing suffix
+        result = generate_credential_input("${{OO_CREDENTIAL:AWS,my_credential_id")
+        self.assertIsNone(result)
+
+        # Wrong prefix
+        result = generate_credential_input("${{OO_SECRET:AWS,my_credential_id}}")
+        self.assertIsNone(result)
+
+        # Empty content
+        result = generate_credential_input("${{OO_CREDENTIAL:}}")
+        self.assertIsNone(result)
+
+        # Missing comma
+        result = generate_credential_input("${{OO_CREDENTIAL:AWS}}")
+        self.assertIsNone(result)
+
+if __name__ == '__main__':
+    unittest.main()