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
|