openlark 0.16.0

飞书开放平台 Rust SDK - 企业级高覆盖率 API 客户端，极简依赖一条命令
Documentation 
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
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

"""Shared data models for API contract validation."""

from __future__ import annotations

from dataclasses import asdict, dataclass, field
from typing import Any


@dataclass(frozen=True)
class ApiIdentity:
    api_id: str
    name: str
    biz_tag: str
    meta_project: str
    meta_version: str
    meta_resource: str
    meta_name: str
    url: str
    doc_path: str
    expected_file: str
    full_path: str = ""

    @property
    def official_method(self) -> str:
        method, _, _ = self.url.partition(":")
        return method.upper()

    @property
    def official_path(self) -> str:
        _, _, path = self.url.partition(":")
        return path


@dataclass(frozen=True)
class RustEndpointCall:
    method: str
    argument: str
    line: int
    resolved_path: str = ""
    source: str = ""
    unresolved_reason: str = ""

    @property
    def is_resolved(self) -> bool:
        return bool(self.resolved_path)


@dataclass(frozen=True)
class RustApiContract:
    rel_path: str
    endpoint_calls: tuple[RustEndpointCall, ...] = ()
    fields: tuple["RustField", ...] = ()
    response_fields: tuple["RustField", ...] = ()


@dataclass(frozen=True)
class OfficialField:
    name: str
    required: bool
    location: str
    field_type: str = ""
    source: str = ""


@dataclass(frozen=True)
class RustField:
    struct_name: str
    field_name: str
    serialized_name: str
    type_name: str
    optional: bool
    line: int


@dataclass(frozen=True)
class ContractFinding:
    severity: str
    code: str
    message: str
    api_id: str
    api_name: str
    expected_file: str
    doc_path: str
    rust_line: int = 0
    official: str = ""
    rust: str = ""

    def sort_key(self) -> tuple[int, str, str, int, str]:
        severity_rank = {"ERROR": 0, "WARN": 1, "INFO": 2, "UNVERIFIED": 3}
        return (
            severity_rank.get(self.severity, 9),
            self.expected_file,
            self.code,
            self.rust_line,
            self.api_id,
        )


@dataclass
class ContractReport:
    crate_name: str
    total_apis: int = 0
    checked_apis: int = 0
    findings: list[ContractFinding] = field(default_factory=list)

    def add(self, finding: ContractFinding) -> None:
        self.findings.append(finding)

    @property
    def error_count(self) -> int:
        return sum(1 for finding in self.findings if finding.severity == "ERROR")

    @property
    def warn_count(self) -> int:
        return sum(1 for finding in self.findings if finding.severity == "WARN")

    @property
    def unresolved_count(self) -> int:
        return sum(1 for finding in self.findings if finding.severity == "UNVERIFIED")

    def to_jsonable(self) -> dict[str, Any]:
        return {
            "crate": self.crate_name,
            "total_apis": self.total_apis,
            "checked_apis": self.checked_apis,
            "error_count": self.error_count,
            "warn_count": self.warn_count,
            "unresolved_count": self.unresolved_count,
            "findings": [
                asdict(finding)
                for finding in sorted(self.findings, key=lambda item: item.sort_key())
            ],
        }