Merge pull request #94 from auscompgeek/cleanup-feedback

virtuald · web-flow · commit 9ef1bc02ac5b · 2018-02-11T10:25:48.000-05:00
Further clean up, expose feedback decorator
diff --git a/magicbot/__init__.py b/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
diff --git a/magicbot/magic_tunable.py b/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
diff --git a/magicbot/magicrobot.py b/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:
