Skip to content

Renderer

Renderer

This module provides utilities for rendering data in various formats, specifically focusing on rendering Volatility framework data into JSON and pandas DataFrames.

Classes:

Name Description
TreeGrid_to_json

A class for rendering Volatility TreeGrid data into JSON format.
Renderer

A class for rendering data into human-readable formats such as lists, JSON strings, and pandas DataFrames.

RenderableDataFrame

Bases: DataFrame

DataFrame with optional full display rendering.

When enabled, display options are applied only during rendering so pandas global options stay unchanged.

Source code in pydfirram/core/renderer.py 
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
class RenderableDataFrame(pd.DataFrame):
    """
    DataFrame with optional full display rendering.

    When enabled, display options are applied only during rendering so pandas
    global options stay unchanged.
    """

    _metadata = ["_pydfirram_full_display"]

    @property
    def _constructor(self):
        return RenderableDataFrame

    def _with_local_display_context(self, render_callable):
        if getattr(self, "_pydfirram_full_display", False):
            with pd.option_context(
                "display.max_rows", None,
                "display.max_columns", None,
            ):
                return render_callable()
        return render_callable()

    def __repr__(self) -> str:
        return self._with_local_display_context(super().__repr__)

    def _repr_html_(self):  # type: ignore[override]
        return self._with_local_display_context(super()._repr_html_)

Renderer

Class for rendering data in various formats.

This class provides methods to render data into human-readable formats such as lists, JSON strings, and pandas DataFrames.

Attributes:

Name Type Description
data Any

The input data to be rendered.
Source code in pydfirram/core/renderer.py 
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
class Renderer():
    """
    Class for rendering data in various formats.

    This class provides methods to render data into human-readable formats
    such as lists, JSON strings, and pandas DataFrames.

    Attributes:
        data (Any): The input data to be rendered.
    """

    def __init__(self, data: Any) -> None:
        """
        Initialize the Renderer with the provided data.

        Args:
            data (Any): The input data to be rendered.
        """
        self.data = data

    def to_list(self):
        """
        Convert the data to a list format.

        This method attempts to render the input data using the
        TreeGrid_to_json class, and convert it to a dictionary.

        Returns:
            Dict: The rendered data in list format.

        Raises:
            Exception: If rendering the data fails.
        """
        try:
            # (fixme) : `render()` should return nothing
            parsed_data : dict[str, Any] = TreeGrid_to_json().render(self.data)
            return parsed_data.get("data")
        except Exception as e:
            logger.error("Impossible de convertir la sortie plugin en liste.")
            raise OutputHandlingError(
                "Impossible de convertir la sortie plugin en liste exploitable."
            ) from e

    def file_render(self)-> None:
        """
        Convert the data to a list format.

        This method attempts to render the input data using the
        TreeGrid_to_json class, and convert it to a dictionary.

        Returns:
            Dict: The rendered data in list format.

        Raises:
            Exception: If rendering the data fails.
        """
        try:
            # (fixme) : `render()` return nothing
            TreeGrid_to_json().render(self.data)
        except Exception as e:
            logger.error("Impossible de rendre la sortie plugin en fichier.")
            raise OutputHandlingError(
                "Impossible de traiter les sorties artefacts du plugin."
            ) from e

    def to_json(self) -> str:
        """
        Convert the data to a JSON string.

        This method first converts the data to a list format, and then
        serializes it to a JSON string.

        Returns:
            str: The data serialized as a JSON string.

        Raises:
            Exception: If converting the data to JSON fails.
        """
        try:
            data_as_dict = self.to_list()
            return dumps(data_as_dict)
        except Exception as e:
            logger.error("Impossible de convertir la sortie plugin en JSON.")
            raise OutputHandlingError(
                "Impossible de convertir la sortie plugin au format JSON."
            ) from e

    def to_df(self,max_row: bool = False) -> pd.DataFrame:
        """
        Convert the data to a pandas DataFrame.

        This method first converts the data to a list format, and then
        constructs a pandas DataFrame from it.

        Returns:
            pd.DataFrame: The data as a pandas DataFrame.

        Raises:
            Exception: If rendering the data as a DataFrame fails.
        """
        try:
            data_as_dict = self.to_list()
            dataframe = RenderableDataFrame(data_as_dict)
            dataframe._pydfirram_full_display = max_row
            return dataframe
        except Exception as e:
            logger.error("Impossible de convertir la sortie plugin en DataFrame.")
            raise OutputHandlingError(
                "Impossible de convertir la sortie plugin en tableau d'analyse."
            ) from e

__init__(data)

Initialize the Renderer with the provided data.

Parameters:

Name Type Description Default
data Any

The input data to be rendered.

 required
Source code in pydfirram/core/renderer.py 
183
184
185
186
187
188
189
190
def __init__(self, data: Any) -> None:
    """
    Initialize the Renderer with the provided data.

    Args:
        data (Any): The input data to be rendered.
    """
    self.data = data

file_render()

Convert the data to a list format.

This method attempts to render the input data using the TreeGrid_to_json class, and convert it to a dictionary.

Returns:

Name Type Description
Dict None

The rendered data in list format.

Raises:

Type Description
Exception

If rendering the data fails.
Source code in pydfirram/core/renderer.py 
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
def file_render(self)-> None:
    """
    Convert the data to a list format.

    This method attempts to render the input data using the
    TreeGrid_to_json class, and convert it to a dictionary.

    Returns:
        Dict: The rendered data in list format.

    Raises:
        Exception: If rendering the data fails.
    """
    try:
        # (fixme) : `render()` return nothing
        TreeGrid_to_json().render(self.data)
    except Exception as e:
        logger.error("Impossible de rendre la sortie plugin en fichier.")
        raise OutputHandlingError(
            "Impossible de traiter les sorties artefacts du plugin."
        ) from e

to_df(max_row=False)

Convert the data to a pandas DataFrame.

This method first converts the data to a list format, and then constructs a pandas DataFrame from it.

Returns:

Type Description
DataFrame

pd.DataFrame: The data as a pandas DataFrame.

Raises:

Type Description
Exception

If rendering the data as a DataFrame fails.
Source code in pydfirram/core/renderer.py 
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
def to_df(self,max_row: bool = False) -> pd.DataFrame:
    """
    Convert the data to a pandas DataFrame.

    This method first converts the data to a list format, and then
    constructs a pandas DataFrame from it.

    Returns:
        pd.DataFrame: The data as a pandas DataFrame.

    Raises:
        Exception: If rendering the data as a DataFrame fails.
    """
    try:
        data_as_dict = self.to_list()
        dataframe = RenderableDataFrame(data_as_dict)
        dataframe._pydfirram_full_display = max_row
        return dataframe
    except Exception as e:
        logger.error("Impossible de convertir la sortie plugin en DataFrame.")
        raise OutputHandlingError(
            "Impossible de convertir la sortie plugin en tableau d'analyse."
        ) from e

to_json()

Convert the data to a JSON string.

This method first converts the data to a list format, and then serializes it to a JSON string.

Returns:

Name Type Description
str str

The data serialized as a JSON string.

Raises:

Type Description
Exception

If converting the data to JSON fails.
Source code in pydfirram/core/renderer.py 
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
def to_json(self) -> str:
    """
    Convert the data to a JSON string.

    This method first converts the data to a list format, and then
    serializes it to a JSON string.

    Returns:
        str: The data serialized as a JSON string.

    Raises:
        Exception: If converting the data to JSON fails.
    """
    try:
        data_as_dict = self.to_list()
        return dumps(data_as_dict)
    except Exception as e:
        logger.error("Impossible de convertir la sortie plugin en JSON.")
        raise OutputHandlingError(
            "Impossible de convertir la sortie plugin au format JSON."
        ) from e

to_list()

Convert the data to a list format.

This method attempts to render the input data using the TreeGrid_to_json class, and convert it to a dictionary.

Returns:

Name Type Description
Dict

The rendered data in list format.

Raises:

Type Description
Exception

If rendering the data fails.
Source code in pydfirram/core/renderer.py 
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
def to_list(self):
    """
    Convert the data to a list format.

    This method attempts to render the input data using the
    TreeGrid_to_json class, and convert it to a dictionary.

    Returns:
        Dict: The rendered data in list format.

    Raises:
        Exception: If rendering the data fails.
    """
    try:
        # (fixme) : `render()` should return nothing
        parsed_data : dict[str, Any] = TreeGrid_to_json().render(self.data)
        return parsed_data.get("data")
    except Exception as e:
        logger.error("Impossible de convertir la sortie plugin en liste.")
        raise OutputHandlingError(
            "Impossible de convertir la sortie plugin en liste exploitable."
        ) from e

TreeGrid_to_json

Bases: CLIRenderer

simple TreeGrid to JSON

Source code in pydfirram/core/renderer.py 
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
class TreeGrid_to_json(V3CLIRenderer):  # type: ignore
    """ simple TreeGrid to JSON
    """
    _type_renderers: Any = {
        V3HexBytes: lambda x: v3_quoted_optional(
            v3_hex_bytes_as_text,
        )(x),
        V3Disassembly: lambda x: v3_quoted_optional(
            v3_display_disassembly,
        )(x),
        V3MultiTypeData: lambda x: v3_quoted_optional(
            v3_multitypedata_as_text,
        )(x),
        bytes: lambda x: v3_optional(
            lambda x: " ".join([f"{b:02x}" for b in x])
        )(x),
        datetime.datetime: lambda x: (
            x.isoformat() if not isinstance(x, V3BaseAbsentValue) else None
        ),
        "default": lambda x: x,
    }

    name = "JSON"
    structured_output = True

    def get_render_options(self) -> list[V3RenderOption]:
        """
        Get render options.
        """
        return []

    # (fixme): This method should return nothing as defined in V3CLIRenderer
    def render(self, grid: V3TreeGrid) -> dict[str, Any]:
        """
        Render the TreeGrid to JSON format.

        Args:
            grid (interfaces.renderers.TreeGrid): The TreeGrid to render.

        Returns:
            Dict: The JSON representation of the TreeGrid.
        """
        final_output: tuple[
            dict[str, dict[str, Any]],
            list[dict[str, Any]],
        ] = ({}, [])

        def visitor(
            node: V3TreeNode,
            accumulator: tuple[dict[str, Any], list[dict[str, Any]]],
        ) -> tuple[dict[str, Any], list[dict[str, Any]]]:
            """
            A visitor function to process each node in the TreeGrid.

            Args:
                node (V3TreeNode): The current node being visited.
                accumulator (Tuple[Dict[str, Any], List[Dict[str, Any]]]):
                    The accumulator containing the accumulated results.

            Returns:
                Tuple[Dict[str, Any], List[Dict[str, Any]]]: The updated
                    accumulator.
            """
            acc_map = accumulator[0]
            final_tree = accumulator[1]
            node_dict: dict[str, Any] = {"__children": []}

            for column_index, column in enumerate(grid.columns):
                renderer = self._type_renderers.get(
                    column.type,
                    self._type_renderers["default"]
                )
                data = renderer(
                    list(node.values)[column_index],
                )
                if isinstance(data, V3BaseAbsentValue):
                    data = None
                node_dict[column.name] = data

            if node.parent:
                acc_map[node.parent.path]["__children"].append(node_dict)
            else:
                final_tree.append(node_dict)
            acc_map[node.path] = node_dict
            return acc_map, final_tree

        if not grid.populated:
            grid.populate(visitor, final_output)
        else:
            grid.visit(
                node=None,
                function=visitor,
                initial_accumulator=final_output,
            )
        return {"data": final_output[1]}

get_render_options()

Get render options.

Source code in pydfirram/core/renderer.py 
70
71
72
73
74
def get_render_options(self) -> list[V3RenderOption]:
    """
    Get render options.
    """
    return []

render(grid)

Render the TreeGrid to JSON format.

Parameters:

Name Type Description Default
grid TreeGrid

The TreeGrid to render.

 required

Returns:

Name Type Description
Dict dict[str, Any]

The JSON representation of the TreeGrid.
Source code in pydfirram/core/renderer.py 
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
def render(self, grid: V3TreeGrid) -> dict[str, Any]:
    """
    Render the TreeGrid to JSON format.

    Args:
        grid (interfaces.renderers.TreeGrid): The TreeGrid to render.

    Returns:
        Dict: The JSON representation of the TreeGrid.
    """
    final_output: tuple[
        dict[str, dict[str, Any]],
        list[dict[str, Any]],
    ] = ({}, [])

    def visitor(
        node: V3TreeNode,
        accumulator: tuple[dict[str, Any], list[dict[str, Any]]],
    ) -> tuple[dict[str, Any], list[dict[str, Any]]]:
        """
        A visitor function to process each node in the TreeGrid.

        Args:
            node (V3TreeNode): The current node being visited.
            accumulator (Tuple[Dict[str, Any], List[Dict[str, Any]]]):
                The accumulator containing the accumulated results.

        Returns:
            Tuple[Dict[str, Any], List[Dict[str, Any]]]: The updated
                accumulator.
        """
        acc_map = accumulator[0]
        final_tree = accumulator[1]
        node_dict: dict[str, Any] = {"__children": []}

        for column_index, column in enumerate(grid.columns):
            renderer = self._type_renderers.get(
                column.type,
                self._type_renderers["default"]
            )
            data = renderer(
                list(node.values)[column_index],
            )
            if isinstance(data, V3BaseAbsentValue):
                data = None
            node_dict[column.name] = data

        if node.parent:
            acc_map[node.parent.path]["__children"].append(node_dict)
        else:
            final_tree.append(node_dict)
        acc_map[node.path] = node_dict
        return acc_map, final_tree

    if not grid.populated:
        grid.populate(visitor, final_output)
    else:
        grid.visit(
            node=None,
            function=visitor,
            initial_accumulator=final_output,
        )
    return {"data": final_output[1]}