access-profiling 0.1__py3-none-any.whl

access/profiling/plotting_utils.py

@@ -0,0 +1,116 @@
+# Copyright 2025 ACCESS-NRI and contributors. See the top-level COPYRIGHT file for details.
+# SPDX-License-Identifier: Apache-2.0
+
+import matplotlib.pyplot as plt
+from matplotlib.figure import Figure
+
+from access.profiling.metrics import ProfilingMetric
+
+
+def calculate_column_widths(table_data: list[list], first_col_fraction: float = None) -> list:
+    """Calculate column widths based on content character length and required width for first column.
+
+    Args:
+        table_data (list[list]): Table data including headers. e.g.
+                                 [[  "ncpus",  "col1", "col2", "col3"],
+                                  ["region1",    0.1,    0.2,    0.3],
+                                  ["region2",    1. ,    2. ,    3. ]]
+        first_col_fraction (float): If provided, controls the fraction of the table width
+                                    assigned to the first column. Default None.
+                                    If set to 0.0 or None, all columns have the same width.
+                                    Must be between 0.0 (inclusive) and 1.0 (exclusive).
+
+    Returns:
+        list : Column width fractions, adding up to 1.
+
+    Raises:
+        ValueError: If table_data has fewer than 2 rows or 2 columns.
+        ValueError: If table_data shape is not rectangular, i.e., all rows do not have the same number of columns.
+    """
+    if not table_data:
+        return []
+
+    # Check that table has a header row and row-label column, and no missing elements.
+    if len(table_data) > 1:
+        for row in table_data[1:]:
+            if len(row) != len(table_data[0]):
+                raise ValueError("Table rows must have the same number of elements")
+    else:
+        raise ValueError("Table must have at least 2 rows (first row is table header)")
+    if len(table_data[0]) < 2:
+        raise ValueError("Table must have at least 2 columns (first column is row label)")
+
+    if first_col_fraction is not None and not (0 <= first_col_fraction < 1):
+        raise ValueError("first_col_fraction must be between 0 and 1 (exclusive)")
+
+    n_cols = len(table_data[0])
+
+    # Calculate max content length for each column based on no. of chars
+    max_lengths = []
+    for col in range(n_cols):
+        col_lengths = [len(str(row[col])) for row in table_data]
+        max_lengths.append(max(col_lengths))
+
+    if first_col_fraction and first_col_fraction > 0:
+        # Set data columns to proportional widths based on content and first_col_fraction
+        data_cols_total = sum(max_lengths[1:])
+        base_width = (1 - first_col_fraction) / data_cols_total
+
+        col_widths = [first_col_fraction]
+        for length in max_lengths[1:]:
+            col_widths.append(length * base_width)
+
+    else:
+        # Equal column width
+        total_length = sum(max_lengths)
+        col_widths = [length / total_length for length in max_lengths]
+
+    return col_widths
+
+
+def plot_bar_metrics(
+    data: dict[str, list[float]],
+    region_labels: list[str],
+    metric: ProfilingMetric,
+    show: bool = True,
+) -> Figure:
+    """Plots a grouped bar chart of a profiling metric over regions.
+
+    Regions are placed along the x-axis. Within each region group, there is one bar per
+    experiment, coloured by experiment name.
+
+    Args:
+        data (dict[str, list[float]]): Mapping of experiment name to a list of metric values,
+            one per region (in the same order as ``region_labels``).
+        region_labels (list[str]): Ordered list of region display labels for the x-axis.
+        metric (ProfilingMetric): The metric being plotted (used for axis labels and title).
+        show (bool): Whether to call ``plt.show()``. Default: True.
+
+    Returns:
+        Figure: The Matplotlib figure containing the bar chart.
+    """
+    exp_names = list(data.keys())
+    n_experiments = len(exp_names)
+    n_regions = len(region_labels)
+
+    fig, ax = plt.subplots(figsize=(max(8, n_experiments * n_regions * 0.8), 6))
+    bar_width = 0.8 / n_experiments
+    group_positions = list(range(n_regions))
+
+    for i, exp_name in enumerate(exp_names):
+        offsets = [pos + (i - (n_experiments - 1) / 2) * bar_width for pos in group_positions]
+        ax.bar(offsets, data[exp_name], width=bar_width, label=exp_name)
+
+    ax.set_xticks(group_positions)
+    ax.set_xticklabels(region_labels)
+    ax.set_xlabel("Region")
+    ax.set_ylabel(f"{metric.name} ({metric.units})")
+    ax.set_title(f"{metric.description}")
+    ax.legend(title="Experiment")
+    ax.grid(axis="y", linestyle="--", alpha=0.7)
+    fig.tight_layout()
+
+    if show:
+        plt.show()
+
+    return fig

access/profiling/scaling.py

@@ -0,0 +1,128 @@
+# Copyright 2025 ACCESS-NRI and contributors. See the top-level COPYRIGHT file for details.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Functions to calculate metrics related to parallel scaling of applications."""
+
+import matplotlib.gridspec as gridspec
+import matplotlib.pyplot as plt
+import xarray as xr
+from matplotlib.figure import Figure
+
+from access.profiling.metrics import ProfilingMetric
+from access.profiling.plotting_utils import calculate_column_widths
+
+
+def parallel_speedup(stats: xr.Dataset, metric: ProfilingMetric) -> xr.DataArray:
+    """Calculates the parallel speedup from scaling data.
+
+    Args:
+        stats (Dataset): Scaling data, stored as a xarray dataset.
+        metric (ProfilingMetric): Metric to use for the speedup calculation.
+
+    Returns:
+        DataArray: Parallel speedup.
+    Raises:
+        ValueError: If metric units are not time (e.g., seconds).
+    """
+    if stats[metric].pint.dimensionality != "[time]":
+        raise ValueError("Metric units must be time (e.g., seconds)!")
+    speedup = stats[metric].sel(ncpus=stats["ncpus"].min()) / stats[metric]
+    speedup.name = "speedup"
+    return speedup
+
+
+def parallel_efficiency(stats: xr.Dataset, metric: ProfilingMetric) -> xr.DataArray:
+    """Calculates the parallel efficiency from scaling data.
+
+    Args:
+        stats (Dataset): Scaling data, stored as a xarray dataset.
+        metric (ProfilingMetric): Metric to use for the efficiency calculation.
+
+    Returns:
+        DataArray: Parallel efficiency.
+    """
+    speedup = parallel_speedup(stats, metric)
+    eff = speedup * (speedup.ncpus.min() / speedup.ncpus)
+    eff = eff.pint.to("percent")
+    eff.name = "parallel efficiency"
+    return eff
+
+
+def plot_scaling_metrics(
+    stats: list[xr.Dataset],
+    metric: ProfilingMetric,
+    xcoordinate: str = "ncpus",
+    first_col_fraction: float = 0.4,
+    show: bool = True,
+) -> Figure:
+    """Plots parallel speedup and efficiency from a list of datasets
+
+    Args:
+        stats (list[xr.Dataset]): The raw times to plot.
+        metric (ProfilinMetric): The metric to plot for each stat.
+        xcoordinate (str): The x-axis variable e.g. "ncpus".
+        first_col_fraction (float): The fraction of table width to assign to the row labels. Default 0.4.
+        show (bool): Whether to show the generated plot. Default: True.
+
+    Returns:
+        Figure: The Matplotlib figure on which the scaling plots and table are plotted on.
+
+    Raises:
+        ValueError: If region_labels is non-empty
+    """
+
+    # setup plots
+    fig = plt.figure(figsize=(15, 6))
+    # using gridspec so table can be added
+    gs = gridspec.GridSpec(2, 2, height_ratios=[3, 1], hspace=0.3)
+    ax1, ax2 = fig.add_subplot(gs[0, 0]), fig.add_subplot(gs[0, 1])
+    ax_tbl = fig.add_subplot(gs[1, :])
+
+    # add table of raw timings
+    tbl = [[xcoordinate] + list(stats[0][xcoordinate].values)]  # first row
+    for stat in stats:
+        # calculate efficiency and speedup
+        efficiency = parallel_efficiency(stat, metric)
+        speedup = parallel_speedup(stat, metric)
+
+        # plots speedup and efficiency on their respective axes.
+        max_eff = 100
+        for region in stat.region.values:
+            speedup.loc[region, :].plot.line(x=xcoordinate, ax=ax1, marker="o", label=region)
+            efficiency.loc[region, :].plot.line(x=xcoordinate, ax=ax2, marker="o", label=region)
+            # find max efficiency for setting efficiency axis
+            max_eff = max(max_eff, efficiency.loc[region, :].max())
+
+            tbl.append([region] + [f"{val:.2f}" for val in stat[metric].loc[:, region].pint.dequantify().values])
+
+    # ideal speedup/scaling
+    minx = stat[xcoordinate].values.min()
+    nx = len(stat[xcoordinate].values)
+    ideal_speedups = [i / minx for i in stat[xcoordinate].values]
+    ax1.plot(stat[xcoordinate].values, ideal_speedups, "k:", label="ideal")
+    ax2.plot(stat[xcoordinate].values, [100] * nx, "k:", label="ideal")
+
+    # formatting
+    ax1.legend()
+    ax1.grid()
+    ax2.grid()
+    ax2.set_ylim((0, 1.1 * max_eff))
+    ax1.set_title("Parallel Speedup")
+    ax2.set_title("Parallel Efficiency")
+    ax_tbl.axis("off")
+    tbl_chart = ax_tbl.table(
+        tbl,
+        bbox=(0.05, 0, 0.9, 1),
+        cellLoc="center",
+        colWidths=calculate_column_widths(tbl, first_col_fraction),
+    )
+    ax_tbl.set_title(f"Timings ({stat[metric].pint.units})")
+    for i in range(len(tbl[0])):
+        tbl_chart[(0, i)].set_text_props(weight="bold")
+    for i in range(len(tbl)):
+        tbl_chart[(i, 0)].set_text_props(weight="bold")
+
+    if show:
+        plt.show()
+
+    return fig

access/profiling/um_parser.py

@@ -0,0 +1,242 @@
+# Copyright 2025 ACCESS-NRI and contributors. See the top-level COPYRIGHT file for details.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Parser for UM profiling data.
+This routine parses the inclusive timers from the UM output log
+(e.g. ``atm.fort6.pe0`` for UM7) and returns a dictionary of the
+profiling data. Since UM7 and UM13 provides multiple sections with timer
+output - we have chosen to use the 'Wallclock times' sub-section
+within the Inclusive Timer Summary section.
+
+The profiling data is assumed to have the following
+format:
+
+```
+ MPP : Inclusive timer summary
+
+ WALLCLOCK  TIMES
+ <N>   ROUTINE                   MEAN   MEDIAN       SD   % of mean      MAX   (PE)      MIN   (PE)
+  1 AS3 Atmos_Phys2        1308.30  1308.30     0.02       0.00%  1308.33 ( 118)  1308.26 ( 221)
+  2 AP2 Boundary Layer      956.50   956.13     3.26       0.34%   981.27 ( 136)   953.28 (  43)
+  3 AS5-8 Updates           884.62   885.52     2.89       0.33%   889.49 (  48)   879.36 ( 212)
+
+...
+
+         CPU TIMES (sorted by wallclock times)
+ <N>    ROUTINE                   MEAN   MEDIAN       SD   % of mean      MAX   (PE)      MIN   (PE)
+...
+
+ ```
+
+All columns in the first sub-section, except for the numeric index and the `% of mean`, are parsed and returned.
+For UM versions 13.x, there is an extra 'N' column name that appears to the left of 'ROUTINE'; this 'N' is
+not present in the output from UM v7.x .
+
+"""
+
+import logging
+import os
+import re
+from pathlib import Path
+
+from access.profiling.metrics import pemax, pemin, tavg, tmax, tmed, tmin, tstd
+from access.profiling.parser import ProfilingParser, _convert_from_string, _read_text_file
+
+logger = logging.getLogger(__name__)
+
+
+class UMProfilingParser(ProfilingParser):
+    """UM profiling output parser."""
+
+    # The parsed column names that will be kept. The order needs to match
+    # the order of the column names in the input data (defined as ``raw_headers``
+    # in the ``read``` method), after discarding the ignored columns.
+    _metrics = [tavg, tmed, tstd, tmax, pemax, tmin, pemin]
+
+    def parse(self, file_path: str | Path | os.PathLike) -> dict:
+        """Parse UM profiling data from a file path.
+
+        Args:
+            file_path (str | Path | os.PathLike): file to parse.
+
+        Returns:
+            stats (dict): dictionary of parsed profiling data.
+                    Ignores two columns ``N``, and ``% over mean`` columns.
+
+                    To keep consistent column names across all parsers, the following
+                    mapping is used:
+                        ==================  ==================
+                        UM column name      Standard metric
+                        ==================  ==================
+                        N                   - (ignored)
+                        ROUTINE             region
+                        MEAN                tavg
+                        MEDIAN              tmed
+                        SD                  tstd
+                        % of mean           - (ignored)
+                        MAX                 tmax
+                        (PE)                pemax
+                        MIN                 tmin
+                        (PE)                pemin
+                        ==================  ==================
+                    Each key returns a list of values, one for each region. For
+                    example, if there are 20 regions, ``stats['tavg']`` will
+                    return a list with 20 values, one each for each of the regions.
+
+                    The assumption is that people will want to look at the same metric
+                    for *all* regions at a time; if you want to look at all metrics for
+                    a single region, then you will have to first find the index for the
+                    ``region``, and then extract that index from *each* of the 'metric'
+                    lists.
+
+                    Any number of column headers can be present at the beginning, i.e., before
+                    ``ROUTINE`` (including ``N`` for UM v13+) and will be ignored when the
+                    header is being parsed. Such columns must contain integer values for the
+                    profiling information parsing to work, otherwise (e.g., new columns with float
+                    data), an ``AssertionError`` is raised.
+
+                    Parsing will fail if there are any unexpected columns at the end, either
+                    at the end of the expected header, or the end of the expected columns with
+                    profiling data (regardless of type of the column value)
+
+        Raises:
+            ValueError: If the UM version number can not be found in the input string data.
+            ValueError: If a match for any of header, footer or section (i.e., empty section)
+                        is not found.
+            AssertionError: If the expected format is not found in *all* of the lines within the
+                            profiling section.
+            TypeError: If file_path cannot be converted to a valid Path object.
+            FileNotFoundError: If file_path doesn't exist or isn't a file.
+        """
+
+        stream = _read_text_file(file_path)
+
+        # First create the local variable with the metrics list
+        metrics = self.metrics
+        raw_headers = ["ROUTINE", "MEAN", "MEDIAN", "SD", r"\% of mean", "MAX", r"\(PE\)", "MIN", r"\(PE\)"]
+
+        header = r"MPP : Inclusive timer summary\s+WALLCLOCK  TIMES\s*"
+        # UM 13 has an extra header 'N' for the numeric row index (that UM7 does not)
+        # Writing the pattern this way avoids having to code in UM version dependent patterns
+        header += r"\S*\s+"
+        # Then skip over white-space-separated header names.
+        header += r"\s*".join(raw_headers) + r"\s*"
+        header_pattern = re.compile(header, re.MULTILINE)
+        header_match = header_pattern.search(stream)
+        if not header_match:
+            logger.debug("Header pattern: %s", header)
+            logger.debug("Input string: %s", stream)
+            raise ValueError(f"No matching header found in {file_path}.")
+        logger.debug("Found header: %s", header_match.group(0))
+
+        # This line (and any preceeding whitespace) indicates
+        # the end of the profiling data that we want to parse
+        footer = r"CPU TIMES \(sorted by wallclock times\)\s*"
+        footer_pattern = re.compile(footer, re.MULTILINE)
+        footer_match = footer_pattern.search(stream)
+        if not footer_match:
+            logger.debug("Footer pattern: %s", footer)
+            logger.debug("Input string: %s", stream)
+            raise ValueError("No matching footer found.")
+        logger.debug("Found footer: %s", footer_match.group(0))
+
+        # Match *everything* between the header and footer (the match could be 0 characters)
+        profiling_section_p = re.compile(header + r"(.*)" + footer, re.MULTILINE | re.DOTALL)
+        profiling_section = profiling_section_p.search(stream)
+
+        profiling_section = profiling_section.group(1)
+        logger.debug("Found section: %s", profiling_section)
+
+        # This is regex dark arts - seems to work, I roughly understood when I
+        # was refining this named capture group, but I might not be able to in
+        # the future. Made heavy use of the regex debugger at regex101.com :) - MS 19/9/2025
+        profile_line = r"^\s*[\d\s]+\s+(?P<region>[a-zA-Z][a-zA-Z:()_/\-*&0-9\s\.]+(?<!\s))"
+        for metric in metrics:
+            logger.debug(f"Adding {metric.name=}")
+            group_name = "".join(metric.name.split())  # remove any white-space from metric name to create group name
+            if metric in [pemax, pemin]:
+                # the pemax and pemin values are enclosed within brackets '()',
+                # so we need to ignore both the opening and closing brackets
+                add_pattern = r"\s+\(\s*(?P<" + group_name + r">[0-9.]+)\s*\)"
+            elif metric == tstd:
+                add_pattern = (
+                    r"\s+(?P<" + group_name + r">[0-9.]+)\s+[\S]+"
+                )  # SD is followed by % of mean -> ignore that column
+            else:
+                add_pattern = (
+                    r"\s+(?P<" + group_name + r">[0-9.]+)"
+                )  # standard white-space followed by a sequence of digits or '.'
+
+            logger.debug(f"{add_pattern=} for {metric.name=}")
+            profile_line += add_pattern
+            logger.debug(f"{profile_line=} after {metric.name=}")
+
+        profile_line += r"$"  # the regex should match till the end of line.
+        profiling_region_p = re.compile(profile_line, re.MULTILINE)
+
+        stats = {"region": []}
+        stats.update({m: [] for m in self.metrics})
+        for line in profiling_region_p.finditer(profiling_section):
+            logger.debug(f"Matched line: {line.group(0)}")
+            stats["region"].append(line.group("region"))
+            for metric in metrics:
+                group_name = "".join(metric.name.split())
+                stats[metric].append(_convert_from_string(line.group(group_name)))
+
+        # Parsing is done - let's run some checks
+        num_lines = len(profiling_section.strip().split("\n"))
+        logger.debug(f"Found {num_lines} lines in profiling section")
+        if len(stats["region"]) != num_lines:
+            raise AssertionError(f"Expected {num_lines} regions, found {len(stats['region'])}.")
+
+        logger.info(f"Found {len(stats['region'])} regions with profiling info")
+        return stats
+
+
+"""Example UM7 runtime log snippet to be parsed for total wallclock runtime:
+
+```
+ END OF RUN - TIMER OUTPUT
+ Timer information is for whole run
+ PE                      0  Elapsed CPU Time:    3943.63426200007     
+ PE                      0   Elapsed Wallclock Time:    3943.80157899974     
+ 
+ Total Elapsed CPU Time:    820297.910506003     
+ Maximum Elapsed Wallclock Time:    3944.07699399998     
+ Speedup:    207.982225436750     
+```
+"""
+
+
+class UMTotalRuntimeParser(ProfilingParser):
+    """Parser for UM total runtime from the UM log file."""
+
+    _metrics = [tmax]
+
+    def parse(self, file_path: str | Path | os.PathLike) -> dict:
+        """Parse UM total runtime from a file.
+
+        Args:
+            file_path (str | Path | os.PathLike): input string to parse.
+
+        Returns:
+            dict: dictionary of parsed profiling data.
+
+        Raises:
+            ValueError: If no matching total runtime line is found.
+        """
+        stream = _read_text_file(file_path)
+        total_runtime_pattern = re.compile(
+            r"Maximum\s+Elapsed\s+Wallclock\s+Time\s*:\s*(?P<total_time>[0-9.]+)\s*",
+            re.MULTILINE,
+        )
+        total_runtime_match = total_runtime_pattern.search(stream)
+        if not total_runtime_match:
+            logger.debug("Total runtime pattern: %s", total_runtime_pattern)
+            logger.debug("Input string: %s", stream)
+            raise ValueError("No matching total runtime line found.")
+
+        total_time = float(total_runtime_match.group("total_time"))
+        logger.debug(f"Found total UM runtime: {total_time} seconds")
+
+        return {"region": ["um_total_walltime"], tmax: [total_time]}

access_profiling-0.1.dist-info/METADATA

@@ -0,0 +1,100 @@
+Metadata-Version: 2.4
+Name: access-profiling
+Version: 0.1
+Summary: Tools and utilities to profile the ACCESS climate models.
+Author-email: Micael Oliveira <micael.oliveira@anu.edu.au>, Manodeep Sinha <manodeep.sinha@anu.edu.au>, Edward Yang <edward.yang@anu.edu.au>
+Keywords: profiling,access
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Utilities
+Requires-Python: >=3.11.4
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: xarray
+Requires-Dist: pint
+Requires-Dist: pint-xarray
+Requires-Dist: matplotlib
+Requires-Dist: access-config-utils
+Requires-Dist: experiment-runner
+Requires-Dist: experiment-generator
+Requires-Dist: payu
+Provides-Extra: devel
+Requires-Dist: pre-commit; extra == "devel"
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Dynamic: license-file
+
+# access-profiling
+
+![CI](https://github.com/ACCESS-NRI/access-profiling/actions/workflows/ci.yml/badge.svg) [![codecov](https://codecov.io/github/ACCESS-NRI/access-profiling/graph/badge.svg?token=KtmrCtSyMv)](https://codecov.io/github/ACCESS-NRI/access-profiling) [![License](https://img.shields.io/badge/license-Apache%202.0-blue?style=flat-square)](https://opensource.org/license/apache-2-0) [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+
+## About
+
+A Python package providing various tools and utilities to profile the models developed at [ACCESS-NRI](https://github.com/ACCESS-NRI).
+
+## Key Features
+
+- Parsers to extract profiling data from model output.
+- Functions to plot key profiling metrics.
+
+## Documentation
+
+Coming soon.
+
+## Installation
+
+### Using pip
+
+You can install the latest release directly from PyPI:
+```shell
+pip install access-profiling
+```
+
+### From source
+
+If you prefer to install from source:
+```shell
+git clone https://github.com/ACCESS-NRI/access-profiling.git
+cd access-profiling
+pip install .
+```
+
+## Usage
+
+Coming soon.
+
+## Development installation
+
+If you intend to contribute or modify the package, it is recommended to work inside a virtual environment.
+
+1. Create and activate a virtual environment
+```shell
+# Create a virtual environment
+python3 -m venv .venv
+
+# Activate the virtual environment
+source .venv/bin/activate
+```
+
+2. Install in editable mode with development and test dependencies
+```shell
+pip install -e ".[devel,test]"
+```
+This will install the package in editable mode, meaning changes to the source code are reflected immediately without reinstallation. Development dependencies such as testing tools will also be installed.
+
+3. Run the test suite
+```shell
+pytest
+```
+
+## Contributing
+
+Contributions are welcome! Please open an issue or submit a pull request if you’d like to add features, fix bugs, or improve documentation.
+
+For significant contributions, we recommend discussing proposed changes in an issue before opening a pull request.
+
+## License
+
+This project is licensed under the Apache 2.0 License.

access_profiling-0.1.dist-info/RECORD

@@ -0,0 +1,21 @@
+access/profiling/__init__.py,sha256=PZZoZy6rHr5221EaJsI3YhuLzgKFvD2fMf2FmCWvl1Y,1025
+access/profiling/access_models.py,sha256=GAXfaiid9psHYOyXBAXyt2YfZJs1cjVXCkIlRx6mNGU,3186
+access/profiling/cice5_parser.py,sha256=tBhRYZhMupade3ALuvNPzYEC5nzfMOeAfRTIEi0lVYU,2926
+access/profiling/cylc_manager.py,sha256=YNzW4KtXhFzKWx47VrtguqroBH4O7QtTleZbaKOofsU,9777
+access/profiling/cylc_parser.py,sha256=2oNJVUWXiGxiYTmGjL0jd3KBlGulTMCjI0kCaXGrVEk,5332
+access/profiling/esmf_parser.py,sha256=-wIwJmgZWPIUmUeNLXXAaxXweLVbPaDC2u7K_AAfGzo,7948
+access/profiling/experiment.py,sha256=K16h-a_X3V-68gkmHXRL162WsZocZf4DrIay5xhah64,11512
+access/profiling/fms_parser.py,sha256=GjsKpSj6-gYLHa-go0kljdO5L_7QCKa98cOgWs6YJio,3481
+access/profiling/manager.py,sha256=w-xiQRxGfp4k0i0bVKyyW-jzFrHMX040h6CeA8FG880,27825
+access/profiling/metrics.py,sha256=1iDPSDcczq9sCI2ULYKI8W5opvHHLn4QR40pmw5Bu68,3300
+access/profiling/parser.py,sha256=8YwNhIAVjRvJhZvA6hl7_BK118HBbG5VAY5Jp0BV7zw,9102
+access/profiling/payu_manager.py,sha256=hlVLleN20-VFb1i3CrBbQYib_PhMlkeTioupDDjioRw,14421
+access/profiling/payujson_parser.py,sha256=jTqtXKkoMacKB2Yc6Hoi6xcMkcrZEJs_nGv73zFFByM,2287
+access/profiling/plotting_utils.py,sha256=io8-BIFZGhCkHlDeEsPxTnlR0iegCv27sxeZTUFdutU,4607
+access/profiling/scaling.py,sha256=GruGTn5y3no-QxbT-kHpR9Q6RrPzpVtrkglRLSGrwbs,4620
+access/profiling/um_parser.py,sha256=E8VJ7Tq5VIrTRbzrNcPfQkSnHoaNdOS_nId4G8StLDo,11202
+access_profiling-0.1.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+access_profiling-0.1.dist-info/METADATA,sha256=tTDn4iq7SJQJUq2PyOt60ss6rvYxXPzeQMkuKQJbQeU,3115
+access_profiling-0.1.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+access_profiling-0.1.dist-info/top_level.txt,sha256=dKU9Xvk9JgcB3ufviuSVfTY6KZ2eihlcvYerY_-00OQ,7
+access_profiling-0.1.dist-info/RECORD,,

access_profiling-0.1.dist-info/WHEEL

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