robotpy-pykit 0.1.3b1__py3-none-any.whl

pykit/networktables/nt4Publisher.py

@@ -0,0 +1,68 @@
+from ntcore import (
+    GenericPublisher,
+    IntegerPublisher,
+    NetworkTable,
+    NetworkTableInstance,
+)
+
+from pykit.logdatareciever import LogDataReciever
+from pykit.logtable import LogTable
+from pykit.logvalue import LogValue
+
+
+class NT4Publisher(LogDataReciever):
+    pykitTable: NetworkTable
+    lastTable: LogTable = LogTable(0)
+
+    timestampPublisher: IntegerPublisher
+    publishers: dict[str, GenericPublisher] = {}
+
+    def __init__(self, actLikeAKit: bool = False):
+        self.pykitTable = NetworkTableInstance.getDefault().getTable(
+            "/AdvantageKit" if actLikeAKit else "/PyKit"
+        )
+        self.timestampPublisher = self.pykitTable.getIntegerTopic(
+            self.timestampKey[1:]
+        ).publish()
+
+    def putTable(self, table: LogTable):
+        self.timestampPublisher.set(table.getTimestamp(), table.getTimestamp())
+
+        newMap = table.getAll(False)
+        oldMap = self.lastTable.getAll(False)
+
+        for key, newValue in newMap.items():
+            if newValue == oldMap.get(key):
+                continue
+            key = key[1:]
+            publisher = self.publishers.get(key)
+            if publisher is None:
+                publisher = self.pykitTable.getTopic(key).genericPublish(
+                    newValue.getNT4Type()
+                )
+                self.publishers[key] = publisher
+
+            match newValue.log_type:
+                case LogValue.LoggableType.Raw:
+                    publisher.setRaw(newValue.value, table.getTimestamp())
+
+                case LogValue.LoggableType.Boolean:
+                    publisher.setBoolean(newValue.value, table.getTimestamp())
+                case LogValue.LoggableType.Integer:
+                    publisher.setInteger(newValue.value, table.getTimestamp())
+                case LogValue.LoggableType.Float:
+                    publisher.setFloat(newValue.value, table.getTimestamp())
+                case LogValue.LoggableType.Double:
+                    publisher.setDouble(newValue.value, table.getTimestamp())
+                case LogValue.LoggableType.String:
+                    publisher.setString(newValue.value, table.getTimestamp())
+                case LogValue.LoggableType.BooleanArray:
+                    publisher.setBooleanArray(newValue.value, table.getTimestamp())
+                case LogValue.LoggableType.IntegerArray:
+                    publisher.setIntegerArray(newValue.value, table.getTimestamp())
+                case LogValue.LoggableType.FloatArray:
+                    publisher.setFloatArray(newValue.value, table.getTimestamp())
+                case LogValue.LoggableType.DoubleArray:
+                    publisher.setDoubleArray(newValue.value, table.getTimestamp())
+                case LogValue.LoggableType.StringArray:
+                    publisher.setStringArray(newValue.value, table.getTimestamp())

pykit/watch/cli_replaywatch.py

@@ -0,0 +1,102 @@
+import os
+import argparse
+import importlib.metadata
+import logging
+import pathlib
+from tempfile import gettempdir
+import time
+import typing
+from watchdog.events import FileSystemEventHandler
+from watchdog.observers import Observer
+
+
+from pykit.loggedrobot import LoggedRobot
+
+
+logger = logging.getLogger("pyfrc.sim")
+
+
+entry_points = importlib.metadata.entry_points
+
+AKIT_FILENAME = "akit-log-path.txt"
+
+
+class PyKitReplayWatch:
+    """
+    Runs the robot in simulation and replay watch
+    """
+
+    do_update: bool = False
+
+    @classmethod
+    def doUpdate(cls) -> bool:
+        return cls.do_update
+
+    def __init__(self, parser: argparse.ArgumentParser):
+        self.simexts = {}
+
+        for entry_point in entry_points(group="robotpy_sim.2026"):
+            try:
+                sim_ext_module = entry_point.load()
+            except ImportError:
+                print(f"WARNING: Error detected in {entry_point}")
+                continue
+
+            self.simexts[entry_point.name] = sim_ext_module
+
+            try:
+                cmd_help = importlib.metadata.metadata(entry_point.dist.name)["summary"]
+            except AttributeError:
+                cmd_help = "Load specified simulation extension"
+            parser.add_argument(
+                f"--{entry_point.name}",
+                default=False,
+                action="store_true",
+                help=cmd_help,
+            )
+
+    def run(
+        self,
+        options: argparse.Namespace,  # pylint: disable=unused-argument
+        project_path: pathlib.Path,  # pylint: disable=unused-argument
+        robot_class: typing.Type[LoggedRobot],  # pylint: disable=unused-argument
+    ):
+
+        PyKitReplayWatch.do_update = False
+
+        class UpdateHandler(FileSystemEventHandler):
+            def on_modified(self, event):
+                if not event.is_directory and event.src_path.endswith(".py"):
+                    print("[PyKit] Modification detected!")
+                    PyKitReplayWatch.do_update = True
+
+        file_handler = UpdateHandler()
+        self.observer = Observer()
+        self.observer.schedule(file_handler, ".", recursive=True)
+
+        self.observer.start()
+
+        if "LOG_PATH" not in os.environ:
+            # see if we can pull from ascope's actively loaded log
+            readPath = os.path.join(gettempdir(), AKIT_FILENAME)
+            if not os.path.exists(readPath):
+                print("[PyKit] Cannot load log to replay!")
+                return
+            with open(
+                os.path.join(gettempdir(), AKIT_FILENAME), "r", encoding="utf-8"
+            ) as f:
+                readfilepath = f.readline()
+                os.environ["LOG_PATH"] = readfilepath
+                print(f"[PyKit] Logging from {readfilepath}")
+        else:
+            logpath = os.environ["LOG_PATH"]
+            print(f"[PyKit] Logging from {logpath}")
+
+        while True:
+            PyKitReplayWatch.do_update = False
+            print("[PyKit] Running replay...")
+            # this is hacky, a real solution is needed for resetting environment
+            os.system("python -m robotpy sim --nogui")
+            print("[PyKit] replay finished...")
+            while not PyKitReplayWatch.doUpdate():
+                time.sleep(1)

pykit/wpilog/wpilogconstants.py

@@ -0,0 +1,2 @@
+extraHeader = "PyKit"
+entryMetadata = '{"source": "PyKit"}'

pykit/wpilog/wpilogreader.py

@@ -0,0 +1,175 @@
+from typing import Any, Iterator
+
+from wpiutil.log import DataLogReader
+
+from pykit.logreplaysource import LogReplaySource
+from pykit.logtable import LogTable
+from pykit.logvalue import LogValue
+
+
+def safeNext(val: Iterator[Any]):
+    try:
+        return next(val)
+    except StopIteration:
+        return None
+
+
+class WPILOGReader(LogReplaySource):
+    """Reads a .wpilog file and provides the data as a replay source."""
+
+    def __init__(self, filename: str) -> None:
+        """
+        Constructor for WPILOGReader.
+
+        :param filename: The path to the .wpilog file.
+        """
+        self.filename = filename
+
+    def start(self):
+        self.reader = DataLogReader(self.filename)
+        self.isValid = (
+            self.reader.isValid()
+            # and self.reader.getExtraHeader() == wpilogconstants.extraHeader
+        )
+        print(self.reader.isValid())
+        print(self.reader.getExtraHeader())
+        self.records = iter([])
+
+        if self.isValid:
+            # Create a new iterator for the initial entry scan
+            self.records = iter(self.reader)
+            self.entryIds: dict[int, str] = {}
+            self.entryTypes: dict[int, LogValue.LoggableType] = {}
+            self.timestamp = None
+            self.entryCustomTypes = {}
+
+        else:
+            print("[WPILogReader] not valid")
+
+    def updateTable(self, table: LogTable) -> bool:
+        """
+        Updates a LogTable with the next record from the log file.
+
+        :param table: The LogTable to update.
+        :return: True if the table was updated, False if the end of the log was reached.
+        """
+        if not self.isValid:
+            return False
+
+        if self.timestamp is not None:
+            table.setTimestamp(self.timestamp)
+
+        keepLogging = False
+        while (record := safeNext(self.records)) is not None:
+            if record.isControl():
+                if record.isStart():
+                    startData = record.getStartData()
+                    self.entryIds[startData.entry] = startData.name
+                    typeStr = startData.type
+                    self.entryTypes[startData.entry] = (
+                        LogValue.LoggableType.fromWPILOGType(typeStr)
+                    )
+                    if typeStr.startswith("struct:") or typeStr == "structschema":
+                        self.entryCustomTypes[startData.entry] = typeStr
+            else:
+                entry = self.entryIds.get(record.getEntry())
+                if entry is not None:
+                    if entry == self.timestampKey:
+                        firsttimestamp = self.timestamp is None
+                        self.timestamp = record.getInteger()
+                        if firsttimestamp:
+                            table.setTimestamp(self.timestamp)
+                        else:
+                            keepLogging = True  # we still have a timestamp, just need to wait until next iter
+                            break
+                    elif (
+                        self.timestamp is not None
+                        and record.getTimestamp() == self.timestamp
+                    ):
+                        entry = entry[1:]
+                        if entry.startswith("ReplayOutputs"):
+                            continue
+                        customType = self.entryCustomTypes.get(record.getEntry())
+                        entryType = self.entryTypes.get(record.getEntry())
+                        if customType is None:
+                            customType = ""
+                        match entryType:
+                            case LogValue.LoggableType.Raw:
+                                table.putValue(
+                                    entry,
+                                    LogValue.withType(
+                                        entryType, record.getRaw(), customType
+                                    ),
+                                )
+                            case LogValue.LoggableType.Boolean:
+                                table.putValue(
+                                    entry,
+                                    LogValue.withType(
+                                        entryType, record.getBoolean(), customType
+                                    ),
+                                )
+                            case LogValue.LoggableType.Integer:
+                                table.putValue(
+                                    entry,
+                                    LogValue.withType(
+                                        entryType, record.getInteger(), customType
+                                    ),
+                                )
+                            case LogValue.LoggableType.Float:
+                                table.putValue(
+                                    entry,
+                                    LogValue.withType(
+                                        entryType, record.getFloat(), customType
+                                    ),
+                                )
+                            case LogValue.LoggableType.Double:
+                                table.putValue(
+                                    entry,
+                                    LogValue.withType(
+                                        entryType, record.getDouble(), customType
+                                    ),
+                                )
+                            case LogValue.LoggableType.String:
+                                table.putValue(
+                                    entry,
+                                    LogValue.withType(
+                                        entryType, record.getString(), customType
+                                    ),
+                                )
+                            case LogValue.LoggableType.BooleanArray:
+                                table.putValue(
+                                    entry,
+                                    LogValue.withType(
+                                        entryType, record.getBooleanArray(), customType
+                                    ),
+                                )
+                            case LogValue.LoggableType.IntegerArray:
+                                table.putValue(
+                                    entry,
+                                    LogValue.withType(
+                                        entryType, record.getIntegerArray(), customType
+                                    ),
+                                )
+                            case LogValue.LoggableType.FloatArray:
+                                table.putValue(
+                                    entry,
+                                    LogValue.withType(
+                                        entryType, record.getFloatArray(), customType
+                                    ),
+                                )
+                            case LogValue.LoggableType.DoubleArray:
+                                table.putValue(
+                                    entry,
+                                    LogValue.withType(
+                                        entryType, record.getDoubleArray(), customType
+                                    ),
+                                )
+                            case LogValue.LoggableType.StringArray:
+                                table.putValue(
+                                    entry,
+                                    LogValue.withType(
+                                        entryType, record.getStringArray(), customType
+                                    ),
+                                )
+
+        return keepLogging

pykit/wpilog/wpilogwriter.py

@@ -0,0 +1,279 @@
+import os
+import random
+import datetime
+from tempfile import gettempdir
+
+from typing import TYPE_CHECKING
+
+from hal import MatchType
+from wpilib import DataLogManager, RobotBase, RobotController
+from pykit.logdatareciever import LogDataReciever
+from pykit.logger import Logger
+from pykit.logtable import LogTable
+from pykit.logvalue import LogValue
+from pykit.wpilog import wpilogconstants
+
+if TYPE_CHECKING:
+    from wpiutil.log import DataLog
+
+
+ASCOPE_FILENAME = "ascope-log-path.txt"
+
+
+class WPILOGWriter(LogDataReciever):
+    """Writes a LogTable to a .wpilog file."""
+
+    log: "DataLog"
+    defaultPathRio: str = "/U/logs"
+    defaultPathSim: str = "pyLogs"
+
+    folder: str
+    filename: str
+    randomIdentifier: str
+    dsAttachedTime: int = 0
+    autoRename: bool
+    logDate: datetime.datetime | None
+    logMatchText: str
+
+    isOpen: bool = False
+    lastTable: LogTable
+    timestampId: int
+    entryIds: dict[str, int]
+    entryTypes: dict[str, LogValue.LoggableType]
+    entryUnits: dict[str, str]
+
+    def __init__(self, filename: str | None = None):
+        path = self.defaultPathSim if RobotBase.isSimulation() else self.defaultPathRio
+
+        self.randomIdentifier = f"{random.randint(0, 0xFFFF):04X}"
+
+        self.folder = os.path.abspath(
+            os.path.dirname(filename) if filename is not None else path
+        )
+        self.filename = (
+            os.path.basename(filename)
+            if filename is not None
+            else f"pykit_{self.randomIdentifier}.wpilog"
+        )
+        self.autoRename = False
+
+    def start(self):
+        # create folder if necessary
+        if not os.path.exists(self.folder):
+            os.makedirs(self.folder)
+
+        # delete log if it exists
+
+        # create a new log
+        fullPath = os.path.join(self.folder, self.filename)
+        print(f"[WPILogWriter] Creating WPILOG file at {fullPath}")
+        # DataLogManager.stop()  # ensure its fully stopped
+        if os.path.exists(fullPath):
+            print("[WPILogWriter] File exists, overwriting")
+            os.remove(fullPath)
+        DataLogManager.stop()
+        DataLogManager.start(self.folder, self.filename)
+        print(DataLogManager.getLogDir())
+        DataLogManager.logNetworkTables(False)
+        self.log = DataLogManager.getLog()
+        # self.log = DataLogWriter(fullPath, wpilogconstants.extraHeader)
+
+        self.isOpen = True
+        self.timestampId = self.log.start(
+            self.timestampKey,
+            LogValue.LoggableType.Integer.getWPILOGType(),
+            wpilogconstants.entryMetadata,
+            0,
+        )
+        self.lastTable = LogTable(0)
+
+        self.entryIds: dict[str, int] = {}
+        self.entryTypes: dict[str, LogValue.LoggableType] = {}
+        self.entryUnits: dict[str, str] = {}
+        self.logDate = None
+        self.logMatchText = f"pykit_{self.randomIdentifier}"
+
+    def end(self):
+        print("[WPILogWriter] Shutting down")
+        self.log.flush()
+        self.log.stop()
+
+        if RobotBase.isSimulation() and Logger.isReplay():
+            # open ascope
+            fullpath = os.path.join(gettempdir(), ASCOPE_FILENAME)
+            if not os.path.exists(gettempdir()):
+                return
+            fullLogPath = os.path.abspath(os.path.join(self.folder, self.filename))
+            print(f"Sending {fullLogPath} to AScope")
+            with open(fullpath, "w", encoding="utf-8") as f:
+                f.write(fullLogPath)
+
+        # DataLogManager.stop()
+
+    def putTable(self, table: LogTable):
+        if not self.isOpen:
+            return
+        if self.autoRename:
+            # rename log if necessary
+            if self.logDate is None:
+                if (
+                    table.get("DriverStation/DSAttached", False)
+                    and table.get("SystemStats/SystemTimeValid", False)
+                ) or RobotBase.isSimulation():
+                    if self.dsAttachedTime == 0:
+                        self.dsAttachedTime = RobotController.getFPGATime() / 1e6
+                    elif (
+                        RobotController.getFPGATime() / 1e6 - self.dsAttachedTime
+                    ) > 5 or RobotBase.isSimulation():
+                        self.logDate = datetime.datetime.now()
+                else:
+                    self.dsAttachedTime = 0
+
+                matchType: MatchType
+                match table.get("DriverStation/MatchType", 0):
+                    case 1:
+                        matchType = MatchType.practice
+                    case 2:
+                        matchType = MatchType.qualification
+                    case 3:
+                        matchType = MatchType.elimination
+                    case _:
+                        matchType = MatchType.none
+
+                if self.logMatchText == "" and matchType != MatchType.none:
+                    match matchType:
+                        case MatchType.practice:
+                            self.logMatchText = "p"
+                        case MatchType.qualification:
+                            self.logMatchText = "q"
+                        case MatchType.elimination:
+                            self.logMatchText = "e"
+                        case _:
+                            self.logMatchText = "u"
+                    self.logMatchText += str(table.get("DriverStation/MatchNumber", 0))
+
+                # update filename
+                filename = "pykit_"
+                if self.logDate is not None:
+                    filename += self.logDate.strftime("%Y%m%d_%H%M%S")
+                else:
+                    filename += self.randomIdentifier
+                eventName = (
+                    table.get("DriverStation/EventName", "").lower().replace(" ", "_")
+                )
+                if eventName != "":
+                    filename += f"_{eventName}"
+                if self.logMatchText != "":
+                    filename += f"_{self.logMatchText}"
+                filename += ".wpilog"
+                if self.filename != filename:
+                    print(f"[WPILogWriter] Renaming log to {filename}")
+                    # DataLogManager.stop()
+                    # self.log.stop()
+                    self.log.stop()
+                    fullPath = os.path.join(self.folder, self.filename)
+                    if os.path.exists(fullPath):
+                        print(f"[WPILogWriter] Old file removed ({self.filename})")
+                        os.remove(fullPath)
+
+                    # DataLogManager.logNetworkTables(False)
+                    DataLogManager.stop()
+                    DataLogManager.start(self.folder, filename)
+                    self.log = DataLogManager.getLog()
+                    # self.log = DataLogWriter(fullPath)
+                    # self.log._startFile()
+                    self.timestampId = self.log.start(
+                        "/Timestamp",
+                        LogValue.LoggableType.Integer.getWPILOGType(),
+                        wpilogconstants.entryMetadata,
+                        0,
+                    )
+                    self.filename = filename
+
+        # write timestamp
+        self.log.appendInteger(
+            self.timestampId, table.getTimestamp(), table.getTimestamp()
+        )
+
+        # get new and old data
+        newMap = table.getAll()
+        oldMap = self.lastTable.getAll()
+
+        # encode fields
+        for key, newValue in newMap.items():
+            fieldType = newValue.log_type
+            appendData = False
+
+            if key not in self.entryIds:  # new field
+                entryId = self.log.start(
+                    key,
+                    newValue.getWPILOGType(),
+                    wpilogconstants.entryMetadata,
+                    table.getTimestamp(),
+                )
+                self.entryIds[key] = entryId
+                self.entryTypes[key] = newValue.log_type
+                self.entryUnits[key] = ""
+
+                appendData = True
+            elif newValue != oldMap.get(key):  # existing field changed
+                appendData = True
+
+            # check if type changed
+            elif newValue.log_type != self.entryTypes[key]:
+                print(
+                    f"[WPILOGWriter] Type of {key} changed from "
+                    f"{self.entryTypes[key]} to {newValue.log_type}, skipping log"
+                )
+                continue
+
+            if appendData:
+                entryId = self.entryIds[key]
+                match fieldType:
+                    case LogValue.LoggableType.Raw:
+                        self.log.appendRaw(
+                            entryId, newValue.value, table.getTimestamp()
+                        )
+                    case LogValue.LoggableType.Boolean:
+                        self.log.appendBoolean(
+                            entryId, newValue.value, table.getTimestamp()
+                        )
+                    case LogValue.LoggableType.Integer:
+                        self.log.appendInteger(
+                            entryId, newValue.value, table.getTimestamp()
+                        )
+                    case LogValue.LoggableType.Float:
+                        self.log.appendFloat(
+                            entryId, newValue.value, table.getTimestamp()
+                        )
+                    case LogValue.LoggableType.Double:
+                        self.log.appendDouble(
+                            entryId, newValue.value, table.getTimestamp()
+                        )
+                    case LogValue.LoggableType.String:
+                        self.log.appendString(
+                            entryId, newValue.value, table.getTimestamp()
+                        )
+                    case LogValue.LoggableType.BooleanArray:
+                        self.log.appendBooleanArray(
+                            entryId, newValue.value, table.getTimestamp()
+                        )
+                    case LogValue.LoggableType.IntegerArray:
+                        self.log.appendIntegerArray(
+                            entryId, newValue.value, table.getTimestamp()
+                        )
+                    case LogValue.LoggableType.FloatArray:
+                        self.log.appendFloatArray(
+                            entryId, newValue.value, table.getTimestamp()
+                        )
+                    case LogValue.LoggableType.DoubleArray:
+                        self.log.appendDoubleArray(
+                            entryId, newValue.value, table.getTimestamp()
+                        )
+                    case LogValue.LoggableType.StringArray:
+                        self.log.appendStringArray(
+                            entryId, newValue.value, table.getTimestamp()
+                        )
+
+        self.log.flush()
+        self.lastTable = table

robotpy_pykit-0.1.3b1.dist-info/METADATA

@@ -0,0 +1,31 @@
+Metadata-Version: 2.4
+Name: robotpy-pykit
+Version: 0.1.3b1
+Summary: A logging, telemetry, and replay framework for FRC robots running python
+Author-email: Luke Maxwell <luke@whsrobotics.org>
+License-Expression: BSD-3-Clause
+Project-URL: Homepage, https://github.com/1757WestwoodRobotics/PyKit
+Keywords: pykit,frc,robotics,logging,telemetry,replay
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pyntcore>=2025.3.2.2
+Requires-Dist: robotpy-wpimath>=2025.3.2.2
+Requires-Dist: robotpy-wpiutil>=2025.3.2.2
+Requires-Dist: wpilib>=2025.3.2.2
+Requires-Dist: robotpy-hal>=2025.3.2.2
+Requires-Dist: pyfrc>=2025.1.0; platform_machine == "x86_64"
+Requires-Dist: watchdog>=6.0.0; platform_machine == "x86_64"
+Dynamic: license-file
+
+# PyKit
+
+PyKit is a Pure-Python logging, telementary, and replay framework developed by [Team 1757](https://whsrobotics.org) for use on Python robots. PyKit enables replaying log files to re-simulate robot code based on real data.
+
+See also
+- [AdvantageKit](https://github.com/Mechanical-Advantage/AdvantageKit/) the inspiration project, in Java
+- [WPILib Data Logging](https://docs.wpilib.org/en/stable/docs/software/telemetry/datalog.html) a simpler logging system included in WPILib
+
+Documentation and example projects coming soon!
+
+Feedback, feature requests, and bug reports are welcome on the [issues](https://github.com/1757WestwoodRobotics/PyKit/issues) page. For non-public inquiries, please send a message to contact@whsrobotics.org.

robotpy_pykit-0.1.3b1.dist-info/RECORD

@@ -0,0 +1,22 @@
+pykit/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pykit/autolog.py,sha256=y98ei8QXh0Ig5F5UxgKRglH17J3kleqkl6B1PVPCE00,12413
+pykit/logdatareciever.py,sha256=n0Xbx93gVzAhVU7lTjXe8LjHc4jeeEgGdQJi3BJw0ME,221
+pykit/loggedrobot.py,sha256=MYIoXgEi7LhiGqfgh4KRvSO4SdpmWG7SIl_cA4VIjmM,2609
+pykit/logger.py,sha256=Qgs5rEIVG80dQI1tOc-KLm5iwQ41lPv4_4BYzD1dyu4,7367
+pykit/logreplaysource.py,sha256=w-HqCuUqjv77FXyRmsJg1K9FbKd_KNvICJ_ayXECMXI,349
+pykit/logtable.py,sha256=SHFkRo1bJ790gw1GdhBqfR5j0qbuFmP4uFtJRZKCoRg,9448
+pykit/logvalue.py,sha256=ic5N3oxI5jmD75fOcyNTsErYp3JDhAI_DdqN_1E6sPs,4429
+pykit/inputs/loggableds.py,sha256=KsOtSOkvShdw24Scxaq1nx7MCjltz7-0tuM5xXABxQY,5011
+pykit/networktables/loggeddashboardchooser.py,sha256=GW3dH0PS1BJJ8K5UXhp7q9Yk9DtHo1YGq2tbjByRrS4,1668
+pykit/networktables/loggednetworkinput.py,sha256=t5uH8B8cLq_9NtdbYQVa8OO0alhbJxUMwd8i0sVmwho,272
+pykit/networktables/nt4Publisher.py,sha256=D9DSoWU9Nrwp7xpFvx7yltBSblX4DhIjI29tkUEBzUk,2860
+pykit/watch/cli_replaywatch.py,sha256=hpiIndevBZsY1S9aDx4TAFxb7PK3mxcsNyea7FbF8g4,3244
+pykit/wpilog/wpilogconstants.py,sha256=BdhugV6UC4ShP5s7lG8CO95Txc5qlVmxTOxyjyhpmfo,60
+pykit/wpilog/wpilogreader.py,sha256=6wtO79aBCoP8M7kzuABrkX0eX6kN8I0zWC1q7E72dQY,7646
+pykit/wpilog/wpilogwriter.py,sha256=WaRQMu8ob2sqrGPmUdLqb7C6pA9NswkvNaJm4x7DdWo,10772
+robotpy_pykit-0.1.3b1.dist-info/licenses/LICENSE,sha256=QEEUUO4dKcmhX9pW9BP4WMEMWqY-jhnmwdPi-Oo-S9w,1554
+robotpy_pykit-0.1.3b1.dist-info/METADATA,sha256=Sp1K_xWrdOOlhTFLrYzwpk_PUHR8mwKL8eHAryB1Tu4,1517
+robotpy_pykit-0.1.3b1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+robotpy_pykit-0.1.3b1.dist-info/entry_points.txt,sha256=fLvOR7Epp2Wx9epr_YMtEbQoSMiHfxozV5QsiraA_Os,63
+robotpy_pykit-0.1.3b1.dist-info/top_level.txt,sha256=tJQlZyFURJ0FEmLtjr4t5CR3lrZKIFEgdw_xxabFeeY,6
+robotpy_pykit-0.1.3b1.dist-info/RECORD,,

robotpy_pykit-0.1.3b1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+