sqlbuild 0.115.0__tar.gz → 0.116.0__tar.gz

{sqlbuild-0.115.0 → sqlbuild-0.116.0}/Cargo.lock

@@ -592,7 +592,7 @@ checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"
 
 [[package]]
 name = "sqlbuild-rules-native"
-version = "0.115.0"
+version = "0.116.0"
 dependencies = [
  "fensu-policy",
  "globset",

{sqlbuild-0.115.0 → sqlbuild-0.116.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlbuild
-Version: 0.115.0
+Version: 0.116.0
 Requires-Dist: duckdb>=1.3.2
 Requires-Dist: filelock>=3.20.3
 Requires-Dist: orjson>=3.10.0

{sqlbuild-0.115.0 → sqlbuild-0.116.0}/crates/sqlbuild-rules-native/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sqlbuild-rules-native"
-version = "0.115.0"
+version = "0.116.0"
 edition.workspace = true
 license.workspace = true
 publish.workspace = true

{sqlbuild-0.115.0 → sqlbuild-0.116.0}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "maturin"
 
 [project]
 name = "sqlbuild"
-version = "0.115.0"
+version = "0.116.0"
 description = "Typed, test-first SQL pipelines with local E2E testing"
 readme = "README.md"
 requires-python = ">=3.12"

{sqlbuild-0.115.0 → sqlbuild-0.116.0}/scripts/dupscore/_helpers/clones/clustering.py

@@ -19,11 +19,12 @@ def cluster_clone_pairs(
     units: list[CloneUnit],
     pairs: list[ClonePair],
     change_of: Callable[[CloneUnit], str | None],
+    forced: frozenset[int],
 ) -> list[CloneCluster]:
     """Group pairs into connected components ordered by estimated duplicated tokens."""
 
     clusters: list[CloneCluster] = [
-        _build_cluster(units=units, pairs=component, change_of=change_of)
+        _build_cluster(units=units, pairs=component, change_of=change_of, forced=forced)
         for component in _connected_pair_groups(pairs)
     ]
     return sorted(clusters, key=_cluster_sort_key)
@@ -63,10 +64,16 @@ def _build_cluster(
     units: list[CloneUnit],
     pairs: list[ClonePair],
     change_of: Callable[[CloneUnit], str | None],
+    forced: frozenset[int],
 ) -> CloneCluster:
     unit_indexes: list[int] = sorted(
         _unit_indexes(pairs),
-        key=lambda index: (units[index].path, units[index].start_line, units[index].name),
+        key=lambda index: (
+            index in forced,
+            units[index].path,
+            units[index].start_line,
+            units[index].name,
+        ),
     )
     position: dict[int, int] = {unit_index: slot for slot, unit_index in enumerate(unit_indexes)}
     best_similarity: dict[int, float] = {}
@@ -76,6 +83,7 @@ def _build_cluster(
     weights: list[float] = [
         len(units[unit_index].normalized) * best_similarity[unit_index]
         for unit_index in unit_indexes
+        if unit_index not in forced
     ]
     links: list[ClonePairLink] = sorted(
         (
@@ -102,6 +110,7 @@ def _build_cluster(
             end_line=units[unit_index].end_line,
             tokens=len(units[unit_index].normalized),
             change=change_of(units[unit_index]),
+            forced_override=unit_index in forced,
         )
         for unit_index in unit_indexes
     )
@@ -109,12 +118,22 @@ def _build_cluster(
         category=category,
         similarity_min=min(similarities),
         similarity_max=max(similarities),
-        duplicated_tokens=round(sum(weights) - max(weights)),
+        duplicated_tokens=_duplicated_tokens(
+            weights=weights, has_forced=len(weights) < len(members)
+        ),
         members=members,
         links=tuple(links),
     )
 
 
+def _duplicated_tokens(*, weights: list[float], has_forced: bool) -> int:
+    """Estimate removable tokens: keep one copy, or a required forced override when present."""
+
+    if has_forced:
+        return round(sum(weights))
+    return round(sum(weights) - max(weights))
+
+
 def _cluster_sort_key(cluster: CloneCluster) -> tuple[int, float, str, int]:
     first: CloneMember = cluster.members[0]
     return (-cluster.duplicated_tokens, -cluster.similarity_max, first.path, first.start_line)

{sqlbuild-0.115.0 → sqlbuild-0.116.0}/scripts/dupscore/_helpers/clones/matching.py

@@ -13,6 +13,8 @@ from scripts.dupscore.constants import (
     CLONE_CANDIDATE_MIN_JACCARD,
     CLONE_MAX_FINGERPRINT_UNITS,
     CLONE_MIN_FINGERPRINTS,
+    CLONE_SMALL_NEAR_MISS_MIN_SIMILARITY,
+    CLONE_SMALL_NEAR_MISS_TOKENS,
 )
 from scripts.dupscore.models import ClonePair, CloneUnit
 
@@ -63,12 +65,16 @@ def find_clone_pairs(
             continue
         if shared / (left_size + right_size - shared) < CLONE_CANDIDATE_MIN_JACCARD:
             continue
+        required: float = _required_similarity(
+            smaller=min(len(units[left].normalized), len(units[right].normalized)),
+            min_similarity=min_similarity,
+        )
         similarity: float = _stream_similarity(
             left=units[left].normalized,
             right=units[right].normalized,
-            min_similarity=min_similarity,
+            min_similarity=required,
         )
-        if similarity >= min_similarity:
+        if similarity >= required:
             pairs[(left, right)] = ClonePair(
                 left=left,
                 right=right,
@@ -78,6 +84,14 @@ def find_clone_pairs(
     return [pairs[key] for key in sorted(pairs)]
 
 
+def _required_similarity(*, smaller: int, min_similarity: float) -> float:
+    """Demand closer matches from short units, whose shared skeletons are mostly idioms."""
+
+    if smaller < CLONE_SMALL_NEAR_MISS_TOKENS:
+        return max(min_similarity, CLONE_SMALL_NEAR_MISS_MIN_SIMILARITY)
+    return min_similarity
+
+
 def _stream_similarity(
     *,
     left: tuple[str, ...],

{sqlbuild-0.115.0 → sqlbuild-0.116.0}/scripts/dupscore/_helpers/clones/python_units.py

@@ -74,7 +74,12 @@ def extract_python_units(*, relative_path: str, source: str) -> tuple[CloneUnit,
     except (SyntaxError, tokenize.TokenError):
         return ()
     starts: list[_Position] = [item.start for item in tokens]
-    normalized: list[str | None] = [_normalize(item) for item in tokens]
+    call_targets: frozenset[_Position] = _call_target_positions(
+        tree=tree, lines=io.StringIO(source).readlines()
+    )
+    normalized: list[str | None] = [
+        _normalize(item=item, call_target=item.start in call_targets) for item in tokens
+    ]
     for span in _ignored_spans(tree.body):
         end: int = bisect_left(starts, span.end)
         if span.statement and end < len(tokens) and tokens[end].type == tokenize.NEWLINE:
@@ -107,9 +112,11 @@ def extract_python_units(*, relative_path: str, source: str) -> tuple[CloneUnit,
     return tuple(units)
 
 
-def _normalize(item: tokenize.TokenInfo) -> str | None:
+def _normalize(*, item: tokenize.TokenInfo, call_target: bool) -> str | None:
     if item.type == tokenize.NAME:
-        return item.string if item.string in _KEYWORDS else PLACEHOLDER_IDENTIFIER
+        if call_target or item.string in _KEYWORDS:
+            return item.string
+        return PLACEHOLDER_IDENTIFIER
     if item.type == tokenize.OP:
         return None if item.string == _RETURN_ARROW else item.string
     if item.type in _FSTRING_BODY_TYPES:
@@ -122,6 +129,39 @@ def _normalize(item: tokenize.TokenInfo) -> str | None:
     return _LITERAL_PLACEHOLDERS.get(item.type, item.string)
 
 
+def _call_target_positions(*, tree: ast.Module, lines: list[str]) -> frozenset[_Position]:
+    """Locate the name tokens of called functions (``f(...)``) and methods (``x.f(...)``)."""
+
+    positions: set[_Position] = set()
+    for node in ast.walk(tree):
+        if not isinstance(node, ast.Call):
+            continue
+        function: ast.expr = node.func
+        if isinstance(function, ast.Name):
+            positions.add(
+                _token_position(lines=lines, line=function.lineno, byte_column=function.col_offset)
+            )
+        elif (
+            isinstance(function, ast.Attribute)
+            and function.end_lineno is not None
+            and function.end_col_offset is not None
+        ):
+            end: _Position = _token_position(
+                lines=lines, line=function.end_lineno, byte_column=function.end_col_offset
+            )
+            positions.add((end[0], end[1] - len(function.attr)))
+    return frozenset(positions)
+
+
+def _token_position(*, lines: list[str], line: int, byte_column: int) -> _Position:
+    """Convert an ``ast`` UTF-8 byte column into the character column ``tokenize`` reports."""
+
+    text: str = lines[line - 1] if 0 < line <= len(lines) else ""
+    if text.isascii():
+        return (line, byte_column)
+    return (line, len(text.encode("utf-8")[:byte_column].decode("utf-8", errors="replace")))
+
+
 def _collect_unit_nodes(*, body: list[ast.stmt], prefix: str) -> list[_UnitNode]:
     collected: list[_UnitNode] = []
     for statement in body:

{sqlbuild-0.115.0 → sqlbuild-0.116.0}/scripts/dupscore/_helpers/clones/rendering.py

@@ -9,6 +9,7 @@ from scripts.dupscore.constants import CLONE_TEXT_MAX_MEMBERS
 from scripts.dupscore.models import CloneCluster, CloneMember, CloneReport
 
 _INDENT: str = "     "
+_FORCED_MARKER: str = " [forced]"
 
 
 def render_clone_text(*, report: CloneReport, top: int) -> str:
@@ -20,7 +21,8 @@ def render_clone_text(*, report: CloneReport, top: int) -> str:
     scope: str = f" changed since {report.since}" if report.since is not None else ""
     lines: list[str] = [
         f"dupscore clones{scope}: {len(report.clusters)} clusters "
-        f"({counts}; {report.allowlisted_pairs} allowlisted pairs hidden)"
+        f"({counts}; {report.allowlisted_pairs} allowlisted pairs hidden; "
+        f"{report.contract_exempt_members} contract-exempt members hidden)"
     ]
     for position, cluster in enumerate(report.clusters[:top], start=1):
         lines.append(f"{position:3d}. {_cluster_heading(cluster)}")
@@ -43,6 +45,7 @@ def render_clone_json(*, report: CloneReport, top: int) -> str:
         "since": report.since,
         "unit_counts": report.unit_counts,
         "allowlisted_pairs": report.allowlisted_pairs,
+        "contract_exempt_members": report.contract_exempt_members,
         "total_clusters": len(report.clusters),
         "clusters": [
             {"rank": position, **asdict(cluster)}
@@ -64,7 +67,8 @@ def _cluster_heading(cluster: CloneCluster) -> str:
 
 def _member_line(member: CloneMember) -> str:
     change: str = f" [{member.change}]" if member.change is not None else ""
+    forced: str = _FORCED_MARKER if member.forced_override else ""
     return (
         f"{member.path}:{member.start_line}-{member.end_line} {member.name} "
-        f"({member.tokens} tokens){change}"
+        f"({member.tokens} tokens){forced}{change}"
     )

{sqlbuild-0.115.0 → sqlbuild-0.116.0}/scripts/dupscore/_helpers/clones/rust_units.py

@@ -100,6 +100,7 @@ _PATH_SEPARATOR: str = "::"
 _RUST_SUFFIX: str = ".rs"
 _DIRECTORY_SUFFIX: str = "/"
 _OWNER_SEPARATOR: str = "::"
+_CALL_SUFFIXES: frozenset[str] = frozenset({"(", "!"})
 
 
 def extract_rust_units(
@@ -123,10 +124,27 @@ def extract_rust_units(
     )
 
 
-def _normalize(item: RustToken) -> str:
-    if item.kind == RUST_KIND_IDENTIFIER:
-        return item.text if item.text in _RUST_KEYWORDS else PLACEHOLDER_IDENTIFIER
-    return _LITERAL_PLACEHOLDERS.get(item.kind, item.text)
+def _normalize_stream(tokens: list[RustToken]) -> list[str]:
+    normalized: list[str] = []
+    for index, item in enumerate(tokens):
+        if item.kind == RUST_KIND_IDENTIFIER:
+            keep: bool = item.text in _RUST_KEYWORDS or _is_call_target(tokens=tokens, index=index)
+            normalized.append(item.text if keep else PLACEHOLDER_IDENTIFIER)
+        else:
+            normalized.append(_LITERAL_PLACEHOLDERS.get(item.kind, item.text))
+    return normalized
+
+
+def _is_call_target(*, tokens: list[RustToken], index: int) -> bool:
+    """Name a called function, method, or macro: an identifier directly before ``(`` or ``!``."""
+
+    following: int = index + 1
+    if following >= len(tokens):
+        return False
+    after: RustToken = tokens[following]
+    if after.kind != RUST_KIND_PUNCTUATION or after.text not in _CALL_SUFFIXES:
+        return False
+    return index == 0 or tokens[index - 1].text != _FUNCTION_KEYWORD
 
 
 def _match_brackets(tokens: list[RustToken]) -> list[int]:
@@ -341,7 +359,7 @@ class _ItemScanner:
                 name=f"{owner}{_OWNER_SEPARATOR}{function_name}" if owner else function_name,
                 start_line=self._tokens[item_start].line,
                 end_line=self._tokens[close].line,
-                normalized=[_normalize(item) for item in body],
+                normalized=_normalize_stream(body),
                 concrete=[item.text for item in body],
             )
         )

sqlbuild-0.116.0/scripts/dupscore/_helpers/contracts/__init__.py

@@ -0,0 +1 @@
+"""Dupscore clones helpers."""

sqlbuild-0.116.0/scripts/dupscore/_helpers/contracts/forced_overrides.py

@@ -0,0 +1,290 @@
+"""Recognise forced overrides of contract methods, derived statically from the analysed source."""
+
+from __future__ import annotations
+
+import ast
+from dataclasses import dataclass
+from pathlib import Path, PurePosixPath
+
+from scripts.dupscore._helpers.clones.filters import path_matches_any
+from scripts.dupscore.constants import LANGUAGE_PYTHON, SOURCE_ROOT
+from scripts.dupscore.exceptions import DupscoreConfigError
+from scripts.dupscore.models import CloneUnit, ContractExemptionEntry
+
+_ABSTRACT_DECORATOR: str = "abstractmethod"
+_MODULE_SEPARATOR: str = "."
+_PYTHON_SUFFIX: str = ".py"
+_PACKAGE_INIT: str = "__init__.py"
+_METHOD_NAME_PARTS: int = 2
+
+type _FunctionNode = ast.FunctionDef | ast.AsyncFunctionDef
+type _ClassKey = tuple[str, str]
+
+
+@dataclass(frozen=True, slots=True)
+class _ClassInfo:
+    bases: tuple[_ClassKey, ...]
+    concrete: frozenset[str]
+    abstract: frozenset[str]
+    complete: bool
+
+
+@dataclass(frozen=True, slots=True)
+class _ContractScope:
+    contract: _ClassKey
+    method_names: frozenset[str]
+    forbidden_owners: frozenset[_ClassKey]
+    paths: tuple[str, ...]
+
+
+def find_forced_overrides(
+    *,
+    repo_root: Path,
+    entries: tuple[ContractExemptionEntry, ...],
+    units: list[CloneUnit],
+) -> tuple[bool, ...]:
+    """Flag each unit that overrides a contract method it may not inherit from an ancestor."""
+
+    exemptions: _ContractExemptions = _ContractExemptions(repo_root=repo_root, entries=entries)
+    return tuple(exemptions.is_forced(unit) for unit in units)
+
+
+class _ContractExemptions:
+    def __init__(self, *, repo_root: Path, entries: tuple[ContractExemptionEntry, ...]) -> None:
+        self._resolver: _ClassResolver = _ClassResolver(repo_root=repo_root)
+        active: list[ContractExemptionEntry] = [
+            entry for entry in entries if (repo_root / entry.contract_path).is_file()
+        ]
+        self._scopes: tuple[_ContractScope, ...] = tuple(self._scope(entry) for entry in active)
+
+    def is_forced(self, unit: CloneUnit) -> bool:
+        """Require a top-level class method under the paths that derives from the contract."""
+
+        if unit.language != LANGUAGE_PYTHON:
+            return False
+        parts: list[str] = unit.name.split(_MODULE_SEPARATOR)
+        if len(parts) != _METHOD_NAME_PARTS:
+            return False
+        class_name, method_name = parts
+        for scope in self._scopes:
+            if method_name not in scope.method_names:
+                continue
+            if not path_matches_any(path=unit.path, globs=scope.paths):
+                continue
+            if self._forced_in_scope(
+                scope=scope, key=(unit.path, class_name), method_name=method_name
+            ):
+                return True
+        return False
+
+    def _forced_in_scope(self, *, scope: _ContractScope, key: _ClassKey, method_name: str) -> bool:
+        order: tuple[_ClassKey, ...] = self._resolver.method_resolution_order(key)
+        if scope.contract not in order:
+            return False
+        if not all(self._resolver.info(ancestor).complete for ancestor in order):
+            return False
+        for ancestor in order[1:]:
+            if method_name in self._resolver.info(ancestor).concrete:
+                return ancestor in scope.forbidden_owners
+        return True
+
+    def _scope(self, entry: ContractExemptionEntry) -> _ContractScope:
+        contract: _ClassKey = (entry.contract_path, entry.contract_class)
+        forbidden: set[_ClassKey] = {contract}
+        for key in (contract, *entry.forbidden_owners):
+            if not self._resolver.exists(key):
+                raise DupscoreConfigError(
+                    f"contract_exemption class {key[0]}:{key[1]} was not found in the analysed "
+                    "source"
+                )
+            forbidden.add(key)
+        return _ContractScope(
+            contract=contract,
+            method_names=self._resolver.abstract_methods(contract),
+            forbidden_owners=frozenset(forbidden),
+            paths=entry.paths,
+        )
+
+
+class _ClassResolver:
+    def __init__(self, *, repo_root: Path) -> None:
+        self._repo_root: Path = repo_root
+        self._trees: dict[str, ast.Module | None] = {}
+        self._infos: dict[_ClassKey, _ClassInfo] = {}
+        self._orders: dict[_ClassKey, tuple[_ClassKey, ...]] = {}
+        self._abstract: dict[_ClassKey, frozenset[str]] = {}
+
+    def exists(self, key: _ClassKey) -> bool:
+        tree: ast.Module | None = self._parse(key[0])
+        return tree is not None and _find_class(tree=tree, name=key[1]) is not None
+
+    def info(self, key: _ClassKey) -> _ClassInfo:
+        if key not in self._infos:
+            self._infos[key] = self._build_info(key)
+        return self._infos[key]
+
+    def abstract_methods(self, key: _ClassKey) -> frozenset[str]:
+        """Mirror ``__abstractmethods__``: own abstract methods plus unoverridden inherited ones."""
+
+        if key in self._abstract:
+            return self._abstract[key]
+        self._abstract[key] = frozenset()
+        info: _ClassInfo = self.info(key)
+        names: set[str] = set(info.abstract)
+        for base in info.bases:
+            names.update(self.abstract_methods(base) - info.concrete)
+        self._abstract[key] = frozenset(names)
+        return self._abstract[key]
+
+    def method_resolution_order(self, key: _ClassKey) -> tuple[_ClassKey, ...]:
+        """C3-linearise the statically resolvable bases, as ``type.__mro__`` would."""
+
+        if key in self._orders:
+            return self._orders[key]
+        self._orders[key] = (key,)
+        bases: tuple[_ClassKey, ...] = self.info(key).bases
+        sequences: list[list[_ClassKey]] = [
+            list(self.method_resolution_order(base)) for base in bases
+        ]
+        self._orders[key] = (key, *_c3_merge([*sequences, list(bases)]))
+        return self._orders[key]
+
+    def _parse(self, relative_path: str) -> ast.Module | None:
+        if relative_path not in self._trees:
+            try:
+                source: str = (self._repo_root / relative_path).read_text(encoding="utf-8")
+                self._trees[relative_path] = ast.parse(source)
+            except (OSError, SyntaxError, UnicodeDecodeError, ValueError):
+                self._trees[relative_path] = None
+        return self._trees[relative_path]
+
+    def _build_info(self, key: _ClassKey) -> _ClassInfo:
+        tree: ast.Module | None = self._parse(key[0])
+        node: ast.ClassDef | None = None if tree is None else _find_class(tree=tree, name=key[1])
+        if tree is None or node is None:
+            return _ClassInfo(bases=(), concrete=frozenset(), abstract=frozenset(), complete=False)
+        functions: list[_FunctionNode] = [
+            item for item in node.body if isinstance(item, (ast.FunctionDef, ast.AsyncFunctionDef))
+        ]
+        bases: list[_ClassKey] = []
+        complete: bool = True
+        for base in node.bases:
+            resolved: _ClassKey | None = self._resolve_base(tree=tree, importer=key[0], base=base)
+            if resolved is not None:
+                bases.append(resolved)
+            elif self._references_local_module(tree=tree, importer=key[0], base=base):
+                complete = False
+        return _ClassInfo(
+            bases=tuple(bases),
+            concrete=frozenset(item.name for item in functions if not _is_abstract(item)),
+            abstract=frozenset(item.name for item in functions if _is_abstract(item)),
+            complete=complete,
+        )
+
+    def _references_local_module(self, *, tree: ast.Module, importer: str, base: ast.expr) -> bool:
+        """Report bases that name this repository but could not be resolved to a class."""
+
+        root: ast.expr = base.value if isinstance(base, ast.Subscript) else base
+        while isinstance(root, ast.Attribute):
+            root = root.value
+        if not isinstance(root, ast.Name):
+            return True
+        if _find_class(tree=tree, name=root.id) is not None:
+            return True
+        for statement in tree.body:
+            if isinstance(statement, ast.ImportFrom):
+                for alias in statement.names:
+                    if (alias.asname or alias.name) == root.id:
+                        return (
+                            self._module_path(
+                                importer=importer, module=statement.module, level=statement.level
+                            )
+                            is not None
+                            or statement.level > 0
+                        )
+            elif isinstance(statement, ast.Import):
+                for alias in statement.names:
+                    if (alias.asname or alias.name.split(_MODULE_SEPARATOR)[0]) == root.id:
+                        return (
+                            self._module_path(importer=importer, module=alias.name, level=0)
+                            is not None
+                        )
+        return False
+
+    def _resolve_base(self, *, tree: ast.Module, importer: str, base: ast.expr) -> _ClassKey | None:
+        if isinstance(base, ast.Subscript):
+            base = base.value
+        if not isinstance(base, ast.Name):
+            return None
+        if _find_class(tree=tree, name=base.id) is not None:
+            return (importer, base.id)
+        for statement in tree.body:
+            if not isinstance(statement, ast.ImportFrom):
+                continue
+            for alias in statement.names:
+                if (alias.asname or alias.name) == base.id:
+                    module_path: str | None = self._module_path(
+                        importer=importer, module=statement.module, level=statement.level
+                    )
+                    return None if module_path is None else (module_path, alias.name)
+        return None
+
+    def _module_path(self, *, importer: str, module: str | None, level: int) -> str | None:
+        if not module:
+            return None
+        parts: list[str] = module.split(_MODULE_SEPARATOR)
+        if level:
+            anchor: PurePosixPath = PurePosixPath(importer).parent
+            for _ in range(level - 1):
+                anchor = anchor.parent
+            bases: list[PurePosixPath] = [anchor.joinpath(*parts)]
+        else:
+            bases = [PurePosixPath(SOURCE_ROOT).joinpath(*parts), PurePosixPath(*parts)]
+        for base in bases:
+            for candidate in (base.with_name(base.name + _PYTHON_SUFFIX), base / _PACKAGE_INIT):
+                if (self._repo_root / candidate).is_file():
+                    return candidate.as_posix()
+        return None
+
+
+def _c3_merge(sequences: list[list[_ClassKey]]) -> list[_ClassKey]:
+    """Merge linearisations; an inconsistent hierarchy falls back to first-seen order."""
+
+    merged: list[_ClassKey] = []
+    pending: list[list[_ClassKey]] = [sequence for sequence in sequences if sequence]
+    while pending:
+        head: _ClassKey = _c3_head(pending)
+        merged.append(head)
+        remaining: list[list[_ClassKey]] = []
+        for sequence in pending:
+            rest: list[_ClassKey] = [item for item in sequence if item != head]
+            if rest:
+                remaining.append(rest)
+        pending = remaining
+    return merged
+
+
+def _c3_head(pending: list[list[_ClassKey]]) -> _ClassKey:
+    tails: set[_ClassKey] = set()
+    for sequence in pending:
+        tails.update(sequence[1:])
+    for sequence in pending:
+        if sequence[0] not in tails:
+            return sequence[0]
+    return pending[0][0]
+
+
+def _find_class(*, tree: ast.Module, name: str) -> ast.ClassDef | None:
+    for statement in tree.body:
+        if isinstance(statement, ast.ClassDef) and statement.name == name:
+            return statement
+    return None
+
+
+def _is_abstract(function: _FunctionNode) -> bool:
+    for decorator in function.decorator_list:
+        if isinstance(decorator, ast.Name) and decorator.id == _ABSTRACT_DECORATOR:
+            return True
+        if isinstance(decorator, ast.Attribute) and decorator.attr == _ABSTRACT_DECORATOR:
+            return True
+    return False