talp-pages 3.4.0a1__tar.gz

talp_pages-3.4.0a1/PKG-INFO

@@ -0,0 +1,97 @@
+Metadata-Version: 2.1
+Name: talp-pages
+Version: 3.4.0a1
+Summary: Command line tools to generate performance reports using the TALP module of DLB
+Home-page: https://pm.bsc.es/gitlab/dlb/talp-pages/
+License: GPL-3.0-only
+Keywords: HPC,Performance Analysis,Profiling,Continuous Performance Analysis
+Author: Valentin Seitz
+Author-email: valentin.seitz@bsc.es
+Maintainer: Valentin Seitz
+Maintainer-email: valentin.seitz@bsc.es
+Requires-Python: >=3.9,<4.0
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Visualization
+Classifier: Topic :: System :: Distributed Computing
+Requires-Dist: jinja2 (>=3.1.4,<4.0.0)
+Requires-Dist: pandas (>=2.2.2,<3.0.0)
+Requires-Dist: python-gitlab (>=4.4.0,<5.0.0)
+Project-URL: Repository, https://pm.bsc.es/gitlab/dlb/talp-pages/
+Description-Content-Type: text/markdown
+
+![TALP LOGO](https://pm.bsc.es/gitlab/dlb/talp-pages/-/raw/add-v1/talp_dlb_logo.png){height=250px}
+
+# Talp Pages
+
+TALP Pages is a collection of Python scripts to postprocess the `json` outputs of [DLB TALP](https://pm.bsc.es/ftp/dlb/doc/user-guide/intro.html#talp-tracking-application-live-performance) and Gitlab pipeline snippets [that can be included](https://docs.gitlab.com/ee/ci/yaml/#include) in your project.
+This makes it easy to integrate TALP into your CI/CD setup and run Continous Benchmarking without having to code up your own solution.
+
+**We provide:**
+
+- talp_pages: Command line tool to generate static html pages
+- Artifact management: A easy way to use Gitlab Artifacts to generate time series data plots.
+- Reusable Jobs that easily integrate into a existing Gitlab CI enviroment
+
+## Use python package
+
+Talp-Pages is written in Python (3.9+). We rely on [poetry](https://python-poetry.org/) for packaging.
+To use, simply install via:
+
+```pip install talp-pages```
+
+From there you should have the following command-line tools available:
+
+- `talp_report`
+- `talp_add_to_db`
+- `talp_badge`
+- `talp_report_ts`
+- `talp_pages`
+- `talp_download_artifacts`
+
+## Use Gitlab Jobs
+
+This section currently is not completly done, but we provide examples on how to use the jobs below:
+
+```yaml
+
+talp-performance-run:
+  stage: performance
+  image: python:3.12-bullseye
+  script:
+    - python generate_talp_json.py
+  artifacts:
+    paths:
+      - talp.json
+
+
+include:
+  - remote: https://pm.bsc.es/gitlab/dlb/talp-pages/-/raw/main/templates/add-to-db/template.yml
+    inputs:
+      stage: deploy
+      generating_job: talp-performance-run
+      talp_output: ./talp.json
+      enviroment: production
+      gitlab_url: https://gitlab.com
+      project_name: valentin.seitz1/sample-application
+      dlb_home: ./dlb_talp
+      job_name: talp-create-artifacts
+  - remote: https://pm.bsc.es/gitlab/dlb/talp-pages/-/raw/main/templates/generate-html/template.yml
+    inputs:
+      stage: deploy
+      generating_job: talp-create-artifacts
+      enviroment: production
+      dlb_home: ./dlb_talp
+      job_name: talp-gen-html
+```
+
+## License
+
+Talp-Pages is available under the General Public License v3.0.
+

talp_pages-3.4.0a1/README.md

@@ -0,0 +1,68 @@
+![TALP LOGO](https://pm.bsc.es/gitlab/dlb/talp-pages/-/raw/add-v1/talp_dlb_logo.png){height=250px}
+
+# Talp Pages
+
+TALP Pages is a collection of Python scripts to postprocess the `json` outputs of [DLB TALP](https://pm.bsc.es/ftp/dlb/doc/user-guide/intro.html#talp-tracking-application-live-performance) and Gitlab pipeline snippets [that can be included](https://docs.gitlab.com/ee/ci/yaml/#include) in your project.
+This makes it easy to integrate TALP into your CI/CD setup and run Continous Benchmarking without having to code up your own solution.
+
+**We provide:**
+
+- talp_pages: Command line tool to generate static html pages
+- Artifact management: A easy way to use Gitlab Artifacts to generate time series data plots.
+- Reusable Jobs that easily integrate into a existing Gitlab CI enviroment
+
+## Use python package
+
+Talp-Pages is written in Python (3.9+). We rely on [poetry](https://python-poetry.org/) for packaging.
+To use, simply install via:
+
+```pip install talp-pages```
+
+From there you should have the following command-line tools available:
+
+- `talp_report`
+- `talp_add_to_db`
+- `talp_badge`
+- `talp_report_ts`
+- `talp_pages`
+- `talp_download_artifacts`
+
+## Use Gitlab Jobs
+
+This section currently is not completly done, but we provide examples on how to use the jobs below:
+
+```yaml
+
+talp-performance-run:
+  stage: performance
+  image: python:3.12-bullseye
+  script:
+    - python generate_talp_json.py
+  artifacts:
+    paths:
+      - talp.json
+
+
+include:
+  - remote: https://pm.bsc.es/gitlab/dlb/talp-pages/-/raw/main/templates/add-to-db/template.yml
+    inputs:
+      stage: deploy
+      generating_job: talp-performance-run
+      talp_output: ./talp.json
+      enviroment: production
+      gitlab_url: https://gitlab.com
+      project_name: valentin.seitz1/sample-application
+      dlb_home: ./dlb_talp
+      job_name: talp-create-artifacts
+  - remote: https://pm.bsc.es/gitlab/dlb/talp-pages/-/raw/main/templates/generate-html/template.yml
+    inputs:
+      stage: deploy
+      generating_job: talp-create-artifacts
+      enviroment: production
+      dlb_home: ./dlb_talp
+      job_name: talp-gen-html
+```
+
+## License
+
+Talp-Pages is available under the General Public License v3.0.

talp_pages-3.4.0a1/pyproject.toml

@@ -0,0 +1,40 @@
+[tool.poetry]
+name = "talp-pages"
+version = "3.4.0-alpha1"
+description = "Command line tools to generate performance reports using the TALP module of DLB"
+authors = ["Valentin Seitz <valentin.seitz@bsc.es>"]
+maintainers = ["Valentin Seitz <valentin.seitz@bsc.es>"]
+readme = "README.md"
+license = "GPL-3.0-only"
+keywords = ["HPC", "Performance Analysis","Profiling","Continuous Performance Analysis"]
+classifiers = [
+    "Intended Audience :: Science/Research",
+    "Operating System :: OS Independent",
+    "Topic :: Scientific/Engineering :: Visualization",
+    "Topic :: System :: Distributed Computing"
+]
+
+homepage = "https://pm.bsc.es/gitlab/dlb/talp-pages/"
+repository= "https://pm.bsc.es/gitlab/dlb/talp-pages/"
+include = [
+    "talp_pages/templates/*.jinja"
+]
+
+[tool.poetry.dependencies]
+python = "^3.9"
+python-gitlab = "^4.4.0"
+jinja2 = "^3.1.4"
+pandas = "^2.2.2"
+
+
+[tool.poetry.scripts]
+talp_add_to_db = 'talp_pages.talp_add_to_db:main'
+talp_report = 'talp_pages.talp_report:main'
+talp_badge = 'talp_pages.talp_badge:main'
+talp_report_ts = 'talp_pages.talp_report_ts:main'
+talp_pages = 'talp_pages.talp_pages:main'
+talp_download_artifacts = 'talp_pages.download_artifacts:main'
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

talp_pages-3.4.0a1/talp_pages/download_artifacts.py

@@ -0,0 +1,90 @@
+#!/usr/bin/env python
+
+import os
+import argparse
+import gitlab
+import logging
+
+"""
+    Script to automagically choose a suitable authentication method and download the .zip archive of the last sucessfull 
+    execution of that jobname on the branch: ref-name
+    Requires python-gitlab to be installed
+
+    Default behaviour: create empty zip file
+"""
+
+
+def download_artifacts(gl, project_name, job_name, ref_name, gitlab_token=None, output_file=None):
+    try:
+        project = gl.projects.get(project_name)
+    except gitlab.exceptions.GitlabGetError as e:
+        logging.error("Failed to get project details: %s", str(e))
+        return
+
+    logging.debug("Found project ID: %s", project.id)
+
+    # Get artifacts for the job
+    try:
+        artifacts_file = project.artifacts.download(
+            ref_name=ref_name, job=job_name.strip())
+        logging.info("Artifacts downloaded successfully: %s", output_file)
+    except Exception as e:
+        logging.critical(
+            "Wasnt able to download artifacts, continue with a empty zip directory")
+        artifacts_file = b'PK\x05\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+
+    with open(output_file, 'wb') as f:
+        f.write(artifacts_file)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Download artifacts from the latest successful GitLab CI job")
+    parser.add_argument(
+        "--gitlab-url", help="GitLab URL (the thing before /api/*)", required=True)
+    parser.add_argument(
+        "--project-name", help="GitLab project name (format: namespace/project)", required=True)
+    parser.add_argument(
+        "--job-name", help="Name of the GitLab CI job from which to download the artifact", required=True)
+    parser.add_argument(
+        "--output-file", help="Output file name for downloaded artifacts", required=True)
+    parser.add_argument(
+        "--ref-name", help="GitLab branch name", default="main")
+    parser.add_argument(
+        "--gitlab-token", help="Personal GitLab access token (if not specified it will try to use a job_token)")
+    parser.add_argument(
+        "--log-level", help="Logging level (DEBUG, INFO, WARNING, ERROR)", default="INFO")
+
+    args = parser.parse_args()
+
+    log_level = getattr(logging, args.log_level.upper(), None)
+    if not isinstance(log_level, int):
+        raise ValueError("Invalid log level: %s" % args.log_level)
+
+    logging.basicConfig(level=log_level)
+    job_gitlab_token = None
+    gitlab_token = None
+
+    if args.gitlab_token:
+        gitlab_token = args.gitlab_token
+    else:
+        job_gitlab_token = os.getenv("CI_JOB_TOKEN")
+        print(job_gitlab_token)
+        logging.debug("Using the CI_JOB_TOKEN variant")
+
+    gl = None
+    if gitlab_token:
+        gl = gitlab.Gitlab(args.gitlab_url, private_token=gitlab_token)
+        gl.auth()
+    elif job_gitlab_token:
+        gl = gitlab.Gitlab(args.gitlab_url, job_token=job_gitlab_token)
+        logging.debug("Using the CI_JOB_TOKEN variant")
+    else:
+        gl = gitlab.Gitlab(args.gitlab_url)
+
+    download_artifacts(gl, args.project_name, args.job_name,
+                       args.ref_name, args.gitlab_token, args.output_file,)
+
+
+if __name__ == "__main__":
+    main()

talp_pages-3.4.0a1/talp_pages/talp_add_to_db.py

@@ -0,0 +1,97 @@
+# myapp/app.py
+import argparse
+import json
+import os
+
+from datetime import datetime
+import sqlite3
+import logging
+from .talp_common import TALP_TABLE_NAME, TALP_TABLE_COLUMNS_WITH_DATATYPES, TALP_TABLE_COLUMNS
+
+
+# Function to insert data into the SQLite database
+def insert_data(conn, timestamp, talp_output, metadata):
+    # Connect to the SQLite database
+    cursor = conn.cursor()
+
+    try:
+        # Create a table if it doesn't exist
+        cursor.execute(
+            f"CREATE TABLE IF NOT EXISTS {TALP_TABLE_NAME} {TALP_TABLE_COLUMNS_WITH_DATATYPES}")
+
+        # Create an index on the timestamp column
+        cursor.execute(
+            f"CREATE INDEX IF NOT EXISTS idx_timestamp ON {TALP_TABLE_NAME} (timestamp)")
+
+        # Convert JSON objects to string format
+
+        # Insert data into the table
+        cursor.execute(f"INSERT INTO {TALP_TABLE_NAME} {TALP_TABLE_COLUMNS} VALUES (?, ?, ?)", (
+            timestamp, json.dumps(talp_output), json.dumps(metadata)))
+
+        # Commit changes and close the connection
+        conn.commit()
+        logging.debug("Data inserted successfully")
+    except sqlite3.Error as e:
+        logging.critical("ERROR inserting data:", e)
+    finally:
+        # Close the connection
+        conn.close()
+
+
+def main():
+    # Parse command-line arguments
+    parser = argparse.ArgumentParser(
+        description='Add talp.json to the local time series database')
+    parser.add_argument('-i', '--input', dest='talp',
+                        help='talp.json file to be added', required=True)
+    parser.add_argument('-m', '--metadata', dest='metadata',
+                        help='metadata.json file to be added', required=False)
+    parser.add_argument('-db', '--database', dest='database',
+                        help='TALP.db file. If not specified a new one will be generated', required=False)
+    # TODO add timestamp mechanism
+    args = parser.parse_args()
+
+    # Check if the JSON file exists
+    if not os.path.exists(args.talp):
+        logging.error(f"The specified JSON file '{args.talp}' does not exist.")
+        return
+
+    if args.metadata:
+        if not os.path.exists(args.metadata):
+            logging.error(
+                f"The specified JSON file '{args.metadata}' does not exist.")
+            return
+
+    # Set output
+    if args.database:
+        DB_FILE = args.database
+    else:
+        DB_FILE = "TALP.db"
+
+    # Connect to database
+    conn = sqlite3.connect(DB_FILE)
+
+    current_timestamp = datetime.now()
+
+    with open(args.talp, 'r') as json_file:
+        try:
+            talp_output = json.load(json_file)
+        except json.JSONDecodeError as e:
+            logging.error(f"Error decoding JSON: {e}")
+            return
+    if args.metadata:
+        with open(args.metadata, 'r') as json_file:
+            try:
+                metadata = json.load(json_file)
+            except json.JSONDecodeError as e:
+                logging.error(f"Error decoding JSON: {e}")
+                return
+    else:
+        metadata = {}
+
+    insert_data(conn, current_timestamp, talp_output, metadata)
+
+
+if __name__ == "__main__":
+    main()

talp_pages-3.4.0a1/talp_pages/talp_badge.py

@@ -0,0 +1,99 @@
+#!/usr/bin/env python
+
+import argparse
+import json
+import os
+from urllib.request import urlopen, Request
+import logging
+from .talp_common import TALP_POP_METRICS_KEY,TALP_DEFAULT_REGION_NAME
+
+class TalpBadge:
+    def __init__(self, talp_file):
+        # Now directly try to create a connection
+        with open(talp_file, 'r') as json_file:
+            # dont catch exception, but fail
+            self.raw_data = json.load(json_file)
+        
+        logging.debug(f"Created TalpReport and read the json: {self.raw_data}")
+        # do some sanity checks
+        if not self.raw_data[TALP_POP_METRICS_KEY]:
+            logging.error(f"No {TALP_POP_METRICS_KEY} found in {talp_file}. Try re-running DLB with arguments --talp --talp-summary=pop-metrics --talp-file={talp_file}")
+            raise Exception(f"No {TALP_POP_METRICS_KEY} found")
+
+    def get_badge_svg(self):
+        
+        parallel_efficiency = None
+        pop_metric_regions = self.raw_data[TALP_POP_METRICS_KEY]
+        for region in pop_metric_regions:
+            if region['name'] == TALP_DEFAULT_REGION_NAME:
+                parallel_efficiency = region['parallelEfficiency']
+
+
+        if not parallel_efficiency:
+            raise Exception(f"Could not find {TALP_DEFAULT_REGION_NAME} in provided json")
+        
+        parallel_efficiency = round(parallel_efficiency, 2)
+        
+        if parallel_efficiency < 0.6:
+            bagde_url = f"https://img.shields.io/badge/Parallel_efficiency-{parallel_efficiency}-red"
+        elif parallel_efficiency < 0.8:
+            bagde_url = f"https://img.shields.io/badge/Parallel_efficiency-{parallel_efficiency}-orange"
+        else:
+            bagde_url = f"https://img.shields.io/badge/Parallel_efficiency-{parallel_efficiency}-green"
+
+        return urlopen(Request(url=bagde_url, headers={'User-Agent': 'Mozilla'})).read()
+
+
+
+def _validate_inputs(args):
+    output_file=None
+    input_file=None
+    # Check if the JSON file exists
+    if not os.path.exists(args.input):
+        raise Exception(
+            f"Error: The specified JSON file '{args.json_file}' does not exist.")
+    else:
+        input_file= args.input
+    # Set output
+    if args.output:
+        output_file = args.output
+        if not args.output.endswith('.svg'):
+            output_file += ".svg"
+            logging.info(f"Appending .svg to '{args.output}'")
+        # Check if the HTML file exists
+        if os.path.exists(args.output):
+            logging.info(f"Overwriting '{args.output}'")
+    else:
+        output_file = args.input.replace(".json", "")
+        output_file += ".svg"
+
+    return output_file,input_file
+
+def main():
+    # Parse command-line arguments
+    parser = argparse.ArgumentParser(
+        description='Render a SVG badge that can be used in pipelines using shields.io. Therefore internet access is required')
+    parser.add_argument('-i', '--input', dest='input', help='Path to the TALP JSON file')
+    parser.add_argument('-o', '--output', dest='output',
+                        help='Name of the svg file beeing generated. If not specified [input].svg will be chosen', required=False)
+    
+    # Parsing arguments
+    try:
+        args = parser.parse_args()
+        output_file, input_file = _validate_inputs(args)
+    except Exception as e:
+        logging.error(f"When parsing arguments ecountered the following error: {e}")
+        parser.print_help()
+        exit(1)
+        
+    badge = TalpBadge(input_file)
+    rendered_svg = badge.get_badge_svg()
+    with open(output_file, 'wb') as f:
+        f.write(rendered_svg)
+
+    
+
+
+
+if __name__ == "__main__":
+    main()

talp_pages-3.4.0a1/talp_pages/talp_common.py

@@ -0,0 +1,43 @@
+"""
+File declaring some global scoped variables we rely to be there in our scrips
+"""
+import pathlib
+from jinja2 import Environment, FileSystemLoader
+from dataclasses import dataclass
+
+TALP_TABLE_NAME = "talp_data"
+TALP_DB_COLUMN_TALP_OUPUT = "talp_ouput"
+TALP_DB_COLUMN_TIMESTAMP = "timestamp"
+TALP_DB_COLUMN_METADATA = "metadata"
+TALP_DEFAULT_REGION_NAME = "MPI Execution"
+TALP_POP_METRICS_KEY = 'popMetrics'
+
+TALP_TEMPLATE_PATH = pathlib.Path(__file__).parent.joinpath('templates').resolve()
+TALP_TABLE_COLUMNS_WITH_DATATYPES = f"({TALP_DB_COLUMN_TIMESTAMP} TIMESTAMP, {TALP_DB_COLUMN_TALP_OUPUT} TEXT, {TALP_DB_COLUMN_METADATA} TEXT)"
+TALP_TABLE_COLUMNS = f"({TALP_DB_COLUMN_TIMESTAMP} ,{TALP_DB_COLUMN_TALP_OUPUT}, {TALP_DB_COLUMN_METADATA})"
+
+TALP_PAGES_REPORT_SITE = 'report.html'
+TALP_PAGES_TIME_SERIES_SITE='report_ts.html'
+TALP_PAGES_INDEX_SITE='index.html'
+TALP_PAGES_BAGDE='parallel_effiency.svg'
+
+def render_template(directory, template_name, **context):
+    # Set up Jinja2 environment and load the template
+    env = Environment(loader=FileSystemLoader(directory))
+    template = env.get_template(template_name)
+
+    # Render the template with the provided context
+    return template.render(context)
+
+
+def date_time_to_string(datetime):
+    return datetime.strftime("%d.%m.%Y %H:%M")
+
+
+@dataclass
+class TalpRelativeLinks:
+    """Class to bundle the generated links in the html"""
+    home: str
+    report: str
+    report_ts: str
+    render_navbar: bool = False

talp_pages-3.4.0a1/talp_pages/talp_pages.py

@@ -0,0 +1,106 @@
+#!/usr/bin/env python
+
+import argparse
+import os
+import logging
+
+from .talp_common import TALP_PAGES_INDEX_SITE, TALP_PAGES_REPORT_SITE, TALP_PAGES_TIME_SERIES_SITE, TALP_PAGES_BAGDE, render_template, TALP_TEMPLATE_PATH, TalpRelativeLinks
+from .talp_badge import TalpBadge
+from .talp_report import TalpReport
+from .talp_report_ts import TalpTimeSeriesReport
+
+class TalpIndexPage:
+
+    
+    def get_html(self,links:TalpRelativeLinks):
+        return render_template(
+            TALP_TEMPLATE_PATH,
+            'talp_index_page.jinja',
+            links=vars(links),
+        )
+
+
+
+
+
+
+
+
+
+
+def _verify_input(args):
+    json_file = None
+    db_file = None
+    prefix = None
+
+    # Check if the JSON file exists
+    if not os.path.exists(args.json_input):
+        logging.error(
+            f"The specified JSON file '{args.json_input}' does not exist.")
+        raise Exception("Not existing input file")
+    else:
+        json_file = args.json_input
+
+    # Check if the SQLITE file exists
+    if not os.path.exists(args.db_input):
+        logging.error(
+            f"The specified SQLITE file '{args.db_input}' does not exist.")
+        raise Exception("Not existing input file")
+    else:
+        db_file = args.db_input
+
+
+    prefix = args.prefix
+
+    return json_file,db_file,prefix
+
+def main():
+
+    def _add_prefix(pref,inp)->str:
+        if pref:
+            return pref + "_" + inp
+        else:
+            return inp
+
+    # Creating the main argument parser
+    parser = argparse.ArgumentParser(description='Render the complete static html pages including a index page.' )
+    # Adding argument for JSON file
+    parser.add_argument('-j', '--json', dest='json_input', help='Path to the TALP JSON file')
+    # Adding argument for DB file
+    parser.add_argument('-d', '--db', dest='db_input', help='Path to the TALP.db file')
+    # Adding argument for prefix
+    parser.add_argument('-p', '--prefix', dest='prefix', help=f"Prefix used in front of the (_){TALP_PAGES_REPORT_SITE}, (_){TALP_PAGES_TIME_SERIES_SITE} and (_){TALP_PAGES_INDEX_SITE}", required=False)
+
+    # Parsing arguments
+    try:
+        args = parser.parse_args()
+        json_file,db_file,prefix = _verify_input(args)
+    except Exception as e:
+        logging.error(f"When parsing arguments ecountered the following error: {e}")
+        parser.print_help()
+        exit(1)
+    
+    output_report_ts=_add_prefix(prefix,TALP_PAGES_TIME_SERIES_SITE)
+    output_report=_add_prefix(prefix,TALP_PAGES_REPORT_SITE)
+    badge_file=_add_prefix(prefix,TALP_PAGES_BAGDE)
+    output_index=_add_prefix(prefix,TALP_PAGES_INDEX_SITE)
+    links=TalpRelativeLinks(output_index,output_report,output_report_ts,render_navbar=True)
+    index = TalpIndexPage()
+    report_ts= TalpTimeSeriesReport(db_file)    
+    report = TalpReport(json_file)
+    bagde = TalpBadge(json_file)
+ 
+    with open(output_index, 'w') as f:
+        f.write(index.get_html(links))
+
+    with open(output_report_ts, 'w') as f:
+        f.write(report_ts.get_html(links))
+
+    with open(output_report, 'w') as f:
+        f.write(report.get_html(links))
+    
+    with open(badge_file, 'wb') as f:
+        f.write(bagde.get_badge_svg())
+    
+    
+