Further clean up, expose feedback decorator

This moves the feedback decorator to the magicbot.magic_tunable module,
where it makes more sense to live.

This also exposes the feedback decorator, as it was never exported.

Add a hint in the docs to also see LiveWindow, as that may fit teams'
needs without the need for this.

Also delete the dead autosend code, as this is what it ended up being.

Finally, this cleans up and fixes a few gripes I had:

* The NetworkTables key used didn't match those of tunables.
* Decorating methods in your robot class with feedback didn't work.
* The decorator required the use of an extra set of parentheses.

Author: auscompgeek

magicbot/__init__.py

@@ -1,6 +1,6 @@
 
 from .magicrobot import MagicRobot
-from .magic_tunable import tunable
+from .magic_tunable import feedback, tunable
 from .magic_reset import will_reset_to
 
 from .state_machine import AutonomousStateMachine, StateMachine, default_state, state, timed_state

magicbot/magic_tunable.py

@@ -1,3 +1,5 @@
+import functools
+import inspect
 
 from networktables import NetworkTables
 from ntcore.value import Value
@@ -123,34 +125,93 @@ def setup_tunables(component, cname, prefix='components'):
         prop._ntattr = ntattr
 
 
-# TODO
-#def autosend(f=None):
-#    '''
-#        Decorator used to send variables to DS::
-#        
-#            
-#        
-#            class MyComponent:
-#            
-#                @autosend
-#                def my_sensor(self):
-#                    return self.limit_switch.get()
-#                    
-#                ...
-#                    
-#            class MyRobot:
-#            
-#                mine = MyComponent 
-#                
-#        This will cause the output of this function to be sent
-#        to ``/components/mine/my_sensor``
-#    '''
-#    
-#    
-#    def _get(self):
-#        return self._Magicbot__autosend.get(f)
-#    
-#    prop = _AutosendProperty(fget=_get)
-#    prop.f = f
-#    
-#    return prop
+def feedback(f=None, *, key: str = None):
+    """
+    This decorator allows you to create NetworkTables values that are
+    automatically updated with the return value of a method.
+
+    ``key`` is an optional parameter, and if it is not supplied,
+    the key will default to the method name with a leading ``get_`` removed.
+    If the method does not start with ``get_``, the key will be the full
+    name of the method.
+
+    The key of the NetworkTables value will vary based on what kind of
+    object the decorated method belongs to:
+
+    * A component: ``/components/COMPONENTNAME/VARNAME``
+    * Your main robot class: ``/robot/VARNAME``
+
+    The NetworkTables value will be auto-updated in all modes (except test mode).
+
+    .. warning:: The function should only act as a getter, and must not
+                 take any arguments (other than self).
+
+    Example::
+
+        from magicbot import feedback
+
+        class MyComponent:
+            navx: ...
+
+            @feedback
+            def get_angle(self):
+                return self.navx.getYaw()
+
+        class MyRobot(magicbot.MagicRobot):
+            my_component: MyComponent
+
+            ...
+
+    In this example, the NetworkTable key is stored at
+    ``/components/my_component/angle``.
+
+    .. seealso:: :class:`~wpilib.livewindow.LiveWindow` may suit your needs,
+                 especially if you wish to monitor WPILib objects.
+
+    .. versionadded:: 2018.1.0
+    """
+    if f is None:
+        return functools.partial(feedback, key=key)
+
+    if not callable(f):
+        raise TypeError('Illegal use of feedback decorator on non-callable {!r}'.format(f))
+    sig = inspect.signature(f)
+    name = f.__name__
+
+    if len(sig.parameters) != 1:
+        raise ValueError("{} may not take arguments other than 'self' (must be a simple getter method)".format(name))
+
+    # Set attributes to be checked during injection
+    f.__feedback__ = True
+    f.__key__ = key
+
+    return f
+
+
+def collect_feedbacks(component, cname: str, prefix='components'):
+    """
+    Finds all methods decorated with :func:`feedback` on an object
+    and returns a list of 2-tuples (method, NetworkTables entry).
+
+    .. note:: This isn't useful for normal use.
+    """
+    if prefix is None:
+        prefix = '/%s' % cname
+    else:
+        prefix = '/%s/%s' % (prefix, cname)
+
+    feedbacks = []
+
+    for name, method in inspect.getmembers(component, inspect.ismethod):
+        if getattr(method, '__feedback__', False):
+            key = method.__key__
+            if key is None:
+                if name.startswith('get_'):
+                    key = name[4:]
+                else:
+                    key = name
+
+            entry = NetworkTables.getEntry('%s/%s' % (prefix, key))
+            feedbacks.append((method, entry))
+
+    return feedbacks

magicbot/magicrobot.py

@@ -13,64 +13,11 @@
 
 from networktables import NetworkTables
 
-from .magic_tunable import setup_tunables, _TunableProperty
+from .magic_tunable import setup_tunables, _TunableProperty, collect_feedbacks
 from .magic_reset import will_reset_to
 
 __all__ = ['MagicRobot']
 
-def feedback(key=None):
-    """
-    If this decorator is applied to a function,
-    its return value will automatically be sent
-    to NetworkTables at key ``/robot/components/component/key``.
-
-    ``key`` is an optional parameter, and if it is not supplied,
-    the key will default to the method name with 'get_' removed.
-    If the method does not start with 'get_', the key will be the full
-    name of the method.
-
-    .. note:: The function will automatically be called in disabled,
-              autonomous, and teleop.
-
-    .. warning:: The function should only act as a getter, and accept
-                 no arguments.
-
-    Example::
-
-        class Component1:
-
-            @feedback()
-            def get_angle(self):
-                return self.navx.getYaw()
-
-    In this example, the NetworkTable key is stored at
-    ``/robot/components/component1/angle``.
-    """
-    def decorator(func):
-        if not callable(func):
-            raise ValueError('Illegal use of feedback decorator on non-callable {!r}'.format(func))
-        sig = inspect.signature(func)
-        name = func.__name__
-
-        if len(sig.parameters) != 1:
-            raise ValueError("{} may not take arguments other than 'self' (must be a simple getter method)".format(name))
-
-        nt_key = key
-        if nt_key is None:
-            # If no key is passed, get key from method name.
-            # -1 instead of 1 in case 'get_' is not present,
-            # in which case the key will be the method name
-
-            if name.startswith('get_'):
-                nt_key = name[4:]
-            else:
-                nt_key = name
-        # Set '__feedback__ attribute to be checked during injection
-        func.__feedback__ = True
-        # Store key within the function to avoid using class dictionary
-        func.__key__ = nt_key
-        return func
-    return decorator
 
 class MagicRobot(wpilib.SampleRobot,
                  metaclass=OrderedClass):
@@ -380,8 +327,6 @@ def operatorControl(self):
 
         while self.isOperatorControl() and self.isEnabled():
 
-            #self._update_autosend()
-            
             try:
                 self.teleopPeriodic()
             except:
@@ -504,6 +449,7 @@ def _create_components(self):
         for cname, component in components:
             self._components.append(component)
             setup_tunables(component, cname, 'components')
+            self._feedbacks += collect_feedbacks(component, cname, 'components')
             self._setup_vars(cname, component)
             self._setup_reset_vars(component)
 
@@ -515,6 +461,7 @@ def _create_components(self):
 
         # And for self too
         setup_tunables(self, 'robot', None)
+        self._feedbacks += collect_feedbacks(self, 'robot', None)
 
         # Call setup functions for components
         for cname, component in components:
@@ -532,7 +479,6 @@ def _create_component(self, name, ctyp):
 
         # Automatically inject a logger object
         component.logger = logging.getLogger(name)
-        component._Magicbot__autosend = {}
 
         self.logger.info("-> %s (class: %s)", name, ctyp.__name__)
 
@@ -585,10 +531,6 @@ def _setup_vars(self, cname, component):
 
             self._inject(n, inject_type, cname, component)
 
-        for (name, method) in inspect.getmembers(component, predicate=inspect.ismethod):
-            if getattr(method, '__feedback__', False):
-                self._feedbacks.append((component, cname, name))
-
     def _inject(self, n, inject_type, cname, component):
         # Retrieve injectable object
         injectable = self._injectables.get(n)
@@ -610,11 +552,6 @@ def _inject(self, n, inject_type, cname, component):
         setattr(component, n, injectable)
         self.logger.debug("-> %s as %s.%s", injectable, cname, n)
 
-        # XXX
-        #if is_autosend:
-            # where to store the nt key?
-        #    component._Magicbot__autosend[prop.f] = None
-    
     def _setup_reset_vars(self, component):
         reset_dict = {}
 
@@ -629,22 +566,15 @@ def _setup_reset_vars(self, component):
         if reset_dict:
             component.__dict__.update(reset_dict)
             self._reset_components.append((reset_dict, component))
-    
-    #def _update_autosend(self):
-    #    # seems like this should just be a giant list instead
-    #    for component in self._components:
-    #        d = component._Magicbot__autosend
-    #        for f in d.keys():
-    #            d[f] = f(component)     
 
     def _update_feedback(self):
-        for (component, cname, name) in self._feedbacks:
+        for method, entry in self._feedbacks:
             try:
-                func = getattr(component, name)
+                value = method()
             except:
+                self.onException()
                 continue
-            # Put ntvalue at /robot/components/component/key
-            self.__nt.putValue('/components/{0}/{1}'.format(cname, func.__key__), func())
+            entry.setValue(value)
 
     def _execute_components(self):
         for component in self._components: