File size: 2,838 Bytes
f764cdf
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
"""Immutable input and output models for repository analysis."""

from __future__ import annotations

from dataclasses import dataclass, field
from typing import Iterable, Iterator


@dataclass(frozen=True, slots=True)
class RepoFile:
    """A file in one repository snapshot.

    ``content`` may be bytes or text.  Analysis is read-only and never writes
    back to the repository.  Metadata fields are intentionally optional so the
    model can be built directly from The Stack v2 rows.
    """

    path: str
    content: bytes | str
    language: str | None = None
    encoding: str | None = None
    blob_id: str | None = None
    is_vendor: bool | None = None
    is_generated: bool | None = None


@dataclass(frozen=True, slots=True)
class Repo:
    """One immutable repository revision."""

    repo_id: str
    revision_id: str
    files: Iterable[RepoFile]

    def iter_files(self) -> Iterator[RepoFile]:
        return iter(self.files)


@dataclass(frozen=True, slots=True)
class DependencyEdge:
    source: str
    target: str
    kind: str
    confidence: float
    status: str = "resolved"
    evidence: str | None = None


@dataclass(frozen=True, slots=True)
class Diagnostic:
    path: str
    level: str
    message: str
    extractor: str | None = None


@dataclass(frozen=True, slots=True)
class FileInfo:
    path: str
    language: str | None
    bytes: int
    sha1: str | None = None
    references: tuple[str, ...] = ()


@dataclass(frozen=True, slots=True)
class ReferenceInfo:
    source_path: str
    name: str
    kind: str
    status: str
    target_path: str | None = None
    candidates: tuple[str, ...] = ()
    confidence: float = 0.0
    evidence: str | None = None
    resolver_evidence: str | None = None


@dataclass(frozen=True, slots=True)
class ConcatenationNode:
    """One node in the deterministic repository concatenation suggestion tree.

    ``kind`` is ``repo``, ``cycle`` or ``file``. File leaves occur exactly
    once. A depth-first traversal therefore produces a complete, stable,
    dependency-first repository sequence.
    """

    kind: str
    name: str
    order: int
    path: str | None = None
    language: str | None = None
    bytes: int = 0
    depends_on: tuple[str, ...] = ()
    children: tuple["ConcatenationNode", ...] = ()


@dataclass(frozen=True, slots=True)
class RepoInfo:
    """Serializable analysis result for one repository revision."""

    repo_id: str
    revision_id: str
    files: tuple[FileInfo, ...]
    edges: tuple[DependencyEdge, ...]
    topological_order: tuple[str, ...]
    strongly_connected_components: tuple[tuple[str, ...], ...] = ()
    diagnostics: tuple[Diagnostic, ...] = ()
    stats: dict[str, int] = field(default_factory=dict)
    references: tuple[ReferenceInfo, ...] = ()
    concatenation_tree: ConcatenationNode | None = None