robotpy-pykit 0.1.3b1__py3-none-any.whl

pykit/logger.py

@@ -0,0 +1,207 @@
+from typing import Any, Optional
+
+from wpilib import RobotController
+from pykit.autolog import AutoLogInputManager, AutoLogOutputManager
+from pykit.inputs.loggableds import LoggedDriverStation
+from pykit.logdatareciever import LogDataReciever
+from pykit.logreplaysource import LogReplaySource
+from pykit.logtable import LogTable
+from pykit.networktables.loggednetworkinput import LoggedNetworkInput
+
+
+class Logger:
+    """Manages the logging and replay of data."""
+
+    replaySource: Optional[LogReplaySource] = None
+    running: bool = False
+    cycleCount: int = 0
+    entry: LogTable = LogTable(0)
+    outputTable: LogTable = LogTable(0)
+    metadata: dict[str, str] = {}
+    checkConsole: bool = True
+
+    dataRecievers: list[LogDataReciever] = []
+    dashboardInputs: list[LoggedNetworkInput] = []
+
+    @classmethod
+    def setReplaySource(cls, replaySource: LogReplaySource):
+        """Sets the replay source for the logger."""
+        cls.replaySource = replaySource
+
+    @classmethod
+    def isReplay(cls) -> bool:
+        """Returns True if the logger is in replay mode."""
+        return cls.replaySource is not None
+
+    @classmethod
+    def recordOutput(cls, key: str, value: Any):
+        """
+        Records an output value to the log table.
+        This is only active when not in replay mode.
+        """
+        if cls.running:
+            cls.outputTable.put(key, value)
+
+    @classmethod
+    def recordMetadata(cls, key: str, value: str):
+        """
+        Records metadata information.
+        This is only active when not in replay mode.
+        """
+        if not cls.isReplay():
+            cls.metadata[key] = value
+
+    @classmethod
+    def processInputs(cls, prefix: str, inputs):
+        """
+        Processes an I/O object, either by logging its state or by updating it from the log.
+
+        In normal mode, it calls 'toLog' on the inputs object to record its state.
+        In replay mode, it calls 'fromLog' on the inputs object to update its state from the log.
+        """
+        if cls.running:
+            if cls.isReplay():
+                inputs.fromLog(cls.entry, prefix)
+            else:
+                inputs.toLog(cls.entry, prefix)
+
+    @classmethod
+    def addDataReciever(cls, reciever: LogDataReciever):
+        cls.dataRecievers.append(reciever)
+
+    @classmethod
+    def registerDashboardInput(cls, dashboardInput: LoggedNetworkInput):
+        cls.dashboardInputs.append(dashboardInput)
+
+    @classmethod
+    def start(cls):
+        if not cls.running:
+            cls.running = True
+            cls.cycleCount = 0
+            print("Logger started")
+
+            if cls.isReplay():
+                cls.replaySource.start()
+
+            if not cls.isReplay():
+                print("Logger in normal logging mode")
+                cls.outputTable = cls.entry.getSubTable("RealOutputs")
+            else:
+                print("Logger in replay mode")
+                cls.outputTable = cls.entry.getSubTable("ReplayOutputs")
+
+            metadataTable = cls.entry.getSubTable(
+                "ReplayMetadata" if cls.isReplay() else "RealMetadata"
+            )
+
+            for key, value in cls.metadata.items():
+                metadataTable.put(key, value)
+
+            RobotController.setTimeSource(cls.getTimestamp)
+            cls.periodicBeforeUser()
+
+    @classmethod
+    def startReciever(cls):
+        for reciever in cls.dataRecievers:
+            reciever.start()
+
+    @classmethod
+    def end(cls):
+        if cls.running:
+            cls.running = False
+            print("Logger ended")
+
+            if cls.isReplay():
+                cls.replaySource.end()
+
+            RobotController.setTimeSource(RobotController.getFPGATime)
+            for reciever in cls.dataRecievers:
+                reciever.end()
+
+    @classmethod
+    def getTimestamp(cls) -> int:
+        """Returns the current timestamp for logging."""
+        if cls.isReplay():
+            return cls.entry.getTimestamp()
+        return RobotController.getFPGATime()
+
+    @classmethod
+    def periodicBeforeUser(cls):
+        """Called periodically before user code to update the log table."""
+        cls.cycleCount += 1
+        if cls.running:
+            entryUpdateStart = RobotController.getFPGATime()
+            if not cls.isReplay():
+                cls.entry.setTimestamp(RobotController.getFPGATime())
+            else:
+                if not cls.replaySource.updateTable(cls.entry):
+                    print("End of replay reached")
+                    cls.end()
+                    raise SystemExit(0)
+
+            dsStart = RobotController.getFPGATime()
+            if cls.isReplay():
+                LoggedDriverStation.loadFromTable(
+                    cls.entry.getSubTable("DriverStation")
+                )
+            dashboardInputStart = RobotController.getFPGATime()
+
+            for dashInput in cls.dashboardInputs:
+                dashInput.periodic()
+
+            dashboardInputEnd = RobotController.getFPGATime()
+
+            cls.recordOutput(
+                "Logger/EntryUpdateMS", (dsStart - entryUpdateStart) / 1000.0
+            )
+            if cls.isReplay():
+                cls.recordOutput(
+                    "Logger/DriverStationMS", (dashboardInputStart - dsStart) / 1000.0
+                )
+            cls.recordOutput(
+                "Logger/DashboardInputsMS",
+                (dashboardInputEnd - dashboardInputStart) / 1000.0,
+            )
+
+    @classmethod
+    def periodicAfterUser(cls, userCodeLength: int, periodicBeforeLength: int):
+        """Called periodically after user code to finalize the log table."""
+        if cls.running:
+            dsStart = RobotController.getFPGATime()
+            if not cls.isReplay():
+                LoggedDriverStation.saveToTable(cls.entry.getSubTable("DriverStation"))
+            autoLogStart = RobotController.getFPGATime()
+            # TODO: AutoLogOutput periodic check and update
+            AutoLogOutputManager.publish_all(cls.outputTable)
+            radioLogStart = RobotController.getFPGATime()
+            # TODO: RadioLogger
+            radioLogEnd = RobotController.getFPGATime()
+            if not cls.isReplay():
+                cls.recordOutput(
+                    "Logger/DriverStationMS", (autoLogStart - dsStart) / 1000.0
+                )
+                for logged_input in AutoLogInputManager.getInputs():
+                    logged_input.toLog(
+                        cls.entry.getSubTable("/"),
+                        "/" + logged_input.__class__.__name__,
+                    )
+
+            cls.recordOutput(
+                "Logger/AutoLogOutputMS", (radioLogStart - autoLogStart) / 1000.0
+            )
+            cls.recordOutput(
+                "Logger/RadioLoggerMS", (radioLogEnd - radioLogStart) / 1000.0
+            )
+            cls.recordOutput("LoggedRobot/UserCodeMS", userCodeLength / 1000.0)
+            periodicAfterLength = radioLogEnd - dsStart
+            cls.recordOutput(
+                "LoggedRobot/LogPeriodicMS",
+                (periodicBeforeLength + periodicAfterLength) / 1000.0,
+            )
+            cls.recordOutput(
+                "LoggedRobot/FullCycleMS",
+                (periodicBeforeLength + userCodeLength + periodicAfterLength) / 1000.0,
+            )
+
+            for reciever in cls.dataRecievers:
+                reciever.putTable(LogTable.clone(cls.entry))

pykit/logreplaysource.py

@@ -0,0 +1,14 @@
+from pykit.logtable import LogTable
+
+
+class LogReplaySource:
+    timestampKey: str = "/Timestamp"
+
+    def start(self):
+        raise NotImplementedError("must be implemented by a subclass")
+
+    def end(self):
+        pass
+
+    def updateTable(self, _table: LogTable) -> bool:
+        raise NotImplementedError("must be implemented by a subclass")

pykit/logtable.py

@@ -0,0 +1,248 @@
+from typing import Any, Set
+
+from wpiutil import wpistruct
+from pykit.logvalue import LogValue
+
+
+class LogTable:
+    """A table of loggable values for a single timestamp."""
+
+    prefix: str
+    depth: int
+    _timestamp: int
+    data: dict[str, LogValue]
+
+    def __init__(self, timestamp: int, prefix="/") -> None:
+        """
+        Constructor for the LogTable.
+
+        :param timestamp: The timestamp for the log entries in this table.
+        :param prefix: The prefix for the log entries.
+        """
+        self._timestamp = timestamp
+        self.prefix = prefix
+        self.depth = 0
+        self.data: dict[str, LogValue] = {}
+
+    @staticmethod
+    def clone(source: "LogTable"):
+        data: dict[str, LogValue] = {}
+        for item, value in source.data.items():
+            data[item] = value
+
+        newTable = LogTable(source._timestamp, source.prefix)
+        newTable.data = data
+        return newTable
+
+    def getTimestamp(self) -> int:
+        """Returns the timestamp of the log table."""
+        return self._timestamp
+
+    def setTimestamp(self, timestamp: int) -> None:
+        """Sets the timestamp of the log table."""
+        self._timestamp = timestamp
+
+    def writeAllowed(
+        self,
+        key: str,
+        logType: LogValue.LoggableType,
+        customType: str,
+    ) -> bool:
+        """
+        Checks if a write operation is allowed for a given key and type.
+        Prevents changing the type of a log entry.
+        """
+        if (currentVal := self.data.get(self.prefix + key)) is None:
+            return True
+        if currentVal.log_type != logType:
+            print(
+                f"Failed to write {key}:\nAttempted {logType} but type is {currentVal.log_type}"
+            )
+            return False
+        if customType != currentVal.custom_type:
+            print(
+                f"Failed to write {key}:\nAttempted {customType} but type is {currentVal.custom_type}"
+            )
+            return False
+        return True
+
+    def addStructSchemaNest(self, structname: str, schema: str):
+        typeString = structname
+        key = "/.schema/" + typeString
+        if key in self.data.keys():
+            return
+
+        self.data[key] = LogValue(schema.encode(), "structschema")
+
+    def addStructSchema(self, struct: Any, seen: Set[str]):
+        typeString = "struct:" + wpistruct.getTypeName(struct.__class__)
+        key = "/.schema/" + typeString
+        if key in self.data.keys():
+            return
+        seen.add(typeString)
+        schema = wpistruct.getSchema(struct.__class__)
+        self.data[key] = LogValue(schema.encode(), "structschema")
+
+        wpistruct.forEachNested(struct.__class__, self.addStructSchemaNest)
+        seen.remove(typeString)
+
+    def put(self, key: str, value: Any, typeStr: str = ""):
+        """
+        Puts a value into the log table.
+        The value is wrapped in a LogValue object.
+        """
+        if hasattr(value, "WPIStruct"):
+            # its a struct!
+            self.addStructSchema(value, set())
+            log_value = LogValue(
+                wpistruct.pack(value),
+                "struct:" + wpistruct.getTypeName(value.__class__),
+            )
+        elif (
+            hasattr(value, "__iter__")
+            and len(value) > 0
+            and hasattr(value[0], "WPIStruct")
+        ):
+            # structured array
+            self.addStructSchema(value[0], set())
+            log_value = LogValue(
+                wpistruct.packArray(value),
+                "struct:" + wpistruct.getTypeName(value[0].__class__) + "[]",
+            )
+        else:
+            log_value = LogValue(value, typeStr)
+        self.putValue(key, log_value)
+
+    def putValue(self, key: str, log_value: LogValue):
+        if isinstance(log_value.value, list) and len(log_value.value) == 0:
+            # empty array is a weird case in dynamic type python, just force the type to match
+            currentVal = self.data.get(self.prefix + key)
+            if currentVal is not None:
+                log_value.log_type = currentVal.log_type
+                log_value.custom_type = currentVal.custom_type
+                if currentVal.custom_type.startswith("struct"):
+                    # struct logging is raw, empty array means we need a empty bytes buffer
+                    log_value.value = b""
+            else:
+                # in the interest of not type mismatch, don't log
+                return
+        if self.writeAllowed(key, log_value.log_type, log_value.custom_type):
+            self.data[self.prefix + key] = log_value
+        else:
+            print(f"Failed to insert {log_value.value}")
+
+    def get(self, key: str, defaultValue: Any) -> Any:
+        """Gets a value from the log table."""
+        if (log_value := self.data.get(self.prefix + key)) is not None:
+            return log_value.value
+        return defaultValue
+
+    def getRaw(self, key: str, defaultValue: bytes) -> bytes:
+        """Gets a raw value from the log table."""
+        if (
+            log_value := self.data.get(self.prefix + key)
+        ) is not None and log_value.log_type == LogValue.LoggableType.Raw:
+            return log_value.value
+        return defaultValue
+
+    def getBoolean(self, key: str, defaultValue: bool) -> bool:
+        """Gets a boolean value from the log table."""
+        if (
+            log_value := self.data.get(self.prefix + key)
+        ) is not None and log_value.log_type == LogValue.LoggableType.Boolean:
+            return log_value.value
+        return defaultValue
+
+    def getInteger(self, key: str, defaultValue: int) -> int:
+        """Gets an integer value from the log table."""
+        if (
+            log_value := self.data.get(self.prefix + key)
+        ) is not None and log_value.log_type == LogValue.LoggableType.Integer:
+            return log_value.value
+        return defaultValue
+
+    def getFloat(self, key: str, defaultValue: float) -> float:
+        """Gets a float value from the log table."""
+        if (
+            log_value := self.data.get(self.prefix + key)
+        ) is not None and log_value.log_type == LogValue.LoggableType.Float:
+            return log_value.value
+        return defaultValue
+
+    def getDouble(self, key: str, defaultValue: float) -> float:
+        """Gets a double value from the log table."""
+        if (
+            log_value := self.data.get(self.prefix + key)
+        ) is not None and log_value.log_type == LogValue.LoggableType.Double:
+            return log_value.value
+        return defaultValue
+
+    def getString(self, key: str, defaultValue: str) -> str:
+        """Gets a string value from the log table."""
+        if (
+            log_value := self.data.get(self.prefix + key)
+        ) is not None and log_value.log_type == LogValue.LoggableType.String:
+            return log_value.value
+        return defaultValue
+
+    def getBooleanArray(self, key: str, defaultValue: list[bool]) -> list[bool]:
+        """Gets a boolean array value from the log table."""
+        if (
+            log_value := self.data.get(self.prefix + key)
+        ) is not None and log_value.log_type == LogValue.LoggableType.BooleanArray:
+            return log_value.value
+        return defaultValue
+
+    def getIntegerArray(self, key: str, defaultValue: list[int]) -> list[int]:
+        """Gets an integer array value from the log table."""
+        if (
+            log_value := self.data.get(self.prefix + key)
+        ) is not None and log_value.log_type == LogValue.LoggableType.IntegerArray:
+            return log_value.value
+        return defaultValue
+
+    def getFloatArray(self, key: str, defaultValue: list[float]) -> list[float]:
+        """Gets a float array value from the log table."""
+        if (
+            log_value := self.data.get(self.prefix + key)
+        ) is not None and log_value.log_type == LogValue.LoggableType.FloatArray:
+            return log_value.value
+        return defaultValue
+
+    def getDoubleArray(self, key: str, defaultValue: list[float]) -> list[float]:
+        """Gets a double array value from the log table."""
+        if (
+            log_value := self.data.get(self.prefix + key)
+        ) is not None and log_value.log_type == LogValue.LoggableType.DoubleArray:
+            return log_value.value
+        return defaultValue
+
+    def getStringArray(self, key: str, defaultValue: list[str]) -> list[str]:
+        """Gets a string array value from the log table."""
+        if (
+            log_value := self.data.get(self.prefix + key)
+        ) is not None and log_value.log_type == LogValue.LoggableType.StringArray:
+            return log_value.value
+        return defaultValue
+
+    def getAll(self, subtableOnly: bool = False) -> dict[str, LogValue]:
+        """Returns all log values in the table."""
+        if not subtableOnly:
+            return self.data
+        return {
+            key: value
+            for key, value in self.data.items()
+            if key.startswith(self.prefix)
+        }
+
+    def getSubTable(self, subtablePrefix: str) -> "LogTable":
+        """
+        Returns a subtable containing only entries with the given prefix.
+
+        :param subtablePrefix: The prefix to filter entries by.
+        :return: A new LogTable containing only the filtered entries.
+        """
+        subtable = LogTable(self.getTimestamp(), self.prefix + subtablePrefix + "/")
+        subtable.data = self.data
+        subtable.depth = self.depth + 1
+        return subtable

pykit/logvalue.py

@@ -0,0 +1,133 @@
+from dataclasses import dataclass
+from enum import Enum, auto
+from typing import Any
+
+
+@dataclass
+class LogValue:
+    """Represents a value in the log table, with its type and custom type string."""
+
+    log_type: "LogValue.LoggableType"
+    custom_type: str
+    value: Any
+
+    def __init__(self, value: Any, typeStr: str = "") -> None:
+        """
+        Constructor for LogValue.
+        Infers the loggable type from the value.
+        """
+        self.value = value
+        self.custom_type = typeStr
+        if isinstance(value, bool):
+            self.log_type = LogValue.LoggableType.Boolean
+        elif isinstance(value, int):
+            self.log_type = LogValue.LoggableType.Integer
+        elif isinstance(value, float):
+            self.log_type = LogValue.LoggableType.Double
+        elif isinstance(value, str):
+            self.log_type = LogValue.LoggableType.String
+        elif isinstance(value, bytes):
+            self.log_type = LogValue.LoggableType.Raw
+        elif isinstance(value, list):
+            if len(value) == 0:
+                self.log_type = LogValue.LoggableType.IntegerArray
+            elif all(isinstance(x, bool) for x in value):
+                self.log_type = LogValue.LoggableType.BooleanArray
+            elif all(isinstance(x, int) for x in value):
+                self.log_type = LogValue.LoggableType.IntegerArray
+            elif all(isinstance(x, float) for x in value):
+                self.log_type = LogValue.LoggableType.DoubleArray
+            elif all(isinstance(x, str) for x in value):
+                self.log_type = LogValue.LoggableType.StringArray
+            else:
+                raise TypeError("Unsupported list type for LogValue")
+        else:
+            raise TypeError(f"Unsupported type for LogValue: {type(value)}")
+
+    @staticmethod
+    def withType(
+        log_type: "LogValue.LoggableType", data: Any, typeStr: str = ""
+    ) -> "LogValue":
+        val = LogValue(1, typeStr)
+        val.log_type = log_type
+        val.value = data
+        return val
+
+    def getWPILOGType(self):
+        if self.custom_type != "":
+            return self.custom_type
+        return self.log_type.getWPILOGType()
+
+    def getNT4Type(self):
+        if self.custom_type != "":
+            return self.custom_type
+        return self.log_type.getNT4Type()
+
+    class LoggableType(Enum):
+        """Enum for the different types of loggable values."""
+
+        Raw = auto()
+        Boolean = auto()
+        Integer = auto()
+        Float = auto()
+        Double = auto()
+        String = auto()
+        BooleanArray = auto()
+        IntegerArray = auto()
+        FloatArray = auto()
+        DoubleArray = auto()
+        StringArray = auto()
+
+        wpilogTypes = [
+            "raw",
+            "boolean",
+            "int64",
+            "float",
+            "double",
+            "string",
+            "boolean[]",
+            "int64[]",
+            "float[]",
+            "double[]",
+            "string[]",
+        ]
+
+        nt4Types = [
+            "raw",
+            "boolean",
+            "int",
+            "float",
+            "double",
+            "string",
+            "boolean[]",
+            "int[]",
+            "float[]",
+            "double[]",
+            "string[]",
+        ]
+
+        def getWPILOGType(self) -> str:
+            """Returns the WPILOG type string for this type."""
+            return LogValue.LoggableType.wpilogTypes.value[self.value - 1]
+
+        def getNT4Type(self) -> str:
+            """Returns the NT4 type string for this type."""
+            return LogValue.LoggableType.nt4Types.value[self.value - 1]
+
+        @staticmethod
+        def fromWPILOGType(typeStr: str) -> "LogValue.LoggableType":
+            """Returns a LoggableType from a WPILOG type string."""
+            if typeStr in LogValue.LoggableType.wpilogTypes.value:
+                return LogValue.LoggableType(
+                    LogValue.LoggableType.wpilogTypes.value.index(typeStr) + 1
+                )
+            return LogValue.LoggableType.Raw
+
+        @staticmethod
+        def fromNT4Type(typeStr: str) -> "LogValue.LoggableType":
+            """Returns a LoggableType from an NT4 type string."""
+            if typeStr in LogValue.LoggableType.nt4Types.value:
+                return LogValue.LoggableType(
+                    LogValue.LoggableType.nt4Types.value.index(typeStr) + 1
+                )
+            return LogValue.LoggableType.Raw

pykit/networktables/loggeddashboardchooser.py

@@ -0,0 +1,55 @@
+from typing import Optional, Generic, TypeVar
+
+from wpilib import SendableChooser, SmartDashboard
+from pykit.logger import Logger
+from pykit.logtable import LogTable
+from pykit.networktables.loggednetworkinput import LoggedNetworkInput
+
+T = TypeVar("T")
+
+
+class LoggedDashboardChooserInputs:
+    def __init__(self) -> None:
+        pass
+
+
+class LoggedDashboardChooser(LoggedNetworkInput, Generic[T]):
+    key: str
+    selectedValue: str = ""
+
+    sendableChooser: SendableChooser = SendableChooser()
+
+    options: dict[str, T] = {}
+
+    def __init__(self, key: str) -> None:
+        self.key = key
+        SmartDashboard.putData(key, self.sendableChooser)
+        self.periodic()
+
+        Logger.registerDashboardInput(self)
+
+    def addOption(self, key: str, value: T):
+        self.sendableChooser.addOption(key, key)
+        self.options[key] = value
+
+    def setDefaultOption(self, key: str, value: T):
+        self.sendableChooser.setDefaultOption(key, key)
+        self.options[key] = value
+
+    def getSelected(self) -> Optional[T]:
+        assert self.selectedValue is not None
+        return self.options.get(self.selectedValue)
+
+    def periodic(self):
+        if not Logger.isReplay():
+            self.selectedValue = self.sendableChooser.getSelected()
+            if self.selectedValue is None:
+                self.selectedValue = ""
+
+        Logger.processInputs(self.prefix + "/SmartDashboard", self)
+
+    def toLog(self, table: LogTable, prefix: str):
+        table.put(f"{prefix}/{self.key}", self.selectedValue)
+
+    def fromLog(self, table: LogTable, prefix: str):
+        self.selectedValue = table.get(f"{prefix}/{self.key}", self.selectedValue)

pykit/networktables/loggednetworkinput.py

@@ -0,0 +1,14 @@
+class LoggedNetworkInput:
+    prefix: str = "NetworkInputs"
+
+    def __init__(self) -> None:
+        pass
+
+    def periodic(self):
+        pass
+
+    @staticmethod
+    def removeSlash(key: str):
+        if key.startswith("/"):
+            return key[1:]
+        return key