# For interactive plots
from bokeh.plotting import figure, show, output_notebook
from bokeh.models import TeX
Loading BokehJS ...

A snapshot of the development on the scikit-learn project.


query_date = np.datetime64("2020-01-01 00:00:00")

# Load data
with open("../devstats-data/scikit-learn_issues.json", "r") as fh:
    issues = [item["node"] for item in json.loads(]

glue("scikit-learn_query_date", str(query_date.astype("M8[D]")))

New issues#

Hide code cell source
newly_created = [
    iss for iss in issues if np.datetime64(iss["createdAt"]) > query_date
new_issues_closed = [iss for iss in newly_created if iss["state"] == "CLOSED"]

new_issue_lifetime = np.array(
        np.datetime64(iss["closedAt"]) - np.datetime64(iss["createdAt"])
        for iss in new_issues_closed
).astype("m8[h]")  # in hours

glue("scikit-learn_num_new_issues", len(newly_created))
glue("scikit-learn_num_new_issues_closed", percent_val(len(new_issues_closed), len(newly_created)))
glue("scikit-learn_new_issue_median_lifetime", f"{np.median(new_issue_lifetime)}")

2169 new issues have been opened since 2020-01-01, of which 1478 (68%) have been closed.

The median lifetime of new issues that were created and closed in this period is 69 hours.

Hide code cell source
title = (
    f"Lifetime of issues created and closed in the last "
    f"{(np.datetime64( - query_date).astype('m8[D]')}"
h, bedges = np.histogram(
    new_issue_lifetime.astype("m8[D]").astype(int), bins=np.arange(30)

p = figure(
    tooltips=[("lifetime", "@right days"), (r"# issues", "@top")],
p.quad(top=h, bottom=0, left=bedges[:-1], right=bedges[1:])
p.xaxis.axis_label = "Issue lifetime (days)"
p.yaxis.axis_label = "# Issues"

Time to response#

Hide code cell source
# Remove issues that are less than a day old for the following analysis
newly_created_day_old = [
    iss for iss in newly_created
    if np.datetime64( - np.datetime64(iss["createdAt"])
    > np.timedelta64(1, "D")

# TODO: really need pandas here
commented_issues = [
    iss for iss in newly_created_day_old
    if any(
        e["node"]["__typename"] == "IssueComment" for e in iss["timelineItems"]["edges"]
first_commenters, time_to_first_comment = [], []
for iss in commented_issues:
    for e in iss["timelineItems"]["edges"]:
        if e["node"]["__typename"] == "IssueComment":
                user = e["node"]["author"]["login"]
            except TypeError as err:
                # This can happen e.g. when a user deletes their GH acct
                user = "UNKNOWN"
            dt = np.datetime64(e["node"]["createdAt"]) - np.datetime64(iss["createdAt"])
            break  # Only want the first commenter
time_to_first_comment = np.array(time_to_first_comment)  # in minutes

median_time_til_first_response = np.median(time_to_first_comment.astype(int) / 60)

cutoffs = [
    np.timedelta64(1, "h"),
    np.timedelta64(12, "h"),
    np.timedelta64(24, "h"),
    np.timedelta64(3, "D"),
    np.timedelta64(7, "D"),
    np.timedelta64(14, "D"),
num_issues_commented_by_cutoff = np.array(
        np.sum(time_to_first_comment < cutoff) for cutoff in cutoffs

# TODO: Update IssueComment query to include:
#  - whether the commenter is a maintainer
#  - datetime of comment
# This will allow analysis of what fraction of issues are addressed by
# maintainers vs. non-maintainer, and the distribution of how long an issue
# usually sits before it's at least commented on

    percent_val(len(commented_issues), len(newly_created_day_old))

glue("scikit-learn_new_issues_at_least_1_day_old", len(newly_created_day_old))
glue("scikit-learn_median_response_time", f"{median_time_til_first_response:1.0f}")

Of the 2169 issues that are at least 24 hours old, 1980 (91%) of them have been commented on. The median time until an issue is first responded to is 6 hours.

Hide code cell source
from bokeh.transform import dodge

title = f"Percentage of issues opened since {query_date} that are commented on within..."

x = [str(c) for c in cutoffs]
y = 100 * num_issues_commented_by_cutoff / len(newly_created_day_old)

p = figure(
    y_range=(0, 100),
    tooltips=[(r"%", "@top")],
p.vbar(x=x, top=y, width=0.8)
p.xaxis.axis_label = "Time interval"
p.yaxis.axis_label = "Percentage of issues commented on within interval"

First responders#

Hide code cell source
first_commenter_tab = pd.DataFrame(
        k: v
        for k, v in zip(
            ("Contributor", "# of times commented first"),
            np.unique(first_commenters, return_counts=True),
    "# of times commented first", ascending=False
Contributor # of times commented first
204 glemaitre 381
78 NicolasHug 200
240 jnothman 186
362 thomasjpfan 155
331 rth 115
304 ogrisel 98
123 adrinjalali 69
169 cmarmo 63
104 TomDLT 51
131 alfaro96 51

Pull Requests#

Hide code cell source
with open("../devstats-data/scikit-learn_prs.json", "r") as fh:
    prs = [item["node"] for item in json.loads(]

### Filters

# Only look at PRs to the main development branch - ignore backports, gh-pages,
# etc.
default_branches = {"main", "master"}  # Account for default branch update
prs = [pr for pr in prs if pr["baseRefName"] in default_branches]

# Drop data where PR author is unknown (e.g. github account no longer exists)
prs = [pr for pr in prs if pr["author"]]  # Failed author query results in None

# Filter out PRs by bots
bot_filter = {"dependabot-preview"}
prs = [pr for pr in prs if pr["author"]["login"] not in bot_filter]

The following filters are applied to the PRs for the following analysis:

  • Only PRs to the default development branch (e.g main)[1] are considered.

  • Only PRs from users with active GitHub accounts are considered. For example, if a user opened a Pull Request in 2016, but then deleted their GitHub account in 2017, then this PR is excluded from the analysis.

  • PRs opened by dependabot are excluded.

Merged PRs over time#

A look at merged PRs over time.

Hide code cell source
# All contributors
merged_prs = [pr for pr in prs if pr['state'] == 'MERGED']
merge_dates = np.array([pr['mergedAt'] for pr in merged_prs], dtype=np.datetime64)
binsize = np.timedelta64(30, "D")
date_bins = np.arange(merge_dates[0], merge_dates[-1], binsize)
h_all, bedges = np.histogram(merge_dates, date_bins)
bcenters = bedges[:-1] + binsize / 2
smoothing_interval = 4  # in units of bin-width

# First-time contributors
first_time_contributor = []
prev_contrib = set()
for record in merged_prs:
        author = record['author']['login']
    except TypeError:  # Author no longer has GitHub account
    if author not in prev_contrib:
# Object dtype for handling None
first_time_contributor = np.array(first_time_contributor, dtype=object)
# Focus on first time contributors
ftc_mask = first_time_contributor == True
ftc_dates = merge_dates[ftc_mask]

h_ftc, bedges = np.histogram(ftc_dates, date_bins)

fig, axes = plt.subplots(1, 2, figsize=(16, 8))
for ax, h, whom in zip(
    axes.ravel(), (h_all, h_ftc), ("all contributors", "first-time contributors")
):, h, width=binsize, label="Raw")
        np.convolve(h, np.ones(smoothing_interval), 'same') / smoothing_interval,
        label=f"{binsize * smoothing_interval} moving average",

fig.suptitle("Merged PRs from:")
axes[0].set_ylabel(f'# Merged PRs / {binsize} interval')

# TODO: Replace this with `glue` once the glue:figure directive supports
# alt-text
import os
os.makedirs("thumbs", exist_ok=True)
plt.savefig("thumbs/scikit-learn.png", bbox_inches="tight")

PR lifetime#

The following plot shows the “survival” of PRs over time. That means, the plot shows how many PRs are open for at least these many days. This is seperated into PRs that are merged and those that are still open (closed but unmerged PRs are not included currently).

Hide code cell source
merged_prs = [pr for pr in prs if pr['state'] == 'MERGED']
lifetimes_merged = np.array(
    [isoparse(pr["mergedAt"]) - isoparse(pr["createdAt"]) for pr in merged_prs],
    dtype="m8[m]").view("int64") / (60 * 24)  # days

#closed_prs = [pr for pr in prs if pr['state'] == 'CLOSED']
#lifetimes_closed = np.array(
#    [isoparse(pr["mergedAt"]) - isoparse(pr["createdAt"]) for pr in closed_prs],
#    dtype="m8[m]").view("int64") / (60 * 24)  # days

# Use the newest issue to guess a time when the data was generated.
# Can this logic be improved?
current_time = isoparse(max(iss["createdAt"] for iss in issues))

open_prs = [pr for pr in prs if pr['state'] == 'OPEN']
age_open = np.array(
    [current_time - isoparse(pr["createdAt"]) for pr in open_prs],
    dtype="m8[m]").view("int64") / (60 * 24)  # days

fig, ax = plt.subplots(figsize=(6, 4))
number_merged = np.arange(1, len(lifetimes_merged)+1)[::-1]
ax.step(lifetimes_merged, number_merged, label="Merged")

#ax.step(lifetimes_closed, np.arange(1, len(lifetimes_closed)+1)[::-1])

number_open = np.arange(1, len(age_open)+1)[::-1]
ax.step(age_open, number_open, label="Open")

# Find the first point where closed have a bigger survival than open PRs:
all_lifetimes = np.concatenate([lifetimes_merged, age_open])

number_merged_all_t = np.interp(all_lifetimes, lifetimes_merged, number_merged)
number_open_all_t = np.interp(all_lifetimes, age_open, number_open)

first_idx = np.argmax(number_merged_all_t < number_open_all_t)
first_time = all_lifetimes[first_idx]

        [first_time], 0, 1, transform=ax.get_xaxis_transform(), colors='k',
        zorder=0, linestyle="--")

    f"{round(first_time)} days",
    xy=(first_time, number_open_all_t[first_idx]),
    xytext=(5, 5), textcoords="offset points",
    va="bottom", ha="left")

ax.set_xlabel("Time until merged or time open [days]")
ax.set_ylabel(r"# of PRs open this long or longer")

Mergeability of Open PRs#

Hide code cell source
open_prs = [pr for pr in prs if pr["state"] == "OPEN"]

# The GraphQL query does not reliably return information on PR mergeability.
# Warn if there are problems
if any([pr["mergeable"] == "UNKNOWN" for pr in open_prs]):
            "\n\nThe data contains PRs with unknown merge status.\n"
            "Please re-download the data to get accurate info about PR mergeability."

conflicting_prs = [isoparse(pr["createdAt"]) for pr in open_prs if pr["mergeable"] == "CONFLICTING"]
mergeable_prs = [isoparse(pr["createdAt"]) for pr in open_prs if pr["mergeable"] == "MERGEABLE"]

fig, ax = plt.subplots(figsize=(6, 4))
    [conflicting_prs, mergeable_prs],
    label=("conflicting", "mergeable"),
    color=("tab:red", "tab:blue"),
ax.set_xlabel("Date of PR creation")
ax.set_ylabel(r"# of conflicting PRs")
/opt/buildhome/python3.8/lib/python3.8/site-packages/IPython/core/ UserWarning: 

The data contains PRs with unknown merge status.
Please re-download the data to get accurate info about PR mergeability.
  exec(code_obj, self.user_global_ns, self.user_ns)

Number of PR participants#

Hide code cell source
# Get the lifetimes and number of participants for merged PRs
lifetimes = np.array(
    [isoparse(pr["mergedAt"]) - isoparse(pr["createdAt"]) for pr in merged_prs],
num_participants = np.array([pr["participants"]["totalCount"] for pr in merged_prs])

title = "Distribution of lifetimes for merged PRs based on the number of participants"

p = figure(width=600, height=300, title=title)
p.xgrid.grid_line_color = None
p.xaxis.ticker = sorted(np.unique(num_participants))
p.yaxis.axis_label = "PR lifetime (hours)"
p.scatter(x=num_participants, y=lifetimes.astype(int), size=9, alpha=0.4)

Where contributions come from#

There have been a total of 8337 merged PRs[2] submitted by 2146 unique authors. 1413 (66%) of these are “fly-by” PRs, i.e. PRs from users who have contributed to the project once (to-date).

Hide code cell source
# Remap PRs by author
contributions_by_author = defaultdict(list)
for pr in merged_prs:
    author = pr["author"]["login"]

num_merged_prs_per_author = np.array(
    [len(prs) for prs in contributions_by_author.values()]

num_flybys = np.sum(num_merged_prs_per_author == 1)

glue("scikit-learn_num_merged_prs_with_known_authors", len(merged_prs))
glue("scikit-learn_num_unique_authors_of_merged_prs", len(contributions_by_author))
glue("scikit-learn_num_flyby", percent_val(num_flybys, len(num_merged_prs_per_author)))
Hide code cell source
title = "Distribution of number of merged PRs per contributor"

x = ["1", "2", "3", "4", "5", "6 - 10", "10 - 20", "20 - 50", "> 50"]
bedges = np.array([0, 1, 2, 3, 4, 5, 10, 20, 50, sum(num_merged_prs_per_author)]) + 0.5
y, _ = np.histogram(num_merged_prs_per_author, bins=bedges)

p = figure(
    y_range=(0, 1.05 * y.max()),
    tooltips=[(r"# PRs merged", "@x"), ("# contributors", f"@top")],
p.vbar(x=x, top=y, width=0.8)
p.xaxis.axis_label = "# Merged PRs per user"
p.yaxis.axis_label = "# of unique contributors with N PRs merged"

Pony factor#

Another way to look at these data is in terms of the pony factor, described as:

The minimum number of contributors whose total contribution constitutes a majority of the contributions.

For this analysis, we will consider merged PRs as the metric for contribution. Considering all merged PRs over the lifetime of the project, the pony factor is: 37.

Hide code cell source
# Sort by number of merged PRs in descending order
num_merged_prs_per_author = num_merged_prs_per_author[::-1]

num_merged_prs = num_merged_prs_per_author.sum()
pf_thresh = 0.5
pony_factor = np.searchsorted(
    np.cumsum(num_merged_prs_per_author), num_merged_prs * pf_thresh
) + 1

fig, ax = plt.subplots()
    np.arange(len(num_merged_prs_per_author)) + 1,
ax.set_title(f"How the pony factor is calculated")
ax.set_xlabel("# unique contributors")
ax.set_ylabel("Cumulative sum of merged PRs / contributor")
    y=num_merged_prs * pf_thresh,
    label=f"Pony factor threshold = {100 * pf_thresh:1.0f}%",

glue("scikit-learn_pony_factor", pony_factor)