.codebanner.json

{
    "folders": [
        "test",
        "scrutiny"
    ],
    "include_patterns": [
        "*.py"
    ],
    "exclude_patterns": [
        "*__init__.py",
        "scrutiny/sdk/docs/*"
    ],
    "license": "MIT - See LICENSE file",
    "project": "Scrutiny Debugger",
    "repo": "github.com/scrutinydebugger/scrutiny-python",
    "copyright_owner": "Scrutiny Debugger",
    "copyright_start_date": "2021",
    "copyright_end_date": null,
    "files": {
        "scrutiny/__main__.py": {
            "docstring": "Entry point of the python module. Launch the CLI.",
            "add_shebang": true
        },
        "scrutiny/cli/cli.py": {
            "docstring": "Provide the Command Line Interface.\nAllow to launch specific functionality by invoking Scrutiny with command line arguments."
        },
        "scrutiny/cli/commands/base_command.py": {
            "docstring": "Abstract class for all commands. Used to automatically find all available commands through reflection"
        },
        "scrutiny/cli/commands/elf2varmap.py": {
            "docstring": "CLI Command to read and .elf file and generate a Scrutiny VarMap file that will be included into the Firmware Description File."
        },
        "scrutiny/cli/commands/get_firmware_id.py": {
            "docstring": "CLI Command to generate a unique ID from a .elf file and optionally writes that ID to the file by a search and replace approach so that the device can broadcast its ID once flashed by this firmware."
        },
        "scrutiny/cli/commands/install_sfd.py": {
            "docstring": "CLI Command to copy a Scrutiny Firmware Description file into the scrutiny storage so it can be automatically loaded by the server upon connection with a device"
        },
        "scrutiny/cli/commands/make_sfd.py": {
            "docstring": "CLI Command to build and validate a Scrutiny Firmware Description file"
        },
        "scrutiny/cli/commands/make_metadata.py": {
            "docstring": "CLI Command to generate the metadata file that will be included in a Scrutiny Firmware Description file"
        },
        "scrutiny/cli/commands/runtest.py": {
            "docstring": "CLI Command to launch the python unit tests"
        },
        "scrutiny/cli/commands/uninstall_sfd.py": {
            "docstring": "CLI Command to remove a Scrutiny Firmware Description file from the scrutiny storage"
        },
        "scrutiny/core/firmware_id.py": {
            "docstring": "Holds the default firmware ID. Used for detection of untagged firmware"
        },
        "scrutiny/core/datalogging.py": {
            "docstring": "Contains the definitions related to the datalogger that are globals to all modules. Mainly what can be stored to the storage"
        },
        "scrutiny/core/firmware_description.py": {
            "docstring": "Contains the class that represent a Scrutiny Firmware Description file. \nA .sfd is a file that holds all the data related to a firmware and is identified by a unique ID."
        },
        "scrutiny/core/sfd_storage.py": {
            "docstring": "Manipulate the Scrutiny storage for .sfd files"
        },
        "scrutiny/core/variable.py": {
            "docstring": "Variable class represent a variable, will be included in VarMap"
        },
        "scrutiny/core/varmap.py": {
            "docstring": "A VarMap list all variables in a firmware file along with their types, address, bit offset, etc\n. I is a simplified version of the DWARF debugging symbols."
        },
        "scrutiny/core/bintools/demangler.py": {
            "docstring": "Converts mangled linkage names to readable symbols names"
        },
        "scrutiny/core/bintools/elf_dwarf_var_extractor.py": {
            "docstring": "Reads a .elf file, extract the DWARF debugging symbols and make a VarMap object out of it."
        },
        "scrutiny/core/bintools/get_var_memrange.py": {
            "docstring": "Simple tool to get the memory ranges of the .elf sections that contains the variables. \nUsed to generate Memdumps for unit testing"
        },
        "scrutiny/server/server.py": {
            "docstring": "The scrutiny server. Talk with multiple clients through a TCP API and communicate with a device through a given communication link (Serial, UDP, etc)\n Allow the clients to interact with the device"
        },
        "scrutiny/server/api/API.py": {
            "docstring": "Manages the TCP API to talk with the multiple clients. Can be a GUI client or a CLI client"
        },
        "scrutiny/server/api/dummy_client_handler.py": {
            "docstring": "Stubbed API connector to make API requests in unit tests without relying on the network"
        },
        "scrutiny/server/api/value_streamer.py": {
            "docstring": "Take the data from the Datastore and sends it to all clients by respecting bitrate limits and avoiding duplicate date."
        },
        "scrutiny/server/datastore/datastore.py": {
            "docstring": "This class is a container that will hold all the data read from a device (e.g. the variables).\n It's the meeting point of the API (with ValueStreamer) and the DeviceHandler"
        },
        "scrutiny/server/datastore/datastore_entry.py": {
            "docstring": "A variable entry in the datastore"
        },
        "scrutiny/server/device/device_handler.py": {
            "docstring": "Manage the communication with the device at high level.\n Try to establish a connection, once it succeed, reads the device configuration. \n Will keep the communication ongoing and will request for memory dump based on the Datastore state"
        },
        "scrutiny/server/device/device_info.py": {
            "docstring": "All the information that can be extracted from the device through the Scrutiny protocol"
        },
        "scrutiny/server/device/emulated_device.py": {
            "docstring": "Emulate a device that is compiled with the C++ lib.\nFor unit testing purpose"
        },
        "scrutiny/server/device/request_dispatcher.py": {
            "docstring": "Use a PriorityQueue to dispatch Request to the device. Associate each request with its callback"
        },
        "scrutiny/server/device/links/dummy_link.py": {
            "docstring": "Fake communication link with a device. Used by the EmulatedDevice for unit test purpose"
        },
        "scrutiny/server/device/links/udp_link.py": {
            "docstring": "Connects the CommHandler to a device through UDP"
        },
        "scrutiny/server/device/submodules/device_searcher.py": {
            "docstring": "Once enabled, generates DISCOVER requests to find a device at the other end of the communication link."
        },
        "scrutiny/server/device/submodules/heartbeat_generator.py": {
            "docstring": "Once enabled, generate HEARTBEAT request periodically to keep a connection alive with a device."
        },
        "scrutiny/server/device/submodules/info_poller.py": {
            "docstring": "Once enabled, successively poll all pollable data from a device through the Scrutiny protocol. Also call callbacks method when specific data is read e.g. Protocol version, buffer size, etc"
        },
        "scrutiny/server/device/submodules/session_initializer.py": {
            "docstring": "Once enabled, try to establish a working session with a device."
        },
        "scrutiny/server/protocol/comm_handler.py": {
            "docstring": "The CommHandler task is to convert Requests and Response from or to a stream of bytes.\nThis class manage send requests, wait for response, indicates if a response timeout occurred and decodes bytes. \nIt manages the low level part of the communication protocol with the device"
        },
        "scrutiny/server/protocol/crc32.py": {
            "docstring": "Compute a CRC32 for protocol validation"
        },
        "scrutiny/server/protocol/exceptions.py": {
            "docstring": "Some exceptions specific to the protocol"
        },
        "scrutiny/server/protocol/protocol.py": {
            "docstring": "Allow encoding and decoding of data based on the Scrutiny Protocol"
        },
        "scrutiny/server/protocol/request.py": {
            "docstring": "Represent a request sent by the server and received by the device"
        },
        "scrutiny/server/protocol/response.py": {
            "docstring": "Represent a response sent by the device and received by the server"
        },
        "scrutiny/server/protocol/commands/base_command.py": {
            "docstring": "Abstract class for all Scrutiny protocol commands "
        },
        "scrutiny/server/protocol/commands/comm_control.py": {
            "docstring": "Scrutiny protocol command to manipulate the communication"
        },
        "scrutiny/server/protocol/commands/datalog_control.py": {
            "docstring": "Scrutiny protocol command to trigger and read data logs."
        },
        "scrutiny/server/protocol/commands/dummy_command.py": {
            "docstring": "Fake Scrutiny protocol command for unit test purpose"
        },
        "scrutiny/server/protocol/commands/get_info.py": {
            "docstring": "Scrutiny protocol command to read some specific configuration in the device"
        },
        "scrutiny/server/protocol/commands/memory_control.py": {
            "docstring": "Scrutiny protocol command to read and wrie memory"
        },
        "scrutiny/server/protocol/commands/user_command.py": {
            "docstring": "Scrutiny protocol command to launch user defined functions in the device. \n It's a way of leveraging the existing communication protocol for other purpose than Scrutiny debugging."
        },
        "test/cli/test_cli.py": {
            "docstring": "Test the Command Line Interface"
        },
        "test/cli/test_elf_dwarf_var_extractor.py": {
            "docstring": "Test the extraction of dwarf symbols from a .elf file"
        },
        "test/server/test_api.py": {
            "docstring": "Test the client API through a fake handler"
        },
        "test/server/test_datastore.py": {
            "docstring": "Test the Datastore behavior"
        },
        "test/server/test_device_handler.py": {
            "docstring": "Test the DeviceHandler that manage the communication with the device at high level."
        },
        "test/server/test_dummy_connection.py": {
            "docstring": "Test the FakeConnection used for unit tests"
        },
        "test/server/test_value_streamer.py": {
            "docstring": "Test the ValueStreamer object that reads the datastore and broadcast variables to all clients."
        },
        "test/server/protocol/test_comm_handler.py": {
            "docstring": "Test the CommHandler that manage the communication with the device a lower level.\n Converts bytes to Request/Response and flag timeouts"
        },
        "test/server/protocol/test_crc.py": {
            "docstring": "Make sure the CRC32 is working for the protocol"
        },
        "test/server/protocol/test_protocol_v1_0.py": {
            "docstring": "Test the Scrutiny Protocol.\n Validate encoding and decoding of each command."
        },
        "test/server/protocol/test_request_response.py": {
            "docstring": "Test for the protocol Request and Response class.\n Ensure that byte encoding/decoding works properly"
        },
        "test/server/test_request_dispatcher.py": {
            "docstring": "Test the request dispatcher.\nPriorities, throttling, size limits."
        },
        "test/tools/test_tools.py": {
            "docstring": "Test various tools for the Python server application"
        },
        "scrutiny/core/memory_content.py": {
            "docstring": "Provide a tool to manipulate non contiguous chunks of bytes with their addresses.\nRepresent a partial memory snapshot"
        },
        "test/core/test_memory_content.py": {
            "docstring": "Test the MemoryContent class functionalities. Make sure it correctly writes and read and also agglomerate contiguous clusters"
        },
        "scrutiny/core/typehints.py": {
            "docstring": "Contains some definition for type hints that are used across all project"
        },
        "scrutiny/server/api/abstract_client_handler.py": {
            "docstring": "Base class for all API client handlers"
        },
        "scrutiny/server/device/links/abstract_link.py": {
            "docstring": "Base class for all device communication link (serial, udp, other)"
        },
        "scrutiny/server/device/submodules/memory_reader.py": {
            "docstring": "Synchronize the datastore with the device\nPoll for entries that are watched and update the datastore with data read from the device. "
        },
        "test/server/test_memory_reader.py": {
            "docstring": "Make sure the memory_Reader correctly reads the device memory to fills the datastore entries that are watch"
        },
        "scrutiny/server/device/submodules/memory_writer.py": {
            "docstring": "Synchronize the datastore with the device\nPoll for entries that are watched and update the device with value change request coming from the user in the datastore."
        },
        "test/core/test_variables.py": {
            "docstring": "Test the behavior of variable manipulation tools"
        },
        "test/server/test_memory_writer.py": {
            "docstring": "Test the bridge between the data store and the device memory (datastore to memory direction only)"
        },
        "scrutiny/cli/commands/list_sfd.py": {
            "docstring": "Print a list of all installed Scrutiny Firmware Description files (SFD) installed on this system"
        },
        "scrutiny/server/active_sfd_handler.py": {
            "docstring": "Manage the loaded SFD file with which the client will interact."
        },
        "test/server/test_active_sfd_handler.py": {
            "docstring": "Test the ActiveSFDHandler"
        },
        "scrutiny/exceptions.py": {
            "docstring": "Some exceptions specific to this module"
        },
        "test/server/links/test_dummy_link.py": {
            "docstring": "Make sure that dummy links transfer data and that global channels works (to simulate switching of channels)"
        },
        "test/server/links/test_serial_link.py": {
            "docstring": "Test serial port link. Require an external serial loopback.\nMake the link object talk with a serial port."
        },
        "test/server/links/test_udp_link.py": {
            "docstring": "Test UDP link.\nnMake the link object talk with a socket"
        },
        "scrutiny/server/device/links/serial_link.py": {
            "docstring": "Represent a Serial Link that can be used to communicate with a device"
        },
        "scrutiny/server/device/links/rtt_link.py": {
            "docstring": "Represent a Segger J-Link RTT that can be used to communicate with a device"
        },
        "test/core/test_types.py": {
            "docstring": "Make some checks on Scrutiny basic types used project wide"
        },
        "scrutiny/core/codecs.py": {
            "docstring": "Contains classes capable to encode/decode data exchanged with embedded side"
        },
        "scrutiny/core/basic_types.py": {
            "docstring": "Contains the basic types used project-wides"
        },
        "scrutiny/server/protocol/typing.py": {
            "docstring": "Mypy typing information for the Scrutiny protocol"
        },
        "scrutiny/server/api/typing.py": {
            "docstring": "Mypy typing information for API"
        },
        "test/core/test_sfd.py": {
            "docstring": "Run some test on the Firmware Description class meant to identify a firmware"
        },
        "scrutiny/cli/commands/add_alias.py": {
            "docstring": "Defines the add-alias command used to embed an alias file into an SFD file in the making"
        },
        "test/core/test_alias.py": {
            "docstring": "Test Alias basic features"
        },
        "scrutiny/core/alias.py": {
            "docstring": "Class that contains the definition of an alias."
        },
        "scrutiny/server/datastore/entry_type.py": {
            "docstring": "Type of datastore entry."
        },
        "test/core/test_firmware_parser.py": {
            "docstring": "Test basic capacities to parse a firmware a generate a valid firmware ID"
        },
        "scrutiny/cli/commands/tag_firmware_id.py": {
            "docstring": "Command to write the firmware ID into a freshly compiled binary"
        },
        "scrutiny/core/firmware_parser.py": {
            "docstring": "Reads a compiled firmware and provide tools to read or write the firmware ID"
        },
        "test/integration/test_read_write.py": {
            "docstring": "Does some Read and Write through the API and check the memory of the emulated device"
        },
        "test/integration/integration_test.py": {
            "docstring": "Base class for tests that checks the integration of all the pythons components. They talk to the API and control an emulated device that runs in a thread"
        },
        "test/server/test_emulated_device.py": {
            "docstring": "Some testcases to make sure the emulated device runs correctly"
        },
        "test/server/datalogging/test_datalogging_storage.py": {
            "docstring": "Test the datalogging storage"
        },
        "test/server/datalogging/test_datalogging.py": {
            "docstring": "Test datalogging features"
        },
        "scrutiny/server/datalogging/datalogging_manager.py": {
            "docstring": "The main server components that manages the datalogging feature at high level"
        },
        "scrutiny/server/datalogging/datalogging_storage.py": {
            "docstring": "A storage interface to save and fetch datalogging acquisition from the disk to keep an history of them"
        },
        "scrutiny/server/device/submodules/datalogging_poller.py": {
            "docstring": "Component of the Device Handler that handles the datalogging feature within the device. Poll for status, new data and configure the device"
        },
        "test/integration/test_datalogging_integration.py": {
            "docstring": "Test the whole datalogging chain with a request to the API, a server that process the request and a fake device that will do the logging."
        },
        "test/server/datalogging/test_datalogging_manager.py": {
            "docstring": "Test the datalogging manager features"
        },
        "scrutiny/server/datalogging/datalogging_utilities.py": {
            "docstring": "Contains some utilities that may be used by more than one module"
        },
        "scrutiny/server/datalogging/definitions/device.py": {
            "docstring": "Contains the definitions related to the datalogging feature on the device side. Shared between the DataloggingManager and the DeviceHandler"
        },
        "scrutiny/server/datalogging/definitions/api.py": {
            "docstring": "Contains the definitions related to the datalogging feature on the API side. Shared between the API and the DataloggingManager"
        },
        "scrutiny/cli/commands/datalog_info.py": {
            "docstring": "Command that return some information about datalogging such as storage location, size, number of acquisitions"
        },
        "scrutiny/cli/commands/list_datalog.py": {
            "docstring": "List all the datalogging acquisition stored on this server"
        },
        "scrutiny/cli/commands/delete_datalog.py": {
            "docstring": "Delete a single or all datalogging acquisitions"
        },
        "scrutiny/cli/commands/export_datalog.py": {
            "docstring": "Extract a datalogging acquisition and export it into a common format, such as CSV"
        },
        "test/sdk/test_api_parser.py": {
            "docstring": "Test suite for the parsing function used by the client"
        },
        "test/sdk/test_client.py": {
            "docstring": "Test suite for the SDK client"
        },
        "scrutiny/tools/timer.py": {
            "docstring": "Minimalist class to make measurement of time easier."
        },
        "scrutiny/tools/throttler.py": {
            "docstring": "Allow to do some throttling to reduce the transmission speed"
        },
        "scrutiny/sdk/exceptions.py": {
            "docstring": "Definitions of all exceptions used across the Scrutiny SDK"
        },
        "scrutiny/sdk/watchable_handle.py": {
            "docstring": "A handle on a watchable element (Variable, Alias, RPV). This handle is created by the client when watching"
        },
        "scrutiny/sdk/definitions.py": {
            "docstring": "Global definitions of types, constants, enums used across the Scrutiny SDK"
        },
        "scrutiny/sdk/client.py": {
            "docstring": "A client that can talk with the Scrutiny server"
        },
        "scrutiny/sdk/_api_parser.py": {
            "docstring": "Internal parsing function for the Scrutiny server API messages"
        },
        "scrutiny/sdk/write_request.py": {
            "docstring": "A object representing a request to write a watchable element."
        },
        "test/integration/test_interract_with_device.py": {
            "docstring": "Make sure we can do some API calls related to the device that are not read/writes."
        },
        "test/core/test_datalogging.py": {
            "docstring": "Test the datalogging features from the core module (shared across modules)"
        },
        "test/sdk/test_datalogging.py": {
            "docstring": "Test the datalogging features defines in the SDK"
        },
        "scrutiny/sdk/datalogging.py": {
            "docstring": "Defines all the types used for datalogging in the SDK"
        },
        "scrutiny/core/bintools/elftools_stubs.py": {
            "docstring": "Stubfile for pyelftools"
        },
        "test/sdk/test_listeners.py": {
            "docstring": "Test suite for the SDK listener feature"
        },
        "scrutiny/sdk/listeners/buffered_reader_listener.py": {
            "docstring": "Create a listener that simply enqueue the updates in a queue for the user to read them"
        },
        "scrutiny/sdk/listeners/text_stream_listener.py": {
            "docstring": "Simple listener useful for debug. Prints all updates in a text stream"
        },
        "scrutiny/sdk/listeners/csv_file_listener.py": {
            "docstring": "Listener that dumps the values of the watchables into either one or multiple CSV files"
        },
        "test/cli/test_makevarmap_Linux_LE_x64_Clang_14_0_0_dwarf3.py": {
            "docstring": "Test suite for symbol extraction. clang dwarf V3"
        },
        "test/cli/test_makevarmap_Linux_LE_x64_Clang_14_0_0_dwarf2.py": {
            "docstring": "Test suite for symbol extraction. clang dwarf V2"
        },
        "test/cli/test_makevarmap_Linux_LE_x64_Gcc_11_4_0_dwarf4.py": {
            "docstring": "Test suite for symbol extraction. GCC dwarf V4"
        },
        "test/cli/test_makevarmap_Linux_LE_x64_Clang_14_0_0_dwarf4.py": {
            "docstring": "Test suite for symbol extraction. clang dwarf V4"
        },
        "test/cli/test_makevarmap_atmega2560_LE_avr_gcc_5_4_0.py": {
            "docstring": "Test suite for symbol extraction. AvrGCC dwarf V4"
        },
        "test/cli/base_testapp_makevarmap_test.py": {
            "docstring": "BAse test for symbol extrction based on C++ TestApp"
        },
        "test/cli/test_makevarmap_Linux_LE_x64_Gcc_11_4_0_dwarf2.py": {
            "docstring": "Test suite for symbol extraction. GCC dwarf V2"
        },
        "test/cli/test_makevarmap_Linux_LE_x64_Gcc_11_4_0_dwarf3.py": {
            "docstring": "Test suite for symbol extraction. GCC dwarf V3"
        },
        "test/cli/base_ctestapp_makevarmap_test.py": {
            "docstring": "Base test for make varmap tests based on the C TestApp"
        },
        "test/server/test_tcp_client_handler.py": {
            "docstring": "Test the TCP client handler (used by the server API) "
        },
        "test/tools/test_stream_datagrams.py": {
            "docstring": "Test the tools that transmit datagrams over a stream."
        },
        "scrutiny/cli/commands/server.py": {
            "docstring": "Command that launches the Scrutiny server"
        },
        "scrutiny/core/embedded_enum.py": {
            "docstring": "Contains the definition for an enum on the embedded side"
        },
        "scrutiny/server/api/tcp_client_handler.py": {
            "docstring": "The connection manager used by the aPI that manages multi-clients. Listen on TCP sockets"
        },
        "scrutiny/tools/stream_datagrams.py": {
            "docstring": "Internal tool to transmit datagrams over a stream. Used by the server and the clients to exchange JSON objects over TCP"
        },
        "test/gui/test_watchable_registry.py": {
            "docstring": "A test suite for the WatchableRegistry object"
        },
        "test/gui/fake_sdk_client.py": {
            "docstring": "Emulate the SDK ScrutinyClient for the purpose of unit testing"
        },
        "test/gui/test_server_manager.py": {
            "docstring": "Test suite for the ServerManager"
        },
        "test/gui/base_gui_test.py": {
            "docstring": "Base class for GUI tests"
        },
        "scrutiny/cli/commands/gui.py": {
            "docstring": "Command to start the GUI"
        },
        "scrutiny/gui/gui.py": {
            "docstring": "The highest level class to manipulate the GUI"
        },
        "scrutiny/gui/main_window.py": {
            "docstring": "The QT Main window object"
        },
        "scrutiny/gui/core/exceptions.py": {
            "docstring": "Exceptions related to the GUI"
        },
        "scrutiny/gui/core/watchable_registry.py": {
            "docstring": "A storage object that keeps a local copy of all the watchable (Variable/Alias/RPV) avaialble on the server. \nLots of overlapping feature with the server datastore, with few fundamentals differences."
        },
        "scrutiny/gui/core/server_manager.py": {
            "docstring": "Object that handles the communication with the server and inform the rest of the GUI about what's happening on the other side of the socket. Based on the SDK ScrutinyClient"
        },
        "scrutiny/gui/dashboard_components/base_component.py": {
            "docstring": "A base class for a component that can be added to the dashboard"
        },
        "scrutiny/gui/dashboard_components/debug/debug_component.py": {
            "docstring": "A component used to develop the GUI"
        },
        "scrutiny/gui/dashboard_components/embedded_graph/embedded_graph_component.py": {
            "docstring": "A componenbt to configure, trigger, view and browse embedded datalogging."
        },
        "scrutiny/gui/dashboard_components/varlist/varlist_component.py": {
            "docstring": "A component that shows the content of the watchable registry, a copy og what's available on the server"
        },
        "scrutiny/gui/dashboard_components/watch/watch_component.py": {
            "docstring": "A component to look at the value of watchable items broadcast by the server"
        },
        "scrutiny/sdk/pending_request.py": {
            "docstring": "A base class for Future objects given to the suer"
        },
        "test/gui/manual/manual_test_device_info_dialog.py": {
            "docstring": "Create an environment to manually test the DeviceInfoDialog window"
        },
        "test/gui/manual/manual_test_device_config_dialog.py": {
            "docstring": "Create an environment to manually test the DeviceConfigDialog window"
        },
        "test/server/links/test_rtt_link.py": {
            "docstring": "Test suite to test Segger Rtt Link "
        },
        "scrutiny/gui/core/definitions.py": {
            "docstring": "Some GUI wide definitions"
        },
        "scrutiny/gui/dialogs/device_config_dialog.py": {
            "docstring": "A dialog meant to change the link between the server and the device and its configuration.\n Contains no app logic, has callback to integrate with an app."
        },
        "scrutiny/gui/dialogs/about_dialog.py": {
            "docstring": "About window, contains data about the software, including all versions numbers"
        },
        "scrutiny/gui/dialogs/device_info_dialog.py": {
            "docstring": "A dialog to visualize the device information downlaoded after a device has connected."
        },
        "scrutiny/gui/dialogs/server_config_dialog.py": {
            "docstring": "A dialog to edit the connection parameter of the server"
        },
        "scrutiny/gui/tools/validators.py": {
            "docstring": "Some QT validators used across the project"
        },
        "scrutiny/gui/widgets/status_bar.py": {
            "docstring": "The status bar shown at the bottom of the app. Contains substantial amount of logic since many menus are there."
        },
        "scrutiny/gui/widgets/validable_line_edit.py": {
            "docstring": "An extension of QLine edit that can accept 2 validator. One enforced by Qt, the other used for visual feedback"
        },
        "scrutiny/gui/widgets/menu_bar.py": {
            "docstring": "The window top menubar"
        },
        "test/gui/manual/manual_test_sfd_content_dialog.py": {
            "docstring": "Create an environment to manually test the SFDContentDialog window"
        },
        "scrutiny/gui/dialogs/sfd_content_dialog.py": {
            "docstring": "Window that displays the metadata associated with a Scrutiny Firmware Description file"
        },
        "scrutiny/gui/core/scrutiny_drag_data.py": {
            "docstring": "Application-wide drag&drop data format. Used to drag watchables items around"
        },
        "scrutiny/gui/dashboard_components/common/watchable_tree.py": {
            "docstring": "An enhanced QTreeView with a data model dedicated to Watchables displayed in folder structure."
        },
        "scrutiny/gui/dashboard_components/watch/watch_tree_model.py": {
            "docstring": "The data model used by the Watch component treeview"
        },
        "test/gui/fake_server_manager.py": {
            "docstring": "A stubbed Server MAnager for unit test purpose"
        },
        "test/gui/test_drag_data.py": {
            "docstring": "A test suite to test the tools that revolves around drag & drop"
        },
        "test/gui/test_watchable_tree.py": {
            "docstring": "Test suite for Custom TreeView widget dedicated to show watchables"
        },
        "test/gui/manual/manual_test_varlist_watch_components.py": {
            "docstring": "A test file that can be invoked manually to check on the varlist/watch widget"
        },
        "scrutiny/core/logging.py": {
            "docstring": "Some global definition for logging"
        },
        "scrutiny/tools/profiling.py": {
            "docstring": "Some tools for profiling the application"
        },
        "scrutiny/gui/widgets/component_sidebar.py": {
            "docstring": "The sidebar with the dashboard component that can be added"
        },
        "scrutiny/gui/widgets/app_stats_display.py": {
            "docstring": "A widget to display the application stats"
        },
        "scrutiny/gui/dashboard_components/metrics/metrics_component.py": {
            "docstring": "A dashboard component that shows internal metrics for debugging purpose"
        },
        "test/gui/test_invoker.py": {
            "docstring": "A test suite to test the cross thread invocation helpers"
        },
        "scrutiny/gui/core/threads.py": {
            "docstring": "Some threading global definition used to enforce thread"
        },
        "scrutiny/gui/tools/invoker.py": {
            "docstring": "Some tools to invoke methods across threads in the GUI"
        },
        "scrutiny/tools/thread_enforcer.py": {
            "docstring": "A runtime checker that enforces the thread ID of function caller. Prevents race conditions from misusage of internal APIs"
        },
        "test/gui/manual/manual_test_graph_axis.py": {
            "docstring": "A dummy app to test the graph axis tree widget"
        },
        "scrutiny/gui/dashboard_components/common/graph_signal_tree.py": {
            "docstring": "The widget that allow the user to define a graph axis/signals using a 2 level tree. First level for axes, Second level for watchables"
        },
        "scrutiny/gui/dashboard_components/common/base_tree.py": {
            "docstring": "An extension of the QT QTreeView that suits this application. Defines some helper functions and common keyboard/mouse behaviors "
        },
        "scrutiny/gui/dashboard_components/continuous_graph/continuous_graph_component.py": {
            "docstring": "A component that makes a real time graphs of the values streamed by the server"
        },
        "scrutiny/tools/global_counters.py": {
            "docstring": "A file that provide some global counter atomic counter for unique ID generation"
        },
        "scrutiny/gui/dashboard_components/common/base_chart.py": {
            "docstring": "Some customized extensions of the QT Charts for the Scrutiny GUI"
        },
        "scrutiny/gui/core/preferences.py": {
            "docstring": "An interface to the user preferences"
        },
        "scrutiny/gui/themes/default_theme.py": {
            "docstring": "A color theme that serves as a base for other theme and loaded by default"
        },
        "scrutiny/server/timebase.py": {
            "docstring": "The timebase used by the server"
        },
        "scrutiny/tools/timebase.py": {
            "docstring": "A generic timebase object that can be used to follow relative time interval and map them to real datetime"
        },
        "test/scrutiny_runner.py": {
            "docstring": "Custom unit test handlers that extends the default unittest framework "
        },
        "scrutiny/gui/widgets/feedback_label.py": {
            "docstring": "A label that can display messages to the suer with success/warning/info/error facilities"
        },
        "scrutiny/sdk/listeners/csv_logger.py": {
            "docstring": "Logger that dumps the values of the watchables into either one or multiple CSV files"
        },
        "test/gui/test_graph_decimator.py": {
            "docstring": "Test suite for the continuuos graph data decimator"
        },
        "scrutiny/gui/app_settings.py": {
            "docstring": "Global settings for the GUI."
        },
        "scrutiny/gui/dashboard_components/common/export_chart_csv.py": {
            "docstring": "Tools to export graphs to CSV format"
        },
        "scrutiny/gui/dashboard_components/continuous_graph/decimator.py": {
            "docstring": "A data decimator meant to handle real-time data stream (monotonic time axis)"
        },
        "scrutiny/gui/tools/prompt.py": {
            "docstring": "Helper to display errors in standardized fashion"
        },
        "scrutiny/gui/tools/min_max.py": {
            "docstring": "Helper to compute min/max on a series."
        },
        "scrutiny/gui/tools/opengl.py": {
            "docstring": "OpenGL related stuff"
        },
        "test/gui/test_preferences.py": {
            "docstring": "A test suite that tests the GUI persistent preferences mechanisms"
        },
        "scrutiny/gui/globals.py": {
            "docstring": "GUI wide globals definitions"
        },
        "scrutiny/server/globals.py": {
            "docstring": "Server wide globals definitions"
        },
        "scrutiny/tools/validation.py": {
            "docstring": "Helpers to validate variables types and values"
        },
        "scrutiny/tools/typing.py": {
            "docstring": "Some typing helpers"
        }
    }
}