Add CallableAction implementation and Action interface

Author: idle-code

contextshell/Action.py

@@ -0,0 +1,9 @@
+from abc import ABC, abstractmethod
+from contextshell.NodePath import NodePath
+from typing import Dict, Union, Any
+
+
+class Action(ABC):
+    @abstractmethod
+    def __call__(self, target: NodePath, action: NodePath, arguments: Dict[Union[NodePath, int], Any]):
+        raise NotImplementedError()

contextshell/CallableAction.py

@@ -0,0 +1,25 @@
+from collections import OrderedDict
+from typing import Callable, Dict, Union, Any, Tuple, List
+
+from contextshell.Action import Action
+from contextshell.NodePath import NodePath
+
+
+class CallableAction(Action):
+    def __init__(self, implementation: Callable):
+        self.implementation = implementation
+
+    def __call__(self, target: NodePath, action: NodePath, arguments: Dict[Union[NodePath, int], Any]):
+        args, kwargs = CallableAction.unpack_argument_tree(arguments)
+        return self.implementation(target, action, *args, **kwargs)
+
+    @staticmethod
+    def unpack_argument_tree(arguments: Dict[Union[NodePath, int], Any]) -> Tuple[List[Any], Dict[NodePath, Any]]:
+        args = list()
+        kwargs = OrderedDict()
+        for key, value in arguments.items():
+            if isinstance(key, int):
+                args.append(value)
+            else:
+                kwargs[key] = value
+        return args, kwargs

contextshell/NodeTreeRoot.py

@@ -1,7 +1,7 @@
 from contextshell.Node import Node
 from contextshell.NodePath import NodePath
 from contextshell.TreeRoot import TreeRoot
-from typing import Callable, Iterable, List
+from typing import Callable, List
 
 
 # TODO: check how implement TemporaryTreeRoot (based on NodeTreeRoot)

tests/unit/CallableActionTests.py

@@ -0,0 +1,60 @@
+import unittest
+from unittest.mock import Mock, ANY
+from contextshell.NodePath import NodePath as np
+from collections import OrderedDict
+
+
+def create_action(*args, **kwargs):
+    from contextshell.CallableAction import CallableAction
+    return CallableAction(*args, **kwargs)
+
+
+class CallTests(unittest.TestCase):
+    def test_target_path_is_passed(self):
+        implementation = Mock()
+        action = create_action(implementation)
+
+        action(np('.target'), np('action'), OrderedDict())
+
+        self.assertIn(np('.target'), *implementation.call_args)
+
+    def test_action_path_is_passed(self):
+        implementation = Mock()
+        action = create_action(implementation)
+
+        action(np('.target'), np('action'), OrderedDict())
+
+        self.assertIn(np('action'), *implementation.call_args)
+
+    def test_arguments_are_unpacked_to_list(self):
+        implementation = Mock()
+        action = create_action(implementation)
+        arguments = OrderedDict([
+            (0, 'foo'),
+            (1, 'bar'),
+            ])
+
+        action(np('.target'), np('action'), arguments)
+
+        implementation.assert_called_with(ANY, ANY, 'foo', 'bar')
+
+    def test_arguments_are_unpacked_to_keywords(self):
+        implementation = Mock()
+        action = create_action(implementation)
+        arguments = OrderedDict([
+            ('foo', 'spam'),
+            ('bar', 2),
+            ])
+
+        action(np('.target'), np('action'), arguments)
+
+        implementation.assert_called_with(ANY, ANY, foo='spam', bar=2)
+
+    def test_return_value_is_forwarded(self):
+        implementation = Mock()
+        implementation.return_value = 'VALUE'
+        action = create_action(implementation)
+
+        action_result = action(np('.target'), np('action'), OrderedDict())
+
+        self.assertEqual('VALUE', action_result)

tests/unit/NodeTreeRootTests.py

@@ -264,14 +264,14 @@ class ListActions(unittest.TestCase):
         'set',
     ]
 
-    def test_root_actions(self):
+    def test_default_actions(self):
         tree = create_tree()
 
         root_actions = tree.list_actions(np('.'))
 
         self.assertSequenceEqual(ListActions.default_actions, root_actions)
 
-    def test_include_parent_actions(self):
+    def test_node_specific_actions(self):
         tree = create_tree()
         child_path = np('.child')
         tree.create(child_path)

todo.yaml

@@ -31,11 +31,27 @@ Issues:
       '.remote.hour: set 18' should invoke '.hour: set 18' on the remote host
     - Return value forwarding
       '.remote.minutes: get' should return value to the local system
-    - Local action should be able operate on remote tree
-      'local_action .remote.foo' - local_action should be able to access basic operations of remote '.foo' node
-      - by basic operations I understand CRUD-like ones
-    - Remote actions should be able to use local tree values
-      '.remote.foo: remote_action .bar' - remote action is able to access basic operations of local '.bar' node
+    - Action arguments can be represented as tree
+      E.g "foo bar=123 bar.spam=arg" will result in following argument tree
+      """
+      [0] foo
+      bar 123
+      bar.spam arg
+      """
+    - How to pass argument tree into action?
+      - >>> Serialization into ordered dictionary
+        - Easy to implement
+        - Backward-compatible with common functions
+      - Path to the temporary tree
+        - Requires backend to support temporary trees
+        - E.g. File backend would require temporary files just for arguments
+      - New tree type
+        - Requires architectual change?
+    - What data is passed to the action on invocation?
+      - Target path
+      - Action name
+      - Arguments
+      Note: Tree/Root is not passed as it doesn't change between invocations
 
 Filesystem backend:
   - Custom types for different files
@@ -46,7 +62,6 @@ Filesystem backend:
 Network backend:
   - Commands issued are executed on the remote host
 
-
 Tree backend:
   - Serialization to file
     - Values