1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

import requests
from datetime import datetime, timedelta

def collect_sprint_metrics(jira_url, api_token, board_id):
    """从 Jira 采集迭代度量数据"""

    headers = {"Authorization": f"Bearer {api_token}"}

    # 1. 获取最近的迭代
    sprints_url = f"{jira_url}/rest/agile/1.0/board/{board_id}/sprint?state=closed"
    sprints = requests.get(sprints_url, headers=headers).json()

    metrics = []
    for sprint in sprints.get("values", []):
        # 2. 获取迭代中的 Issue
        issues_url = f"{jira_url}/rest/agile/1.0/sprint/{sprint['id']}/issue"
        issues = requests.get(issues_url, headers=headers).json()

        total_points = 0
        completed_points = 0
        bugs_created = 0
        bugs_resolved = 0

        for issue in issues.get("issues", []):
            fields = issue["fields"]
            points = fields.get("customfield_10016", 0) or 0
            total_points += points

            if fields["status"]["name"] in ["Done", "Closed"]:
                completed_points += points

            if fields["issuetype"]["name"] == "Bug":
                bugs_created += 1
                if fields["status"]["name"] in ["Done", "Closed"]:
                    bugs_resolved += 1

        delivery_rate = completed_points / total_points if total_points > 0 else 0

        # 3. 计算交付周期（从创建到关闭的平均天数）
        lead_times = []
        for issue in issues.get("issues", []):
            created = datetime.fromisoformat(issue["fields"]["created"][:10])
            if issue["fields"]["resolutiondate"]:
                resolved = datetime.fromisoformat(
                    issue["fields"]["resolutiondate"][:10])
                lead_times.append((resolved - created).days)

        avg_lead_time = sum(lead_times) / len(lead_times) if lead_times else 0

        metrics.append({
            "sprint_name": sprint["name"],
            "total_points": total_points,
            "completed_points": completed_points,
            "delivery_rate": round(delivery_rate, 2),
            "bugs_created": bugs_created,
            "bugs_resolved": bugs_resolved,
            "avg_lead_time_days": round(avg_lead_time, 1)
        })

    return metrics

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

import numpy as np

def calculate_baseline(data_points):
    """计算过程基线"""
    mean = np.mean(data_points)
    std = np.std(data_points, ddof=1)  # 样本标准差

    ucl = mean + 3 * std  # 上控制限
    lcl = mean - 3 * std  # 下控制限

    return {
        "mean": round(mean, 2),
        "std": round(std, 2),
        "ucl": round(ucl, 2),  # Upper Control Limit
        "lcl": round(lcl, 2),  # Lower Control Limit
        "normal_range": f"{round(mean - 2*std, 2)} ~ {round(mean + 2*std, 2)}",
        "sample_size": len(data_points)
    }

# 示例：过去 20 个迭代的交付率
delivery_rates = [78, 85, 82, 79, 88, 81, 76, 84, 80, 83,
                  86, 77, 82, 85, 81, 79, 84, 80, 83, 82]

baseline = calculate_baseline(delivery_rates)
print(baseline)
# {'mean': 81.75, 'std': 3.18, 'ucl': 91.29, 'lcl': 72.21,
#  'normal_range': '75.39 ~ 88.11', 'sample_size': 20}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

import matplotlib.pyplot as plt

def plot_control_chart(data, baseline, title="交付率控制图"):
    """绘制控制图"""
    fig, ax = plt.subplots(figsize=(12, 6))

    x = range(1, len(data) + 1)
    ax.plot(x, data, 'bo-', markersize=6, label='实际值')
    ax.axhline(y=baseline['mean'], color='green', linestyle='-',
               label=f"均值 ({baseline['mean']})")
    ax.axhline(y=baseline['ucl'], color='red', linestyle='--',
               label=f"UCL ({baseline['ucl']})")
    ax.axhline(y=baseline['lcl'], color='red', linestyle='--',
               label=f"LCL ({baseline['lcl']})")

    # 标记异常点
    for i, v in enumerate(data):
        if v > baseline['ucl'] or v < baseline['lcl']:
            ax.plot(i + 1, v, 'ro', markersize=10)

    ax.set_xlabel('迭代')
    ax.set_ylabel('交付率 (%)')
    ax.set_title(title)
    ax.legend()
    plt.tight_layout()
    plt.savefig('control_chart.png', dpi=150)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

from sklearn.linear_model import LinearRegression
import numpy as np

# 历史数据
X = np.array([
    # [故事点, 变更率, 评审覆盖率, 测试覆盖率, 团队经验月数]
    [21, 0.15, 0.80, 0.65, 18],
    [34, 0.25, 0.70, 0.55, 15],
    [18, 0.10, 0.90, 0.75, 24],
    [28, 0.30, 0.60, 0.50, 12],
    [25, 0.12, 0.85, 0.70, 20],
    # ... 更多数据
])

# 交付周期（天）
y = np.array([10, 18, 8, 22, 11])

model = LinearRegression()
model.fit(X, y)

# 预测：下一个迭代的情况
next_sprint = [[26, 0.20, 0.75, 0.60, 16]]
predicted_lead_time = model.predict(next_sprint)
print(f"预测交付周期: {predicted_lead_time[0]:.1f} 天")
# 预测交付周期: 14.2 天