robotpy-pykit 0.1.3b1__py3-none-any.whl

pykit/autolog.py

@@ -0,0 +1,329 @@
+import typing
+import inspect
+import gc
+import dataclasses
+
+from wpiutil import wpistruct
+
+from pykit.logtable import LogTable
+from pykit.logvalue import LogValue
+
+
+class AutoLogClassOutputManager:
+    """
+    A manager class for handling automatic logging of dataclass fields.
+    """
+
+    logged_classes = []
+
+    @classmethod
+    def register_class(cls, class_to_register: typing.Any):
+        """
+        Registers a class for automatic logging.
+
+        :param class_type: The class type to register.
+        """
+        cls.logged_classes.append(class_to_register)
+
+
+class AutoLogInputManager:
+    """
+    A manager class for handling automatic input loading of dataclass fields.
+    """
+
+    logged_classes = []
+
+    @classmethod
+    def register_class(cls, class_to_register: typing.Any):
+        """
+        Registers a class for automatic input loading.
+
+        :param class_type: The class type to register.
+        """
+        cls.logged_classes.append(class_to_register)
+
+    @classmethod
+    def getInputs(cls) -> typing.List[typing.Any]:
+        return cls.logged_classes
+
+
+class AutoLogOutputManager:
+    """
+    A manager class for handling automatic logging of output members (fields/methods).
+    """
+
+    # Stores a dictionary where keys are class types and values are lists of
+    # dictionaries, each representing a decorated member.
+    # Each member dictionary contains:
+    #   'name': str (name of the field or method)
+    #   'is_method': bool (True if it's a method, False if it's a field)
+    #   'log_type': LogValue.LoggableType (the type to log as)
+    #   'custom_type': str (optional custom type string)
+    logged_members: typing.Dict[
+        typing.Type, typing.List[typing.Dict[str, typing.Any]]
+    ] = {}
+
+    root_cache = []
+
+    @classmethod
+    def publish_all(cls, table: LogTable, root_instance=None):
+        if root_instance is None:
+            if cls.root_cache:
+                root_instance = cls.root_cache
+            else:
+                root_instance = []
+                for clS in cls.logged_members:
+                    for instance in gc.get_referrers(
+                        clS
+                    ):  # at runtime take all instances that exist of registered classes
+                        if instance.__class__ == clS:
+                            root_instance.append(instance)
+                cls.root_cache = root_instance
+        for instance in root_instance:
+            cls.publish(instance, table)
+            if (
+                hasattr(
+                    instance, "_do_autolog"
+                )  # is the attempted class actually marked for autolog?
+                and getattr(instance, "_do_autolog")
+                and hasattr(instance, "__dict__")
+                and not isinstance(instance, staticmethod)
+            ):
+                # be recursive, there are sub-members, but only on classes marked for autolog
+                cls.publish_all(table, instance.__dict__.values())
+
+    @classmethod
+    def register_member(
+        cls,
+        class_type: typing.Type,
+        member_name: str,
+        is_method: bool,
+        log_type: LogValue.LoggableType,
+        key: str = "",
+        custom_type: str = "",
+    ):
+        """
+        Registers a member (field or method) of a class for automatic output logging.
+        """
+        if class_type not in cls.logged_members:
+            cls.logged_members[class_type] = []
+        cls.logged_members[class_type].append(
+            {
+                "name": member_name,
+                "is_method": is_method,
+                "log_type": log_type,
+                "key": key,
+                "custom_type": custom_type,
+            }
+        )
+
+    @classmethod
+    def publish(cls, instance: typing.Any, table: LogTable):
+        """
+        Publishes the values of all registered members of an instance to a LogTable.
+        """
+        class_type = type(instance)
+        if class_type in cls.logged_members:
+            for member_info in cls.logged_members[class_type]:
+                member_name = member_info["name"]
+                is_method = member_info["is_method"]
+                log_type = member_info["log_type"]
+                custom_type = member_info["custom_type"]
+
+                key = member_info["key"] or member_name
+
+                value = None
+                if is_method:
+                    # Assume methods are getters and take no arguments
+                    value = getattr(instance, member_name)()
+                else:
+                    value = getattr(instance, member_name)
+
+                # Put the value into the log table with the specified type
+                if hasattr(value, "WPIStruct") or (
+                    hasattr(value, "__iter__")
+                    and len(value) > 0
+                    and hasattr(value[0], "WPIStruct")
+                ):
+                    table.put(key, value)
+                else:
+                    log_value = LogValue(value, custom_type)
+                    if log_type is not None:
+                        # Override the inferred log_type if explicitly provided in the decorator
+                        log_value.log_type = log_type
+
+                    # if table.writeAllowed(
+                    #     full_key, log_value.log_type, log_value.custom_type
+                    # ):
+                    table.putValue(key, log_value)
+
+
+def autolog_output(
+    key: str,
+    log_type: typing.Optional[LogValue.LoggableType] = None,
+    custom_type: str = "",
+):
+    """
+    A decorator for methods or fields in a class to automatically log their output.
+    """
+
+    def decorator(member):
+        # This part is tricky because Python decorators for methods/fields
+        # don't directly give you the class at definition time.
+        # We'll store a temporary attribute and process it in a class decorator.
+        if inspect.isfunction(member):
+            # It's a method
+            print(f"[AugoLogOutput] DEBUG: Setting up log for {key}")
+            member._autolog_output_info = {
+                "is_method": True,
+                "log_type": log_type,
+                "custom_type": custom_type,
+                "key": key,
+            }
+        else:
+            # It's a field (this case is harder to handle directly with a decorator
+            # on the field itself, usually done via a class decorator or metaclass)
+            # For now, we'll assume it's a method or a property-like descriptor.
+            # If it's a simple field, the class decorator approach is more robust.
+            # Let's assume for now that direct field decoration will be handled
+            # by a class decorator that scans for these attributes.
+            # For direct field decoration, we might need a descriptor.
+            # For simplicity, let's focus on methods first, or assume a class
+            # decorator will pick up field annotations.
+            # For now, let's make it work for methods and properties.
+            member._autolog_output_info = {
+                "is_method": False,  # This will be true for properties too
+                "log_type": log_type,
+                "custom_type": custom_type,
+                "key": key,
+            }
+        return member
+
+    return decorator
+
+
+def autologgable_output(cls):
+    """
+    A class decorator that scans for methods/fields decorated with @autolog_output
+    and registers them with AutoLogOutputManager.
+    """
+    for name in dir(cls):
+        member = getattr(cls, name)
+        if hasattr(member, "_autolog_output_info"):
+            info = member._autolog_output_info
+            AutoLogOutputManager.register_member(
+                cls,
+                name,
+                info["is_method"],
+                info["log_type"],
+                info["key"],
+                info["custom_type"],
+            )
+
+    setattr(cls, "_do_autolog", True)
+    return cls
+
+
+def autolog(cls=None, /):
+    """
+    A class decorator that adds 'toLog' and 'fromLog' methods to a dataclass for automatic logging.
+
+    The 'toLog' method serializes the dataclass fields to a LogTable.
+    The 'fromLog' method deserializes the data from a LogTable into the dataclass fields.
+
+    This decorator is designed to be used with dataclasses and supports nested dataclasses
+    decorated with @autolog.
+    """
+
+    def wrap(clS):
+        resolved_hints = typing.get_type_hints(clS)
+        field_names = [field.name for field in dataclasses.fields(clS)]
+
+        def toLog(self, table: LogTable, prefix: str):
+            """
+            Recursively logs the fields of the dataclass to a LogTable.
+
+            :param table: The LogTable instance to write to.
+            :param prefix: The prefix for the log entries.
+            """
+            for name in field_names:
+                value = getattr(self, name)
+                field_prefix = f"{prefix}/{name}"
+                if hasattr(value, "toLog"):
+                    value.toLog(table, field_prefix)
+                else:
+                    table.put(field_prefix, value)
+
+        def fromLog(self, table: LogTable, prefix: str):
+            """
+            Recursively reads the fields of the dataclass from a LogTable.
+
+            :param table: The LogTable instance to read from.
+            :param prefix: The prefix for the log entries.
+            """
+            for name in field_names:
+                field_prefix = f"{prefix}/{name}"
+
+                value = getattr(self, name)
+                if hasattr(value, "fromLog"):
+                    value.fromLog(table, field_prefix)
+                else:
+                    field_type = resolved_hints[name]
+                    new_value = None
+
+                    origin = typing.get_origin(field_type)
+                    if origin is list:
+                        list_type = typing.get_args(field_type)[0]
+                        if list_type is bool:
+                            new_value = table.getBooleanArray(field_prefix, value)
+                        elif list_type is int:
+                            new_value = table.getIntegerArray(field_prefix, value)
+                        elif list_type is float:
+                            new_value = table.getDoubleArray(field_prefix, value)
+                        elif list_type is str:
+                            new_value = table.getStringArray(field_prefix, value)
+                        elif hasattr(list_type, "WPIStruct"):
+                            new_value = wpistruct.unpackArray(
+                                list_type, table.getRaw(field_prefix, b"")
+                            )
+                            # is it struct?
+                        else:
+                            print(
+                                f"[AutoLog] Failed to read of type {field_type} with value {list_type}"
+                            )
+                    else:
+                        if field_type is bool:
+                            new_value = table.getBoolean(field_prefix, value)
+                        elif field_type is int:
+                            new_value = table.getInteger(field_prefix, value)
+                        elif field_type is float:
+                            new_value = table.getDouble(field_prefix, value)
+                        elif field_type is str:
+                            new_value = table.getString(field_prefix, value)
+                        elif hasattr(field_type, "WPIStruct"):
+                            new_value = wpistruct.unpack(
+                                field_type, table.getRaw(field_prefix, b"")
+                            )
+                            # is it struct?
+                        else:
+                            print(f"[AutoLog] Failed to read of type {field_type}")
+
+                    if new_value is not None:
+                        setattr(self, name, new_value)
+
+        def registerAutologged(self) -> None:
+            print(f"[AutoLog] registering {self.name}")
+            AutoLogInputManager.register_class(self)
+
+        setattr(clS, "toLog", toLog)
+        setattr(clS, "fromLog", fromLog)
+        # https://docs.python.org/3/library/dataclasses.html#dataclasses.__post_init__
+        # https://docs.python.org/3/reference/expressions.html#private-name-mangling
+        setattr(cls, f"_{clS.__class__.__name__}__post_init__", registerAutologged)
+
+        return clS
+
+    if cls is None:
+        return wrap
+
+    return wrap(cls)

pykit/inputs/loggableds.py

@@ -0,0 +1,110 @@
+from hal import AllianceStationID
+from wpilib import DriverStation
+from wpilib.simulation import DriverStationSim
+
+from pykit.logtable import LogTable
+from pykit.logvalue import LogValue
+
+
+class LoggedDriverStation:
+    """A dataclass for holding Driver Station I/O data."""
+
+    @classmethod
+    def saveToTable(cls, table: LogTable):
+        """Saves the current Driver Station data to the log table."""
+        alliance = DriverStation.getAlliance()
+        location = DriverStation.getLocation()
+        station = (
+            0
+            if location is None or alliance is None
+            else (location + (3 if alliance == DriverStation.Alliance.kBlue else 0))
+        )
+        table.put("AllianceStation", station)
+        table.put("EventName", DriverStation.getEventName())
+        table.put("GameSpecificMessage", DriverStation.getGameSpecificMessage())
+        table.put("MatchNumber", DriverStation.getMatchNumber())
+        table.put("ReplayNumber", DriverStation.getReplayNumber())
+        table.put("MatchType", DriverStation.getMatchType().value)
+        table.put("MatchTime", DriverStation.getMatchTime())
+
+        table.put("Enabled", DriverStation.isEnabled())
+        table.put("Autonomous", DriverStation.isAutonomous())
+        table.put("Test", DriverStation.isTest())
+        table.put("EmergencyStop", DriverStation.isEStopped())
+        table.put("FMSAttached", DriverStation.isFMSAttached())
+        table.put("DSAttached", DriverStation.isDSAttached())
+
+        for i in range(DriverStation.kJoystickPorts):
+            joystickTable = table.getSubTable(f"Joystick{i}")
+            joystickTable.put("Name", DriverStation.getJoystickName(i).strip())
+            joystickTable.put("Type", DriverStation.getJoystickType(i))
+            joystickTable.put("Xbox", DriverStation.getJoystickIsXbox(i))
+            joystickTable.put("ButtonCount", DriverStation.getStickButtonCount(i))
+            joystickTable.put("ButtonValues", DriverStation.getStickButtons(i))
+
+            povCount = DriverStation.getStickPOVCount(i)
+            povValues = []
+            for j in range(povCount):
+                povValues.append(DriverStation.getStickPOV(i, j))
+            joystickTable.putValue(
+                "POVs", LogValue.withType(LogValue.LoggableType.IntegerArray, povValues)
+            )
+
+            axisCount = DriverStation.getStickAxisCount(i)
+            axisValues = []
+            axisTypes = []
+            for j in range(axisCount):
+                axisValues.append(DriverStation.getStickAxis(i, j))
+                axisTypes.append(DriverStation.getJoystickAxisType(i, j))
+
+            joystickTable.putValue(
+                "AxesValues",
+                LogValue.withType(LogValue.LoggableType.DoubleArray, axisValues),
+            )
+            joystickTable.put("AxisTypes", axisTypes)
+
+    @classmethod
+    def loadFromTable(cls, table: LogTable):
+        DriverStationSim.setAllianceStationId(
+            AllianceStationID(
+                table.get("AllianceStation", AllianceStationID.kRed1.value)
+            )
+        )
+        DriverStationSim.setEventName(table.get("EventName", ""))
+        DriverStationSim.setGameSpecificMessage(table.get("GameSpecificMessage", ""))
+        DriverStationSim.setMatchNumber(table.get("MatchNumber", 0))
+        DriverStationSim.setReplayNumber(table.get("ReplayNumber", 0))
+        DriverStationSim.setMatchType(
+            DriverStation.MatchType(table.get("MatchType", 0))
+        )
+        DriverStationSim.setMatchTime(table.get("MatchTime", -1.0))
+
+        DriverStationSim.setEnabled(table.get("Enabled", False))
+        DriverStationSim.setAutonomous(table.get("Autonomous", False))
+        DriverStationSim.setTest(table.get("Test", False))
+        DriverStationSim.setEStop(table.get("EmergencyStop", False))
+        DriverStationSim.setFmsAttached(table.get("FMSAttached", False))
+        dsAttached = table.get("DSAttached", False)
+        DriverStationSim.setDsAttached(dsAttached)
+        for i in range(DriverStation.kJoystickPorts):
+            joystickTable = table.getSubTable(f"Joystick{i}")
+            # print(joystickTable.getDoubleArray("AxesValues", []))
+
+            buttonValues = joystickTable.get("ButtonValues", 0)
+            DriverStationSim.setJoystickButtons(i, buttonValues)
+
+            povValues = joystickTable.get("POVs", [])
+            DriverStationSim.setJoystickPOVCount(i, len(povValues))
+            for j, pov in enumerate(povValues):
+                DriverStationSim.setJoystickPOV(i, j, pov)
+
+            axisValues = joystickTable.get("AxesValues", [])
+            axisTypes = joystickTable.get("AxisTypes", [])
+
+            DriverStationSim.setJoystickAxisCount(i, len(axisValues))
+            for j, (axis_val, axis_type) in enumerate(zip(axisValues, axisTypes)):
+                DriverStationSim.setJoystickAxis(i, j, axis_val)
+                DriverStationSim.setJoystickAxisType(i, j, axis_type)
+
+        if dsAttached:
+            DriverStationSim.notifyNewData()

pykit/logdatareciever.py

@@ -0,0 +1,14 @@
+from pykit.logtable import LogTable
+
+
+class LogDataReciever:
+    timestampKey: str = "/Timestamp"
+
+    def start(self):
+        pass
+
+    def end(self):
+        pass
+
+    def putTable(self, table: LogTable):
+        pass

pykit/loggedrobot.py

@@ -0,0 +1,80 @@
+import hal
+from wpilib import (
+    DSControlWord,
+    IterativeRobotBase,
+    RobotController,
+    Watchdog,
+)
+
+from pykit.logger import Logger
+
+
+class LoggedRobot(IterativeRobotBase):
+    """A robot base class that provides logging and replay functionality."""
+
+    default_period = 0.02  # seconds
+
+    def printOverrunMessage(self):
+        """Prints a message when the main loop overruns."""
+        print("Loop overrun detected!")
+
+    def __init__(self):
+        """
+        Constructor for the LoggedRobot.
+        Initializes the robot, sets up the logger, and creates I/O objects.
+        """
+        IterativeRobotBase.__init__(self, LoggedRobot.default_period)
+        self.useTiming = True
+        self._nextCycleUs = 0
+        self._periodUs = int(self.getPeriod() * 1000000)
+
+        self.notifier = hal.initializeNotifier()[0]
+        self.watchdog = Watchdog(LoggedRobot.default_period, self.printOverrunMessage)
+        self.word = DSControlWord()
+
+    def endCompetition(self) -> None:
+        """Called at the end of the competition to clean up resources."""
+        hal.stopNotifier(self.notifier)
+        hal.cleanNotifier(self.notifier)
+
+    def startCompetition(self) -> None:
+        """
+        The main loop of the robot.
+        Handles timing, logging, and calling the periodic functions.
+        """
+        self.robotInit()
+
+        # TODO: handle autolog outputs
+
+        if self.isSimulation():
+            self._simulationInit()
+
+        self.initEnd = RobotController.getFPGATime()
+        Logger.periodicAfterUser(self.initEnd, 0)
+        print("Robot startup complete!")
+        hal.observeUserProgramStarting()
+
+        Logger.startReciever()
+
+        while True:
+            if self.useTiming:
+                currentTime = RobotController.getFPGATime()  # microseconds
+                if self._nextCycleUs < currentTime:
+                    # loop overrun, immediate next cycle
+                    self._nextCycleUs = currentTime
+                else:
+                    hal.updateNotifierAlarm(self.notifier, int(self._nextCycleUs))
+                    if hal.waitForNotifierAlarm(self.notifier) == 0:
+                        break
+                self._nextCycleUs += self._periodUs
+
+            periodicBeforeStart = RobotController.getFPGATime()
+            Logger.periodicBeforeUser()
+
+            userCodeStart = RobotController.getFPGATime()
+            self._loopFunc()
+            userCodeEnd = RobotController.getFPGATime()
+
+            Logger.periodicAfterUser(
+                userCodeEnd - userCodeStart, userCodeStart - periodicBeforeStart
+            )