https://github.com/ben-manes/gradle-versions-plugin json representation to slack

dependencies_to_slack.py

#!/usr/bin/env python3

import argparse
import json

import slackweb
import pandas


def process_outdated_dependencies(source_json):
    # Flatten release available version
    outdated_dependencies = sorted(
        list(
            map(lambda dep: dep.update({"available": dep["available"]["release"]}) or dep,
                source_json["outdated"]["dependencies"])
        ),
        key=lambda dep: dep["group"]
    )

    aggregated_groups = pandas.DataFrame(outdated_dependencies).groupby(["group", "version", "available"]).agg(
        lambda name: "; ".join(name))

    def glue(dep):
        return f"{dep['group']} : *{dep['name']}* [{dep['version']} -> {dep['available']}]"

    joined = '\n'.join([glue(dep) for dep in aggregated_groups.to_records()])

    return {
        "pretext": "*The following dependencies have later integration versions* :information_source:",
        "text": joined,
        "mrkdwn_in": ["pretext", "text"]}


def process_unresolved_dependencies(source_json):
    unresolved_dependencies = sorted(source_json["unresolved"]["dependencies"], key=lambda dep: dep["group"])

    def glue(dep):
        return f"{dep['group']} : *{dep['name']}* : {dep['version']}"

    joined = '\n'.join([glue(dep) for dep in unresolved_dependencies])

    return {
        "pretext": "*The following dependencies are unavailable at the integration revision level* :exclamation:",
        "text": joined,
        "mrkdwn_in": ["pretext", "text"]}


def process_exceeded_dependencies(source_json):
    exceeded_dependencies = sorted(source_json["exceeded"]["dependencies"], key=lambda dep: dep["group"])

    def glue(dep):
        return f"{dep['group']} : *{dep['name']}* : {dep['version']} (latest available: {dep['available']})"

    joined = '\n'.join([glue(dep) for dep in exceeded_dependencies])

    return {
        "pretext": "*The following dependencies exceed the version found at the integration revision level* :warning:",
        "text": joined,
        "mrkdwn_in": ["pretext", "text"]}


def process_current_dependencies(source_json):
    current_dependencies = sorted(source_json["current"]["dependencies"], key=lambda dep: dep["group"])

    aggregated_groups = pandas.DataFrame(current_dependencies).groupby(["group", "version"]).agg(
        lambda name: "; ".join(name))

    def glue(dep):
        return f"{dep['group']} : *{dep['name']}* : {dep['version']}"

    joined = '\n'.join([glue(dep) for dep in aggregated_groups.to_records()])

    return {
        "pretext": "*The following dependencies are using the latest integration version* :white_check_mark:",
        "text": joined,
        "mrkdwn_in": ["pretext", "text"]}


parser = argparse.ArgumentParser()
parser.add_argument('--webhook-url', required=True, dest="webhook_url")
parser.add_argument('--source-file', required=True, dest="source_file")
args = parser.parse_args()

slack = slackweb.Slack(url=args.webhook_url)

with open(args.source_file) as source_file:
    source = json.load(source_file)

attachments = []

if source["outdated"]["count"] > 0:
    attachments.append(process_outdated_dependencies(source))
else:
    attachments.append({"text": "We're using latest versions of dependencies"})

if source["unresolved"]["count"] > 0:
    attachments.append(process_unresolved_dependencies(source))

if source["exceeded"]["count"] > 0:
    attachments.append(process_exceeded_dependencies(source))

if source["current"]["count"] > 0:
    attachments.append(process_current_dependencies(source))

slack.notify(attachments=attachments)