I watched 382 Dan John Strength Coach YouTube videos so that you don't have to.

from pathlib import Path
import json
import pandas as pd

frequency_data = (
    pd.read_csv(Path("object_frequencies.csv"))
    .sort_values("rank")
    .reset_index(drop=True)
)
records_dir = Path("v1_1_objects_relations/records")
record_paths = list(records_dir.glob("*.json"))

print(f"Objects: {len(frequency_data):,}")
print(f"Video records: {len(record_paths):,}")

recurring_objects = frequency_data.loc[
    frequency_data["frequency"] > 1
].copy()

normalized_rank = (
    (recurring_objects["rank"] - recurring_objects["rank"].min())
    / (recurring_objects["rank"].max() - recurring_objects["rank"].min())
)
normalized_frequency = (
    (recurring_objects["frequency"] - recurring_objects["frequency"].min())
    / (recurring_objects["frequency"].max() - recurring_objects["frequency"].min())
)

distance_from_endpoint_line = (1 - normalized_rank) - normalized_frequency
knee_index = distance_from_endpoint_line.idxmax()
cutoff_frequency = int(frequency_data.loc[knee_index, "frequency"])
cutoff_rank = int(frequency_data.loc[
    frequency_data["frequency"] >= cutoff_frequency, "rank"
].max())

from collections import Counter, defaultdict

analysis_group = set(
    frequency_data.head(cutoff_rank)["object"].str.strip().str.lower()
)
adjacency = defaultdict(set)
pair_frequency = Counter()

for record_path in records_dir.glob("*.json"):
    record = json.loads(record_path.read_text(encoding="utf-8-sig"))
    labels = {
        item["id"]: item["label"].strip().lower()
        for item in record.get("objects", [])
    }
    for relation in record.get("relations", []):
        subject = labels.get(relation.get("subject"))
        object_ = labels.get(relation.get("object"))
        if subject and object_ and subject != object_:
            pair_frequency[tuple(sorted((subject, object_)))] += 1
            adjacency[subject].add(object_)
            adjacency[object_].add(subject)

first_order = set().union(*(adjacency[item] for item in analysis_group)) - analysis_group
second_order = (
    set().union(*(adjacency[item] for item in first_order))
    - analysis_group - first_order
)

def connected_groups(pair_counts, minimum_frequency):
    graph = defaultdict(set)
    for (left, right), count in pair_counts.items():
        if count >= minimum_frequency:
            graph[left].add(right)
            graph[right].add(left)

    groups, visited = [], set()
    for start in sorted(graph):
        if start in visited:
            continue
        stack, component = [start], set()
        visited.add(start)
        while stack:
            node = stack.pop()
            component.add(node)
            for neighbour in graph[node] - visited:
                visited.add(neighbour)
                stack.append(neighbour)
        groups.append(sorted(component))

    return sorted(groups, key=lambda group: (-len(group), group))

retained_pairs = {
    pair: count for pair, count in pair_frequency.items()
    if count >= 3
}

const filteredEdges = data.edges.filter(
    (edge) =>
        edge.frequency >= minPairFrequency &&
        scopeNodes.has(edge.source) &&
        scopeNodes.has(edge.target)
);

const visible = new Set([selectedId, ...direct, ...second]);

cytoscape({
    container: networkRef.current,
    elements,
    minZoom: 0.04,
    maxZoom: 5,
    style: networkStyles,
    layout: selectedId
        ? { name: "concentric", animate: false }
        : { name: "preset", fit: true, padding: 38 },
});