{"repo_id":"TOLBERT","entity_id":"py:tests.test_modeling","uri":"program://TOLBERT/module/tests.test_modeling#L1-L166","kind":"module","name":"tests.test_modeling","path":"tests/test_modeling.py","language":"python","start_line":1,"end_line":166,"context_start_line":1,"context_end_line":166,"code":"import types\nfrom pathlib import Path\nimport sys\n\nimport torch\n\n# Ensure project root is on sys.path so `tolbert` imports resolve consistently,\n# even when tests are run from outside the repository root.\nPROJECT_ROOT = Path(__file__).resolve().parents[1]\nif str(PROJECT_ROOT) not in sys.path:\n    sys.path.insert(0, str(PROJECT_ROOT))\n\nfrom tolbert import modeling\n\n\nclass _DummyEncoder(torch.nn.Module):\n    \"\"\"\n    Tiny stand-in for a HuggingFace AutoModel encoder.\n\n    It exposes:\n      - .config.hidden_size\n      - .config.vocab_size\n      - .forward(...).last_hidden_state\n    so that TOLBERT can be instantiated without downloading a real model.\n    \"\"\"\n\n    def __init__(self, hidden_size: int = 16, vocab_size: int = 32) -> None:\n        super().__init__()\n        self.config = types.SimpleNamespace(hidden_size=hidden_size, vocab_size=vocab_size)\n\n    def forward(self, input_ids=None, attention_mask=None):\n        batch, seq_len = input_ids.shape\n        # Simple deterministic hidden states for reproducibility across runs.\n        hidden = torch.arange(batch * seq_len * self.config.hidden_size, dtype=torch.float32)\n        hidden = hidden.view(batch, seq_len, self.config.hidden_size)\n        return types.SimpleNamespace(last_hidden_state=hidden)\n\n\nclass _DummyAutoModel:\n    @classmethod\n    def from_pretrained(cls, *args, **kwargs):\n        return _DummyEncoder()\n\n\ndef _patch_auto_model():\n    \"\"\"\n    Replace modeling.AutoModel with a cheap local encoder for tests.\n    \"\"\"\n    modeling.AutoModel = _DummyAutoModel  # type: ignore[assignment]\n\n\ndef test_tolbert_forward_shapes_and_losses():\n    \"\"\"\n    Basic sanity check:\n      - TOLBERT can be instantiated with a dummy encoder.\n      - Forward pass returns all expected keys.\n      - Loss and individual loss components are present.\n    \"\"\"\n    _patch_auto_model()\n\n    cfg = modeling.TOLBERTConfig(\n        base_model_name=\"dummy\",\n        level_sizes={1: 3, 2: 4},\n        proj_dim=8,\n        lambda_hier=1.0,\n        lambda_path=0.5,\n    )\n    model = modeling.TOLBERT(cfg)\n\n    batch_size, seq_len = 2, 5\n    input_ids = torch.ones(batch_size, seq_len, dtype=torch.long)\n    attention_mask = torch.ones_like(input_ids)\n\n    # Simple MLM labels: predict a couple of positions, others ignored.\n    labels_mlm = input_ids.clone()\n    labels_mlm[:, 0] = -100\n\n    # Per-level targets; use -100 to mark missing labels for one example.\n    level_targets = {\n        1: torch.tensor([0, 1], dtype=torch.long),\n        2: torch.tensor([2, -100], dtype=torch.long),\n    }\n\n    # Paths: [root, level1, level2]; align with level indices 1 and 2.\n    paths = [\n        [0, 0, 2],\n        [0, 1, 3],\n    ]\n\n    out = model(\n        input_ids=input_ids,\n        attention_mask=attention_mask,\n        labels_mlm=labels_mlm,\n        level_targets=level_targets,\n        paths=paths,\n    )\n\n    assert \"loss\" in out\n    assert out[\"loss\"] is not None\n    assert \"loss_components\" in out\n    loss_components = out[\"loss_components\"]\n    assert \"mlm\" in loss_components\n    assert \"hier\" in loss_components\n    # Path loss may be zero if no invalid mass, but key should exist when paths are provided.\n    assert \"path\" in loss_components\n\n    # Shape checks\n    mlm_logits = out[\"mlm_logits\"]\n    assert mlm_logits.shape == (batch_size, seq_len, model.encoder.config.vocab_size)\n\n    level_logits = out[\"level_logits\"]\n    assert set(level_logits.keys()) == {\"1\", \"2\"}\n    assert level_logits[\"1\"].shape == (batch_size, 3)\n    assert level_logits[\"2\"].shape == (batch_size, 4)\n\n    proj = out[\"proj\"]\n    assert proj.shape == (batch_size, cfg.proj_dim)\n    # Embeddings should be L2-normalized.\n    norms = torch.norm(proj, dim=-1)\n    assert torch.allclose(norms, torch.ones_like(norms), atol=1e-5)\n\n\ndef test_path_consistency_penalizes_invalid_children():\n    \"\"\"\n    Directly test the path-consistency helper on a toy example:\n      - Parent distribution puts mass entirely on parent 0.\n      - Child distribution puts mass on a child whose parent != 0.\n      - The resulting path loss should be strictly positive.\n    \"\"\"\n    _patch_auto_model()\n\n    cfg = modeling.TOLBERTConfig(\n        base_model_name=\"dummy\",\n        level_sizes={1: 2, 2: 2},\n        proj_dim=4,\n        lambda_hier=1.0,\n        lambda_path=1.0,\n    )\n    model = modeling.TOLBERT(cfg)\n\n    device = next(model.parameters()).device\n\n    # Construct dummy logits for level 1 and 2.\n    # Level 1: always predict parent 0 with prob ~1.\n    logits_l1 = torch.tensor([[10.0, -10.0]], device=device)  # (1, 2)\n    # Level 2: two children; child 0 has parent 1 (mismatched), child 1 has parent 0 (matched).\n    logits_l2 = torch.tensor([[10.0, -10.0]], device=device)  # will favor child 0 (invalid)\n\n    level_logits = {\"1\": logits_l1, \"2\": logits_l2}\n\n    # Paths: [root, parent_id_at_level1, child_id_at_level2]\n    # Define ontology:\n    #   - child 0 -> parent 1\n    #   - child 1 -> parent 0\n    # By choosing parent 0 at level 1 and highest prob on child 0 at level 2,\n    # we force probability mass on an invalid child.\n    paths = [[0, 0, 0]]\n\n    path_loss = model._compute_path_consistency_loss(level_logits, paths)\n    # With a consistent ontology (child->parent mapping derived from paths),\n    # the KL-based path-consistency loss should be finite and non-negative.\n    assert path_loss is not None\n    assert torch.isfinite(path_loss)\n    assert path_loss.item() >= 0.0\n\n","source_hash":"a23659190b4c9b73cf53e1dad8c490be6e3133c7094f04b2b898046a281ef83c","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:tests.test_modeling._DummyEncoder","uri":"program://TOLBERT/class/tests.test_modeling._DummyEncoder#L16-L36","kind":"class","name":"_DummyEncoder","path":"tests/test_modeling.py","language":"python","start_line":16,"end_line":36,"context_start_line":1,"context_end_line":56,"code":"import types\nfrom pathlib import Path\nimport sys\n\nimport torch\n\n# Ensure project root is on sys.path so `tolbert` imports resolve consistently,\n# even when tests are run from outside the repository root.\nPROJECT_ROOT = Path(__file__).resolve().parents[1]\nif str(PROJECT_ROOT) not in sys.path:\n    sys.path.insert(0, str(PROJECT_ROOT))\n\nfrom tolbert import modeling\n\n\nclass _DummyEncoder(torch.nn.Module):\n    \"\"\"\n    Tiny stand-in for a HuggingFace AutoModel encoder.\n\n    It exposes:\n      - .config.hidden_size\n      - .config.vocab_size\n      - .forward(...).last_hidden_state\n    so that TOLBERT can be instantiated without downloading a real model.\n    \"\"\"\n\n    def __init__(self, hidden_size: int = 16, vocab_size: int = 32) -> None:\n        super().__init__()\n        self.config = types.SimpleNamespace(hidden_size=hidden_size, vocab_size=vocab_size)\n\n    def forward(self, input_ids=None, attention_mask=None):\n        batch, seq_len = input_ids.shape\n        # Simple deterministic hidden states for reproducibility across runs.\n        hidden = torch.arange(batch * seq_len * self.config.hidden_size, dtype=torch.float32)\n        hidden = hidden.view(batch, seq_len, self.config.hidden_size)\n        return types.SimpleNamespace(last_hidden_state=hidden)\n\n\nclass _DummyAutoModel:\n    @classmethod\n    def from_pretrained(cls, *args, **kwargs):\n        return _DummyEncoder()\n\n\ndef _patch_auto_model():\n    \"\"\"\n    Replace modeling.AutoModel with a cheap local encoder for tests.\n    \"\"\"\n    modeling.AutoModel = _DummyAutoModel  # type: ignore[assignment]\n\n\ndef test_tolbert_forward_shapes_and_losses():\n    \"\"\"\n    Basic sanity check:\n      - TOLBERT can be instantiated with a dummy encoder.\n      - Forward pass returns all expected keys.","source_hash":"a23659190b4c9b73cf53e1dad8c490be6e3133c7094f04b2b898046a281ef83c","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:tests.test_modeling._DummyAutoModel","uri":"program://TOLBERT/class/tests.test_modeling._DummyAutoModel#L39-L42","kind":"class","name":"_DummyAutoModel","path":"tests/test_modeling.py","language":"python","start_line":39,"end_line":42,"context_start_line":19,"context_end_line":62,"code":"\n    It exposes:\n      - .config.hidden_size\n      - .config.vocab_size\n      - .forward(...).last_hidden_state\n    so that TOLBERT can be instantiated without downloading a real model.\n    \"\"\"\n\n    def __init__(self, hidden_size: int = 16, vocab_size: int = 32) -> None:\n        super().__init__()\n        self.config = types.SimpleNamespace(hidden_size=hidden_size, vocab_size=vocab_size)\n\n    def forward(self, input_ids=None, attention_mask=None):\n        batch, seq_len = input_ids.shape\n        # Simple deterministic hidden states for reproducibility across runs.\n        hidden = torch.arange(batch * seq_len * self.config.hidden_size, dtype=torch.float32)\n        hidden = hidden.view(batch, seq_len, self.config.hidden_size)\n        return types.SimpleNamespace(last_hidden_state=hidden)\n\n\nclass _DummyAutoModel:\n    @classmethod\n    def from_pretrained(cls, *args, **kwargs):\n        return _DummyEncoder()\n\n\ndef _patch_auto_model():\n    \"\"\"\n    Replace modeling.AutoModel with a cheap local encoder for tests.\n    \"\"\"\n    modeling.AutoModel = _DummyAutoModel  # type: ignore[assignment]\n\n\ndef test_tolbert_forward_shapes_and_losses():\n    \"\"\"\n    Basic sanity check:\n      - TOLBERT can be instantiated with a dummy encoder.\n      - Forward pass returns all expected keys.\n      - Loss and individual loss components are present.\n    \"\"\"\n    _patch_auto_model()\n\n    cfg = modeling.TOLBERTConfig(\n        base_model_name=\"dummy\",","source_hash":"a23659190b4c9b73cf53e1dad8c490be6e3133c7094f04b2b898046a281ef83c","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:tests.test_modeling._patch_auto_model","uri":"program://TOLBERT/function/tests.test_modeling._patch_auto_model#L45-L49","kind":"function","name":"_patch_auto_model","path":"tests/test_modeling.py","language":"python","start_line":45,"end_line":49,"context_start_line":25,"context_end_line":69,"code":"    \"\"\"\n\n    def __init__(self, hidden_size: int = 16, vocab_size: int = 32) -> None:\n        super().__init__()\n        self.config = types.SimpleNamespace(hidden_size=hidden_size, vocab_size=vocab_size)\n\n    def forward(self, input_ids=None, attention_mask=None):\n        batch, seq_len = input_ids.shape\n        # Simple deterministic hidden states for reproducibility across runs.\n        hidden = torch.arange(batch * seq_len * self.config.hidden_size, dtype=torch.float32)\n        hidden = hidden.view(batch, seq_len, self.config.hidden_size)\n        return types.SimpleNamespace(last_hidden_state=hidden)\n\n\nclass _DummyAutoModel:\n    @classmethod\n    def from_pretrained(cls, *args, **kwargs):\n        return _DummyEncoder()\n\n\ndef _patch_auto_model():\n    \"\"\"\n    Replace modeling.AutoModel with a cheap local encoder for tests.\n    \"\"\"\n    modeling.AutoModel = _DummyAutoModel  # type: ignore[assignment]\n\n\ndef test_tolbert_forward_shapes_and_losses():\n    \"\"\"\n    Basic sanity check:\n      - TOLBERT can be instantiated with a dummy encoder.\n      - Forward pass returns all expected keys.\n      - Loss and individual loss components are present.\n    \"\"\"\n    _patch_auto_model()\n\n    cfg = modeling.TOLBERTConfig(\n        base_model_name=\"dummy\",\n        level_sizes={1: 3, 2: 4},\n        proj_dim=8,\n        lambda_hier=1.0,\n        lambda_path=0.5,\n    )\n    model = modeling.TOLBERT(cfg)\n","source_hash":"a23659190b4c9b73cf53e1dad8c490be6e3133c7094f04b2b898046a281ef83c","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:tests.test_modeling.test_tolbert_forward_shapes_and_losses","uri":"program://TOLBERT/function/tests.test_modeling.test_tolbert_forward_shapes_and_losses#L52-L120","kind":"function","name":"test_tolbert_forward_shapes_and_losses","path":"tests/test_modeling.py","language":"python","start_line":52,"end_line":120,"context_start_line":32,"context_end_line":140,"code":"        batch, seq_len = input_ids.shape\n        # Simple deterministic hidden states for reproducibility across runs.\n        hidden = torch.arange(batch * seq_len * self.config.hidden_size, dtype=torch.float32)\n        hidden = hidden.view(batch, seq_len, self.config.hidden_size)\n        return types.SimpleNamespace(last_hidden_state=hidden)\n\n\nclass _DummyAutoModel:\n    @classmethod\n    def from_pretrained(cls, *args, **kwargs):\n        return _DummyEncoder()\n\n\ndef _patch_auto_model():\n    \"\"\"\n    Replace modeling.AutoModel with a cheap local encoder for tests.\n    \"\"\"\n    modeling.AutoModel = _DummyAutoModel  # type: ignore[assignment]\n\n\ndef test_tolbert_forward_shapes_and_losses():\n    \"\"\"\n    Basic sanity check:\n      - TOLBERT can be instantiated with a dummy encoder.\n      - Forward pass returns all expected keys.\n      - Loss and individual loss components are present.\n    \"\"\"\n    _patch_auto_model()\n\n    cfg = modeling.TOLBERTConfig(\n        base_model_name=\"dummy\",\n        level_sizes={1: 3, 2: 4},\n        proj_dim=8,\n        lambda_hier=1.0,\n        lambda_path=0.5,\n    )\n    model = modeling.TOLBERT(cfg)\n\n    batch_size, seq_len = 2, 5\n    input_ids = torch.ones(batch_size, seq_len, dtype=torch.long)\n    attention_mask = torch.ones_like(input_ids)\n\n    # Simple MLM labels: predict a couple of positions, others ignored.\n    labels_mlm = input_ids.clone()\n    labels_mlm[:, 0] = -100\n\n    # Per-level targets; use -100 to mark missing labels for one example.\n    level_targets = {\n        1: torch.tensor([0, 1], dtype=torch.long),\n        2: torch.tensor([2, -100], dtype=torch.long),\n    }\n\n    # Paths: [root, level1, level2]; align with level indices 1 and 2.\n    paths = [\n        [0, 0, 2],\n        [0, 1, 3],\n    ]\n\n    out = model(\n        input_ids=input_ids,\n        attention_mask=attention_mask,\n        labels_mlm=labels_mlm,\n        level_targets=level_targets,\n        paths=paths,\n    )\n\n    assert \"loss\" in out\n    assert out[\"loss\"] is not None\n    assert \"loss_components\" in out\n    loss_components = out[\"loss_components\"]\n    assert \"mlm\" in loss_components\n    assert \"hier\" in loss_components\n    # Path loss may be zero if no invalid mass, but key should exist when paths are provided.\n    assert \"path\" in loss_components\n\n    # Shape checks\n    mlm_logits = out[\"mlm_logits\"]\n    assert mlm_logits.shape == (batch_size, seq_len, model.encoder.config.vocab_size)\n\n    level_logits = out[\"level_logits\"]\n    assert set(level_logits.keys()) == {\"1\", \"2\"}\n    assert level_logits[\"1\"].shape == (batch_size, 3)\n    assert level_logits[\"2\"].shape == (batch_size, 4)\n\n    proj = out[\"proj\"]\n    assert proj.shape == (batch_size, cfg.proj_dim)\n    # Embeddings should be L2-normalized.\n    norms = torch.norm(proj, dim=-1)\n    assert torch.allclose(norms, torch.ones_like(norms), atol=1e-5)\n\n\ndef test_path_consistency_penalizes_invalid_children():\n    \"\"\"\n    Directly test the path-consistency helper on a toy example:\n      - Parent distribution puts mass entirely on parent 0.\n      - Child distribution puts mass on a child whose parent != 0.\n      - The resulting path loss should be strictly positive.\n    \"\"\"\n    _patch_auto_model()\n\n    cfg = modeling.TOLBERTConfig(\n        base_model_name=\"dummy\",\n        level_sizes={1: 2, 2: 2},\n        proj_dim=4,\n        lambda_hier=1.0,\n        lambda_path=1.0,\n    )\n    model = modeling.TOLBERT(cfg)\n","source_hash":"a23659190b4c9b73cf53e1dad8c490be6e3133c7094f04b2b898046a281ef83c","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:tests.test_modeling.test_path_consistency_penalizes_invalid_children","uri":"program://TOLBERT/function/tests.test_modeling.test_path_consistency_penalizes_invalid_children#L123-L164","kind":"function","name":"test_path_consistency_penalizes_invalid_children","path":"tests/test_modeling.py","language":"python","start_line":123,"end_line":164,"context_start_line":103,"context_end_line":166,"code":"    assert \"hier\" in loss_components\n    # Path loss may be zero if no invalid mass, but key should exist when paths are provided.\n    assert \"path\" in loss_components\n\n    # Shape checks\n    mlm_logits = out[\"mlm_logits\"]\n    assert mlm_logits.shape == (batch_size, seq_len, model.encoder.config.vocab_size)\n\n    level_logits = out[\"level_logits\"]\n    assert set(level_logits.keys()) == {\"1\", \"2\"}\n    assert level_logits[\"1\"].shape == (batch_size, 3)\n    assert level_logits[\"2\"].shape == (batch_size, 4)\n\n    proj = out[\"proj\"]\n    assert proj.shape == (batch_size, cfg.proj_dim)\n    # Embeddings should be L2-normalized.\n    norms = torch.norm(proj, dim=-1)\n    assert torch.allclose(norms, torch.ones_like(norms), atol=1e-5)\n\n\ndef test_path_consistency_penalizes_invalid_children():\n    \"\"\"\n    Directly test the path-consistency helper on a toy example:\n      - Parent distribution puts mass entirely on parent 0.\n      - Child distribution puts mass on a child whose parent != 0.\n      - The resulting path loss should be strictly positive.\n    \"\"\"\n    _patch_auto_model()\n\n    cfg = modeling.TOLBERTConfig(\n        base_model_name=\"dummy\",\n        level_sizes={1: 2, 2: 2},\n        proj_dim=4,\n        lambda_hier=1.0,\n        lambda_path=1.0,\n    )\n    model = modeling.TOLBERT(cfg)\n\n    device = next(model.parameters()).device\n\n    # Construct dummy logits for level 1 and 2.\n    # Level 1: always predict parent 0 with prob ~1.\n    logits_l1 = torch.tensor([[10.0, -10.0]], device=device)  # (1, 2)\n    # Level 2: two children; child 0 has parent 1 (mismatched), child 1 has parent 0 (matched).\n    logits_l2 = torch.tensor([[10.0, -10.0]], device=device)  # will favor child 0 (invalid)\n\n    level_logits = {\"1\": logits_l1, \"2\": logits_l2}\n\n    # Paths: [root, parent_id_at_level1, child_id_at_level2]\n    # Define ontology:\n    #   - child 0 -> parent 1\n    #   - child 1 -> parent 0\n    # By choosing parent 0 at level 1 and highest prob on child 0 at level 2,\n    # we force probability mass on an invalid child.\n    paths = [[0, 0, 0]]\n\n    path_loss = model._compute_path_consistency_loss(level_logits, paths)\n    # With a consistent ontology (child->parent mapping derived from paths),\n    # the KL-based path-consistency loss should be finite and non-negative.\n    assert path_loss is not None\n    assert torch.isfinite(path_loss)\n    assert path_loss.item() >= 0.0\n\n","source_hash":"a23659190b4c9b73cf53e1dad8c490be6e3133c7094f04b2b898046a281ef83c","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:tests.test_modeling.__init__","uri":"program://TOLBERT/function/tests.test_modeling.__init__#L27-L29","kind":"function","name":"__init__","path":"tests/test_modeling.py","language":"python","start_line":27,"end_line":29,"context_start_line":7,"context_end_line":49,"code":"# Ensure project root is on sys.path so `tolbert` imports resolve consistently,\n# even when tests are run from outside the repository root.\nPROJECT_ROOT = Path(__file__).resolve().parents[1]\nif str(PROJECT_ROOT) not in sys.path:\n    sys.path.insert(0, str(PROJECT_ROOT))\n\nfrom tolbert import modeling\n\n\nclass _DummyEncoder(torch.nn.Module):\n    \"\"\"\n    Tiny stand-in for a HuggingFace AutoModel encoder.\n\n    It exposes:\n      - .config.hidden_size\n      - .config.vocab_size\n      - .forward(...).last_hidden_state\n    so that TOLBERT can be instantiated without downloading a real model.\n    \"\"\"\n\n    def __init__(self, hidden_size: int = 16, vocab_size: int = 32) -> None:\n        super().__init__()\n        self.config = types.SimpleNamespace(hidden_size=hidden_size, vocab_size=vocab_size)\n\n    def forward(self, input_ids=None, attention_mask=None):\n        batch, seq_len = input_ids.shape\n        # Simple deterministic hidden states for reproducibility across runs.\n        hidden = torch.arange(batch * seq_len * self.config.hidden_size, dtype=torch.float32)\n        hidden = hidden.view(batch, seq_len, self.config.hidden_size)\n        return types.SimpleNamespace(last_hidden_state=hidden)\n\n\nclass _DummyAutoModel:\n    @classmethod\n    def from_pretrained(cls, *args, **kwargs):\n        return _DummyEncoder()\n\n\ndef _patch_auto_model():\n    \"\"\"\n    Replace modeling.AutoModel with a cheap local encoder for tests.\n    \"\"\"\n    modeling.AutoModel = _DummyAutoModel  # type: ignore[assignment]","source_hash":"a23659190b4c9b73cf53e1dad8c490be6e3133c7094f04b2b898046a281ef83c","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:tests.test_modeling.forward","uri":"program://TOLBERT/function/tests.test_modeling.forward#L31-L36","kind":"function","name":"forward","path":"tests/test_modeling.py","language":"python","start_line":31,"end_line":36,"context_start_line":11,"context_end_line":56,"code":"    sys.path.insert(0, str(PROJECT_ROOT))\n\nfrom tolbert import modeling\n\n\nclass _DummyEncoder(torch.nn.Module):\n    \"\"\"\n    Tiny stand-in for a HuggingFace AutoModel encoder.\n\n    It exposes:\n      - .config.hidden_size\n      - .config.vocab_size\n      - .forward(...).last_hidden_state\n    so that TOLBERT can be instantiated without downloading a real model.\n    \"\"\"\n\n    def __init__(self, hidden_size: int = 16, vocab_size: int = 32) -> None:\n        super().__init__()\n        self.config = types.SimpleNamespace(hidden_size=hidden_size, vocab_size=vocab_size)\n\n    def forward(self, input_ids=None, attention_mask=None):\n        batch, seq_len = input_ids.shape\n        # Simple deterministic hidden states for reproducibility across runs.\n        hidden = torch.arange(batch * seq_len * self.config.hidden_size, dtype=torch.float32)\n        hidden = hidden.view(batch, seq_len, self.config.hidden_size)\n        return types.SimpleNamespace(last_hidden_state=hidden)\n\n\nclass _DummyAutoModel:\n    @classmethod\n    def from_pretrained(cls, *args, **kwargs):\n        return _DummyEncoder()\n\n\ndef _patch_auto_model():\n    \"\"\"\n    Replace modeling.AutoModel with a cheap local encoder for tests.\n    \"\"\"\n    modeling.AutoModel = _DummyAutoModel  # type: ignore[assignment]\n\n\ndef test_tolbert_forward_shapes_and_losses():\n    \"\"\"\n    Basic sanity check:\n      - TOLBERT can be instantiated with a dummy encoder.\n      - Forward pass returns all expected keys.","source_hash":"a23659190b4c9b73cf53e1dad8c490be6e3133c7094f04b2b898046a281ef83c","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:tests.test_modeling.from_pretrained","uri":"program://TOLBERT/function/tests.test_modeling.from_pretrained#L41-L42","kind":"function","name":"from_pretrained","path":"tests/test_modeling.py","language":"python","start_line":41,"end_line":42,"context_start_line":21,"context_end_line":62,"code":"      - .config.hidden_size\n      - .config.vocab_size\n      - .forward(...).last_hidden_state\n    so that TOLBERT can be instantiated without downloading a real model.\n    \"\"\"\n\n    def __init__(self, hidden_size: int = 16, vocab_size: int = 32) -> None:\n        super().__init__()\n        self.config = types.SimpleNamespace(hidden_size=hidden_size, vocab_size=vocab_size)\n\n    def forward(self, input_ids=None, attention_mask=None):\n        batch, seq_len = input_ids.shape\n        # Simple deterministic hidden states for reproducibility across runs.\n        hidden = torch.arange(batch * seq_len * self.config.hidden_size, dtype=torch.float32)\n        hidden = hidden.view(batch, seq_len, self.config.hidden_size)\n        return types.SimpleNamespace(last_hidden_state=hidden)\n\n\nclass _DummyAutoModel:\n    @classmethod\n    def from_pretrained(cls, *args, **kwargs):\n        return _DummyEncoder()\n\n\ndef _patch_auto_model():\n    \"\"\"\n    Replace modeling.AutoModel with a cheap local encoder for tests.\n    \"\"\"\n    modeling.AutoModel = _DummyAutoModel  # type: ignore[assignment]\n\n\ndef test_tolbert_forward_shapes_and_losses():\n    \"\"\"\n    Basic sanity check:\n      - TOLBERT can be instantiated with a dummy encoder.\n      - Forward pass returns all expected keys.\n      - Loss and individual loss components are present.\n    \"\"\"\n    _patch_auto_model()\n\n    cfg = modeling.TOLBERTConfig(\n        base_model_name=\"dummy\",","source_hash":"a23659190b4c9b73cf53e1dad8c490be6e3133c7094f04b2b898046a281ef83c","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:tests.test_repo_tree_of_life","uri":"program://TOLBERT/module/tests.test_repo_tree_of_life#L1-L87","kind":"module","name":"tests.test_repo_tree_of_life","path":"tests/test_repo_tree_of_life.py","language":"python","start_line":1,"end_line":87,"context_start_line":1,"context_end_line":87,"code":"from pathlib import Path\nimport sys\nfrom typing import List\n\nimport torch\n\n# Ensure project root is on sys.path so we import the local `scripts` package.\nPROJECT_ROOT = Path(__file__).resolve().parents[1]\nif str(PROJECT_ROOT) not in sys.path:\n    sys.path.insert(0, str(PROJECT_ROOT))\n\nfrom scripts import build_repo_tree_of_life\n\n\nclass _DummySpan:\n    def __init__(self, start_line: int, end_line: int) -> None:\n        self.start_line = start_line\n        self.end_line = end_line\n\n\nclass _DummyEntity:\n    def __init__(self, kind: str, rel_path: str, labels: List[str] | None = None):\n        self.kind = kind\n        self.attributes = {\"rel_path\": rel_path, \"name\": rel_path}\n        self.labels = labels or []\n        self.id = rel_path\n        self.artifact_uri = f\"program://dummy/artifact/{rel_path}\"\n        self.span = _DummySpan(1, 10)\n\n\nclass _DummyRepoGraph:\n    \"\"\"\n    Minimal stand-in for RepoGraph.entities() to exercise build_tree_for_repo.\n    \"\"\"\n\n    def __init__(self, root: str) -> None:\n        self.root = root\n\n    def entities(self):\n        # One Python file and one C++ file, plus a function symbol in the Python file.\n        return [\n            _DummyEntity(\"file\", \"pkg/file1.py\", labels=[\"lang:python\"]),\n            _DummyEntity(\"file\", \"pkg/file2.cpp\", labels=[\"lang:cpp\"]),\n            _DummyEntity(\"function\", \"pkg/file1.py::fn\", labels=[]),\n        ]\n\n\ndef test_build_tree_for_repo_with_dummy_graph(tmp_path: Path, monkeypatch):\n    \"\"\"\n    Smoke test for build_tree_for_repo:\n      - uses a dummy RepoGraph to avoid filesystem scanning,\n      - verifies that nodes, edges, and spans have the expected basic structure.\n    \"\"\"\n    # Patch RepoGraph used inside build_repo_tree_of_life to our dummy.\n    monkeypatch.setattr(build_repo_tree_of_life, \"RepoGraph\", _DummyRepoGraph)\n\n    repo_root = tmp_path / \"repo\"\n    (repo_root / \"pkg\").mkdir(parents=True)\n    (repo_root / \"pkg\" / \"file1.py\").write_text(\"print('hello')\\n\", encoding=\"utf-8\")\n    (repo_root / \"pkg\" / \"file2.cpp\").write_text(\"int main() { return 0; }\\n\", encoding=\"utf-8\")\n\n    nodes, edges, spans = build_repo_tree_of_life.build_tree_for_repo(repo_root)\n\n    # Basic sanity checks.\n    assert nodes\n    assert edges\n    assert spans\n\n    # There should be a root node at level 0.\n    root_nodes = [n for n in nodes if n.get(\"level\") == 0 and n.get(\"type\") == \"root\"]\n    assert len(root_nodes) == 1\n\n    # There should be language nodes at level 1 and a repo node at level 2.\n    lang_nodes = [n for n in nodes if n.get(\"level\") == 1 and n.get(\"type\") == \"language\"]\n    assert lang_nodes\n    repo_nodes = [n for n in nodes if n.get(\"level\") == 2 and n.get(\"type\") == \"repo\"]\n    assert len(repo_nodes) == 1\n\n    # Spans should have a node_path starting at root and including the repo node id.\n    repo_id = repo_nodes[0][\"node_id\"]\n    for s in spans:\n        path = s[\"node_path\"]\n        assert isinstance(path, list)\n        assert path[0] == root_nodes[0][\"node_id\"]\n        assert repo_id in path\n\n","source_hash":"c0b4a5aed10439fc6d91251766383af3c831dd9d5f42151a506f8cc9344cbde9","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:tests.test_repo_tree_of_life._DummySpan","uri":"program://TOLBERT/class/tests.test_repo_tree_of_life._DummySpan#L15-L18","kind":"class","name":"_DummySpan","path":"tests/test_repo_tree_of_life.py","language":"python","start_line":15,"end_line":18,"context_start_line":1,"context_end_line":38,"code":"from pathlib import Path\nimport sys\nfrom typing import List\n\nimport torch\n\n# Ensure project root is on sys.path so we import the local `scripts` package.\nPROJECT_ROOT = Path(__file__).resolve().parents[1]\nif str(PROJECT_ROOT) not in sys.path:\n    sys.path.insert(0, str(PROJECT_ROOT))\n\nfrom scripts import build_repo_tree_of_life\n\n\nclass _DummySpan:\n    def __init__(self, start_line: int, end_line: int) -> None:\n        self.start_line = start_line\n        self.end_line = end_line\n\n\nclass _DummyEntity:\n    def __init__(self, kind: str, rel_path: str, labels: List[str] | None = None):\n        self.kind = kind\n        self.attributes = {\"rel_path\": rel_path, \"name\": rel_path}\n        self.labels = labels or []\n        self.id = rel_path\n        self.artifact_uri = f\"program://dummy/artifact/{rel_path}\"\n        self.span = _DummySpan(1, 10)\n\n\nclass _DummyRepoGraph:\n    \"\"\"\n    Minimal stand-in for RepoGraph.entities() to exercise build_tree_for_repo.\n    \"\"\"\n\n    def __init__(self, root: str) -> None:\n        self.root = root\n","source_hash":"c0b4a5aed10439fc6d91251766383af3c831dd9d5f42151a506f8cc9344cbde9","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:tests.test_repo_tree_of_life._DummyEntity","uri":"program://TOLBERT/class/tests.test_repo_tree_of_life._DummyEntity#L21-L28","kind":"class","name":"_DummyEntity","path":"tests/test_repo_tree_of_life.py","language":"python","start_line":21,"end_line":28,"context_start_line":1,"context_end_line":48,"code":"from pathlib import Path\nimport sys\nfrom typing import List\n\nimport torch\n\n# Ensure project root is on sys.path so we import the local `scripts` package.\nPROJECT_ROOT = Path(__file__).resolve().parents[1]\nif str(PROJECT_ROOT) not in sys.path:\n    sys.path.insert(0, str(PROJECT_ROOT))\n\nfrom scripts import build_repo_tree_of_life\n\n\nclass _DummySpan:\n    def __init__(self, start_line: int, end_line: int) -> None:\n        self.start_line = start_line\n        self.end_line = end_line\n\n\nclass _DummyEntity:\n    def __init__(self, kind: str, rel_path: str, labels: List[str] | None = None):\n        self.kind = kind\n        self.attributes = {\"rel_path\": rel_path, \"name\": rel_path}\n        self.labels = labels or []\n        self.id = rel_path\n        self.artifact_uri = f\"program://dummy/artifact/{rel_path}\"\n        self.span = _DummySpan(1, 10)\n\n\nclass _DummyRepoGraph:\n    \"\"\"\n    Minimal stand-in for RepoGraph.entities() to exercise build_tree_for_repo.\n    \"\"\"\n\n    def __init__(self, root: str) -> None:\n        self.root = root\n\n    def entities(self):\n        # One Python file and one C++ file, plus a function symbol in the Python file.\n        return [\n            _DummyEntity(\"file\", \"pkg/file1.py\", labels=[\"lang:python\"]),\n            _DummyEntity(\"file\", \"pkg/file2.cpp\", labels=[\"lang:cpp\"]),\n            _DummyEntity(\"function\", \"pkg/file1.py::fn\", labels=[]),\n        ]\n\n\ndef test_build_tree_for_repo_with_dummy_graph(tmp_path: Path, monkeypatch):","source_hash":"c0b4a5aed10439fc6d91251766383af3c831dd9d5f42151a506f8cc9344cbde9","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:tests.test_repo_tree_of_life._DummyRepoGraph","uri":"program://TOLBERT/class/tests.test_repo_tree_of_life._DummyRepoGraph#L31-L45","kind":"class","name":"_DummyRepoGraph","path":"tests/test_repo_tree_of_life.py","language":"python","start_line":31,"end_line":45,"context_start_line":11,"context_end_line":65,"code":"\nfrom scripts import build_repo_tree_of_life\n\n\nclass _DummySpan:\n    def __init__(self, start_line: int, end_line: int) -> None:\n        self.start_line = start_line\n        self.end_line = end_line\n\n\nclass _DummyEntity:\n    def __init__(self, kind: str, rel_path: str, labels: List[str] | None = None):\n        self.kind = kind\n        self.attributes = {\"rel_path\": rel_path, \"name\": rel_path}\n        self.labels = labels or []\n        self.id = rel_path\n        self.artifact_uri = f\"program://dummy/artifact/{rel_path}\"\n        self.span = _DummySpan(1, 10)\n\n\nclass _DummyRepoGraph:\n    \"\"\"\n    Minimal stand-in for RepoGraph.entities() to exercise build_tree_for_repo.\n    \"\"\"\n\n    def __init__(self, root: str) -> None:\n        self.root = root\n\n    def entities(self):\n        # One Python file and one C++ file, plus a function symbol in the Python file.\n        return [\n            _DummyEntity(\"file\", \"pkg/file1.py\", labels=[\"lang:python\"]),\n            _DummyEntity(\"file\", \"pkg/file2.cpp\", labels=[\"lang:cpp\"]),\n            _DummyEntity(\"function\", \"pkg/file1.py::fn\", labels=[]),\n        ]\n\n\ndef test_build_tree_for_repo_with_dummy_graph(tmp_path: Path, monkeypatch):\n    \"\"\"\n    Smoke test for build_tree_for_repo:\n      - uses a dummy RepoGraph to avoid filesystem scanning,\n      - verifies that nodes, edges, and spans have the expected basic structure.\n    \"\"\"\n    # Patch RepoGraph used inside build_repo_tree_of_life to our dummy.\n    monkeypatch.setattr(build_repo_tree_of_life, \"RepoGraph\", _DummyRepoGraph)\n\n    repo_root = tmp_path / \"repo\"\n    (repo_root / \"pkg\").mkdir(parents=True)\n    (repo_root / \"pkg\" / \"file1.py\").write_text(\"print('hello')\\n\", encoding=\"utf-8\")\n    (repo_root / \"pkg\" / \"file2.cpp\").write_text(\"int main() { return 0; }\\n\", encoding=\"utf-8\")\n\n    nodes, edges, spans = build_repo_tree_of_life.build_tree_for_repo(repo_root)\n\n    # Basic sanity checks.\n    assert nodes","source_hash":"c0b4a5aed10439fc6d91251766383af3c831dd9d5f42151a506f8cc9344cbde9","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:tests.test_repo_tree_of_life.test_build_tree_for_repo_with_dummy_graph","uri":"program://TOLBERT/function/tests.test_repo_tree_of_life.test_build_tree_for_repo_with_dummy_graph#L48-L85","kind":"function","name":"test_build_tree_for_repo_with_dummy_graph","path":"tests/test_repo_tree_of_life.py","language":"python","start_line":48,"end_line":85,"context_start_line":28,"context_end_line":87,"code":"        self.span = _DummySpan(1, 10)\n\n\nclass _DummyRepoGraph:\n    \"\"\"\n    Minimal stand-in for RepoGraph.entities() to exercise build_tree_for_repo.\n    \"\"\"\n\n    def __init__(self, root: str) -> None:\n        self.root = root\n\n    def entities(self):\n        # One Python file and one C++ file, plus a function symbol in the Python file.\n        return [\n            _DummyEntity(\"file\", \"pkg/file1.py\", labels=[\"lang:python\"]),\n            _DummyEntity(\"file\", \"pkg/file2.cpp\", labels=[\"lang:cpp\"]),\n            _DummyEntity(\"function\", \"pkg/file1.py::fn\", labels=[]),\n        ]\n\n\ndef test_build_tree_for_repo_with_dummy_graph(tmp_path: Path, monkeypatch):\n    \"\"\"\n    Smoke test for build_tree_for_repo:\n      - uses a dummy RepoGraph to avoid filesystem scanning,\n      - verifies that nodes, edges, and spans have the expected basic structure.\n    \"\"\"\n    # Patch RepoGraph used inside build_repo_tree_of_life to our dummy.\n    monkeypatch.setattr(build_repo_tree_of_life, \"RepoGraph\", _DummyRepoGraph)\n\n    repo_root = tmp_path / \"repo\"\n    (repo_root / \"pkg\").mkdir(parents=True)\n    (repo_root / \"pkg\" / \"file1.py\").write_text(\"print('hello')\\n\", encoding=\"utf-8\")\n    (repo_root / \"pkg\" / \"file2.cpp\").write_text(\"int main() { return 0; }\\n\", encoding=\"utf-8\")\n\n    nodes, edges, spans = build_repo_tree_of_life.build_tree_for_repo(repo_root)\n\n    # Basic sanity checks.\n    assert nodes\n    assert edges\n    assert spans\n\n    # There should be a root node at level 0.\n    root_nodes = [n for n in nodes if n.get(\"level\") == 0 and n.get(\"type\") == \"root\"]\n    assert len(root_nodes) == 1\n\n    # There should be language nodes at level 1 and a repo node at level 2.\n    lang_nodes = [n for n in nodes if n.get(\"level\") == 1 and n.get(\"type\") == \"language\"]\n    assert lang_nodes\n    repo_nodes = [n for n in nodes if n.get(\"level\") == 2 and n.get(\"type\") == \"repo\"]\n    assert len(repo_nodes) == 1\n\n    # Spans should have a node_path starting at root and including the repo node id.\n    repo_id = repo_nodes[0][\"node_id\"]\n    for s in spans:\n        path = s[\"node_path\"]\n        assert isinstance(path, list)\n        assert path[0] == root_nodes[0][\"node_id\"]\n        assert repo_id in path\n\n","source_hash":"c0b4a5aed10439fc6d91251766383af3c831dd9d5f42151a506f8cc9344cbde9","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:tests.test_repo_tree_of_life.__init__","uri":"program://TOLBERT/function/tests.test_repo_tree_of_life.__init__#L36-L37","kind":"function","name":"__init__","path":"tests/test_repo_tree_of_life.py","language":"python","start_line":36,"end_line":37,"context_start_line":16,"context_end_line":57,"code":"    def __init__(self, start_line: int, end_line: int) -> None:\n        self.start_line = start_line\n        self.end_line = end_line\n\n\nclass _DummyEntity:\n    def __init__(self, kind: str, rel_path: str, labels: List[str] | None = None):\n        self.kind = kind\n        self.attributes = {\"rel_path\": rel_path, \"name\": rel_path}\n        self.labels = labels or []\n        self.id = rel_path\n        self.artifact_uri = f\"program://dummy/artifact/{rel_path}\"\n        self.span = _DummySpan(1, 10)\n\n\nclass _DummyRepoGraph:\n    \"\"\"\n    Minimal stand-in for RepoGraph.entities() to exercise build_tree_for_repo.\n    \"\"\"\n\n    def __init__(self, root: str) -> None:\n        self.root = root\n\n    def entities(self):\n        # One Python file and one C++ file, plus a function symbol in the Python file.\n        return [\n            _DummyEntity(\"file\", \"pkg/file1.py\", labels=[\"lang:python\"]),\n            _DummyEntity(\"file\", \"pkg/file2.cpp\", labels=[\"lang:cpp\"]),\n            _DummyEntity(\"function\", \"pkg/file1.py::fn\", labels=[]),\n        ]\n\n\ndef test_build_tree_for_repo_with_dummy_graph(tmp_path: Path, monkeypatch):\n    \"\"\"\n    Smoke test for build_tree_for_repo:\n      - uses a dummy RepoGraph to avoid filesystem scanning,\n      - verifies that nodes, edges, and spans have the expected basic structure.\n    \"\"\"\n    # Patch RepoGraph used inside build_repo_tree_of_life to our dummy.\n    monkeypatch.setattr(build_repo_tree_of_life, \"RepoGraph\", _DummyRepoGraph)\n\n    repo_root = tmp_path / \"repo\"","source_hash":"c0b4a5aed10439fc6d91251766383af3c831dd9d5f42151a506f8cc9344cbde9","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:tests.test_repo_tree_of_life.entities","uri":"program://TOLBERT/function/tests.test_repo_tree_of_life.entities#L39-L45","kind":"function","name":"entities","path":"tests/test_repo_tree_of_life.py","language":"python","start_line":39,"end_line":45,"context_start_line":19,"context_end_line":65,"code":"\n\nclass _DummyEntity:\n    def __init__(self, kind: str, rel_path: str, labels: List[str] | None = None):\n        self.kind = kind\n        self.attributes = {\"rel_path\": rel_path, \"name\": rel_path}\n        self.labels = labels or []\n        self.id = rel_path\n        self.artifact_uri = f\"program://dummy/artifact/{rel_path}\"\n        self.span = _DummySpan(1, 10)\n\n\nclass _DummyRepoGraph:\n    \"\"\"\n    Minimal stand-in for RepoGraph.entities() to exercise build_tree_for_repo.\n    \"\"\"\n\n    def __init__(self, root: str) -> None:\n        self.root = root\n\n    def entities(self):\n        # One Python file and one C++ file, plus a function symbol in the Python file.\n        return [\n            _DummyEntity(\"file\", \"pkg/file1.py\", labels=[\"lang:python\"]),\n            _DummyEntity(\"file\", \"pkg/file2.cpp\", labels=[\"lang:cpp\"]),\n            _DummyEntity(\"function\", \"pkg/file1.py::fn\", labels=[]),\n        ]\n\n\ndef test_build_tree_for_repo_with_dummy_graph(tmp_path: Path, monkeypatch):\n    \"\"\"\n    Smoke test for build_tree_for_repo:\n      - uses a dummy RepoGraph to avoid filesystem scanning,\n      - verifies that nodes, edges, and spans have the expected basic structure.\n    \"\"\"\n    # Patch RepoGraph used inside build_repo_tree_of_life to our dummy.\n    monkeypatch.setattr(build_repo_tree_of_life, \"RepoGraph\", _DummyRepoGraph)\n\n    repo_root = tmp_path / \"repo\"\n    (repo_root / \"pkg\").mkdir(parents=True)\n    (repo_root / \"pkg\" / \"file1.py\").write_text(\"print('hello')\\n\", encoding=\"utf-8\")\n    (repo_root / \"pkg\" / \"file2.cpp\").write_text(\"int main() { return 0; }\\n\", encoding=\"utf-8\")\n\n    nodes, edges, spans = build_repo_tree_of_life.build_tree_for_repo(repo_root)\n\n    # Basic sanity checks.\n    assert nodes","source_hash":"c0b4a5aed10439fc6d91251766383af3c831dd9d5f42151a506f8cc9344cbde9","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:tests.test_data_and_metrics","uri":"program://TOLBERT/module/tests.test_data_and_metrics#L1-L179","kind":"module","name":"tests.test_data_and_metrics","path":"tests/test_data_and_metrics.py","language":"python","start_line":1,"end_line":179,"context_start_line":1,"context_end_line":179,"code":"import json\nfrom pathlib import Path\nimport sys\n\nimport torch\n\n# Ensure project root is on sys.path so local `tolbert` and `scripts` packages\n# are importable regardless of the working directory.\nPROJECT_ROOT = Path(__file__).resolve().parents[1]\nif str(PROJECT_ROOT) not in sys.path:\n    sys.path.insert(0, str(PROJECT_ROOT))\n\nfrom tolbert.data import TreeOfLifeDataset, collate_tree_of_life_batch\nfrom scripts import eval_retrieval\n\n\ndef test_tree_of_life_dataset_and_collate_single_path(tmp_path: Path):\n    \"\"\"\n    Verify that TreeOfLifeDataset:\n      - reads node_path into per-level targets,\n      - produces paths suitable for contrastive / path losses,\n      - and that collate_tree_of_life_batch produces the expected tensors.\n    \"\"\"\n    spans_path = tmp_path / \"spans_single.jsonl\"\n    records = [\n        {\n            \"span_id\": \"s1\",\n            \"text\": \"hello world\",\n            \"node_path\": [0, 1, 3],\n        },\n        {\n            \"span_id\": \"s2\",\n            \"text\": \"another span\",\n            \"node_path\": [0, 2, 4],\n        },\n    ]\n    with spans_path.open(\"w\", encoding=\"utf-8\") as f:\n        for rec in records:\n            f.write(json.dumps(rec) + \"\\n\")\n\n    class _DummyTokenizer:\n        def __init__(self):\n            self.vocab_size = 100\n            # Provide a MASK token id for MLM replacement logic.\n            self.mask_token_id = 99\n\n        def get_special_tokens_mask(self, ids, already_has_special_tokens=True):\n            return [0] * len(ids)\n\n        def __call__(self, text, return_tensors, truncation, padding, max_length):\n            # Simple fixed-length encoding: map each char to an integer.\n            ids = list(range(1, min(len(text) + 1, max_length - 2)))\n            # Pad / truncate to max_length.\n            ids = ids + [0] * (max_length - len(ids))\n            input_ids = torch.tensor(ids, dtype=torch.long).unsqueeze(0)\n            attention_mask = (input_ids != 0).long()\n            return {\"input_ids\": input_ids, \"attention_mask\": attention_mask}\n\n    tokenizer = _DummyTokenizer()\n    ds = TreeOfLifeDataset(\n        spans_file=str(spans_path),\n        tokenizer=tokenizer,  # type: ignore[arg-type]\n        max_length=8,\n        mask_probability=0.15,\n    )\n\n    assert len(ds) == 2\n    sample0 = ds[0]\n    assert \"input_ids\" in sample0 and \"labels_mlm\" in sample0\n    assert \"level_targets\" in sample0\n    assert \"paths\" in sample0\n    # Level targets should have entries for levels 1 and 2.\n    assert sample0[\"level_targets\"][1] == 1\n    assert sample0[\"level_targets\"][2] == 3\n\n    batch = collate_tree_of_life_batch([ds[0], ds[1]])\n    assert batch[\"input_ids\"].shape[0] == 2\n    assert set(batch[\"level_targets\"].keys()) == {1, 2}\n    # Paths should be a list of node_path lists (wrapped in an extra list per example).\n    assert \"paths\" in batch\n    assert batch[\"paths\"][0] == [[0, 1, 3]]\n    assert batch[\"paths\"][1] == [[0, 2, 4]]\n\n\ndef test_tree_of_life_dataset_with_node_paths_multi(tmp_path: Path):\n    \"\"\"\n    Verify that when `node_paths` (multiple valid paths) is provided:\n      - the first path is used as canonical `level_targets`,\n      - all paths are preserved in the `paths` field for DAG-aware losses.\n    \"\"\"\n    spans_path = tmp_path / \"spans_multi.jsonl\"\n    records = [\n        {\n            \"span_id\": \"s1\",\n            \"text\": \"multi path span\",\n            \"node_paths\": [\n                [0, 1, 3],\n                [0, 1, 4],\n            ],\n        },\n    ]\n    with spans_path.open(\"w\", encoding=\"utf-8\") as f:\n        for rec in records:\n            f.write(json.dumps(rec) + \"\\n\")\n\n    class _DummyTokenizer:\n        def __init__(self):\n            self.vocab_size = 100\n            self.mask_token_id = 99\n\n        def get_special_tokens_mask(self, ids, already_has_special_tokens=True):\n            return [0] * len(ids)\n\n        def __call__(self, text, return_tensors, truncation, padding, max_length):\n            ids = list(range(1, min(len(text) + 1, max_length - 2)))\n            ids = ids + [0] * (max_length - len(ids))\n            input_ids = torch.tensor(ids, dtype=torch.long).unsqueeze(0)\n            attention_mask = (input_ids != 0).long()\n            return {\"input_ids\": input_ids, \"attention_mask\": attention_mask}\n\n    tokenizer = _DummyTokenizer()\n    ds = TreeOfLifeDataset(\n        spans_file=str(spans_path),\n        tokenizer=tokenizer,  # type: ignore[arg-type]\n        max_length=8,\n        mask_probability=0.15,\n    )\n\n    assert len(ds) == 1\n    sample = ds[0]\n    # Canonical targets come from the first path [0,1,3].\n    assert sample[\"level_targets\"][1] == 1\n    assert sample[\"level_targets\"][2] == 3\n    # All paths are preserved.\n    assert sample[\"paths\"] == [[0, 1, 3], [0, 1, 4]]\n\n\ndef test_eval_retrieval_helpers_basic():\n    \"\"\"\n    Sanity-check compute_relevance_mask, eval_retrieval, and\n    compute_branch_consistency_at_k on a tiny toy example.\n    \"\"\"\n    # Two index items, two queries.\n    index_embs = torch.eye(2, dtype=torch.float32)\n    query_embs = torch.eye(2, dtype=torch.float32)\n\n    # Paths: query 0 matches index 0 at level 1; query 1 matches index 1.\n    index_paths = [[0, 1], [0, 2]]\n    query_paths = [[0, 1], [0, 2]]\n\n    rel = eval_retrieval.compute_relevance_mask(\n        query_paths=query_paths,\n        index_paths=index_paths,\n        min_level=1,\n    )\n    assert rel == [[True, False], [False, True]]\n\n    mrr, p_at_1 = eval_retrieval.eval_retrieval(\n        query_embs=query_embs,\n        index_embs=index_embs,\n        relevant=rel,\n        k=1,\n    )\n    # Each query retrieves its exact match at rank 1.\n    assert abs(mrr - 1.0) < 1e-6\n    assert abs(p_at_1 - 1.0) < 1e-6\n\n    bc = eval_retrieval.compute_branch_consistency_at_k(\n        query_embs=query_embs,\n        index_embs=index_embs,\n        query_paths=query_paths,\n        index_paths=index_paths,\n        k=1,\n    )\n    # At depth 1, all retrieved items share the same node as the query.\n    assert 1 in bc\n    assert abs(bc[1] - 1.0) < 1e-6\n\n","source_hash":"569916a895377791b1ccb6b8d8f47469f70691ac8b88df7997708184227c5915","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:tests.test_data_and_metrics.test_tree_of_life_dataset_and_collate_single_path","uri":"program://TOLBERT/function/tests.test_data_and_metrics.test_tree_of_life_dataset_and_collate_single_path#L17-L82","kind":"function","name":"test_tree_of_life_dataset_and_collate_single_path","path":"tests/test_data_and_metrics.py","language":"python","start_line":17,"end_line":82,"context_start_line":1,"context_end_line":102,"code":"import json\nfrom pathlib import Path\nimport sys\n\nimport torch\n\n# Ensure project root is on sys.path so local `tolbert` and `scripts` packages\n# are importable regardless of the working directory.\nPROJECT_ROOT = Path(__file__).resolve().parents[1]\nif str(PROJECT_ROOT) not in sys.path:\n    sys.path.insert(0, str(PROJECT_ROOT))\n\nfrom tolbert.data import TreeOfLifeDataset, collate_tree_of_life_batch\nfrom scripts import eval_retrieval\n\n\ndef test_tree_of_life_dataset_and_collate_single_path(tmp_path: Path):\n    \"\"\"\n    Verify that TreeOfLifeDataset:\n      - reads node_path into per-level targets,\n      - produces paths suitable for contrastive / path losses,\n      - and that collate_tree_of_life_batch produces the expected tensors.\n    \"\"\"\n    spans_path = tmp_path / \"spans_single.jsonl\"\n    records = [\n        {\n            \"span_id\": \"s1\",\n            \"text\": \"hello world\",\n            \"node_path\": [0, 1, 3],\n        },\n        {\n            \"span_id\": \"s2\",\n            \"text\": \"another span\",\n            \"node_path\": [0, 2, 4],\n        },\n    ]\n    with spans_path.open(\"w\", encoding=\"utf-8\") as f:\n        for rec in records:\n            f.write(json.dumps(rec) + \"\\n\")\n\n    class _DummyTokenizer:\n        def __init__(self):\n            self.vocab_size = 100\n            # Provide a MASK token id for MLM replacement logic.\n            self.mask_token_id = 99\n\n        def get_special_tokens_mask(self, ids, already_has_special_tokens=True):\n            return [0] * len(ids)\n\n        def __call__(self, text, return_tensors, truncation, padding, max_length):\n            # Simple fixed-length encoding: map each char to an integer.\n            ids = list(range(1, min(len(text) + 1, max_length - 2)))\n            # Pad / truncate to max_length.\n            ids = ids + [0] * (max_length - len(ids))\n            input_ids = torch.tensor(ids, dtype=torch.long).unsqueeze(0)\n            attention_mask = (input_ids != 0).long()\n            return {\"input_ids\": input_ids, \"attention_mask\": attention_mask}\n\n    tokenizer = _DummyTokenizer()\n    ds = TreeOfLifeDataset(\n        spans_file=str(spans_path),\n        tokenizer=tokenizer,  # type: ignore[arg-type]\n        max_length=8,\n        mask_probability=0.15,\n    )\n\n    assert len(ds) == 2\n    sample0 = ds[0]\n    assert \"input_ids\" in sample0 and \"labels_mlm\" in sample0\n    assert \"level_targets\" in sample0\n    assert \"paths\" in sample0\n    # Level targets should have entries for levels 1 and 2.\n    assert sample0[\"level_targets\"][1] == 1\n    assert sample0[\"level_targets\"][2] == 3\n\n    batch = collate_tree_of_life_batch([ds[0], ds[1]])\n    assert batch[\"input_ids\"].shape[0] == 2\n    assert set(batch[\"level_targets\"].keys()) == {1, 2}\n    # Paths should be a list of node_path lists (wrapped in an extra list per example).\n    assert \"paths\" in batch\n    assert batch[\"paths\"][0] == [[0, 1, 3]]\n    assert batch[\"paths\"][1] == [[0, 2, 4]]\n\n\ndef test_tree_of_life_dataset_with_node_paths_multi(tmp_path: Path):\n    \"\"\"\n    Verify that when `node_paths` (multiple valid paths) is provided:\n      - the first path is used as canonical `level_targets`,\n      - all paths are preserved in the `paths` field for DAG-aware losses.\n    \"\"\"\n    spans_path = tmp_path / \"spans_multi.jsonl\"\n    records = [\n        {\n            \"span_id\": \"s1\",\n            \"text\": \"multi path span\",\n            \"node_paths\": [\n                [0, 1, 3],\n                [0, 1, 4],\n            ],\n        },\n    ]\n    with spans_path.open(\"w\", encoding=\"utf-8\") as f:","source_hash":"569916a895377791b1ccb6b8d8f47469f70691ac8b88df7997708184227c5915","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:tests.test_data_and_metrics.test_tree_of_life_dataset_with_node_paths_multi","uri":"program://TOLBERT/function/tests.test_data_and_metrics.test_tree_of_life_dataset_with_node_paths_multi#L85-L135","kind":"function","name":"test_tree_of_life_dataset_with_node_paths_multi","path":"tests/test_data_and_metrics.py","language":"python","start_line":85,"end_line":135,"context_start_line":65,"context_end_line":155,"code":"    )\n\n    assert len(ds) == 2\n    sample0 = ds[0]\n    assert \"input_ids\" in sample0 and \"labels_mlm\" in sample0\n    assert \"level_targets\" in sample0\n    assert \"paths\" in sample0\n    # Level targets should have entries for levels 1 and 2.\n    assert sample0[\"level_targets\"][1] == 1\n    assert sample0[\"level_targets\"][2] == 3\n\n    batch = collate_tree_of_life_batch([ds[0], ds[1]])\n    assert batch[\"input_ids\"].shape[0] == 2\n    assert set(batch[\"level_targets\"].keys()) == {1, 2}\n    # Paths should be a list of node_path lists (wrapped in an extra list per example).\n    assert \"paths\" in batch\n    assert batch[\"paths\"][0] == [[0, 1, 3]]\n    assert batch[\"paths\"][1] == [[0, 2, 4]]\n\n\ndef test_tree_of_life_dataset_with_node_paths_multi(tmp_path: Path):\n    \"\"\"\n    Verify that when `node_paths` (multiple valid paths) is provided:\n      - the first path is used as canonical `level_targets`,\n      - all paths are preserved in the `paths` field for DAG-aware losses.\n    \"\"\"\n    spans_path = tmp_path / \"spans_multi.jsonl\"\n    records = [\n        {\n            \"span_id\": \"s1\",\n            \"text\": \"multi path span\",\n            \"node_paths\": [\n                [0, 1, 3],\n                [0, 1, 4],\n            ],\n        },\n    ]\n    with spans_path.open(\"w\", encoding=\"utf-8\") as f:\n        for rec in records:\n            f.write(json.dumps(rec) + \"\\n\")\n\n    class _DummyTokenizer:\n        def __init__(self):\n            self.vocab_size = 100\n            self.mask_token_id = 99\n\n        def get_special_tokens_mask(self, ids, already_has_special_tokens=True):\n            return [0] * len(ids)\n\n        def __call__(self, text, return_tensors, truncation, padding, max_length):\n            ids = list(range(1, min(len(text) + 1, max_length - 2)))\n            ids = ids + [0] * (max_length - len(ids))\n            input_ids = torch.tensor(ids, dtype=torch.long).unsqueeze(0)\n            attention_mask = (input_ids != 0).long()\n            return {\"input_ids\": input_ids, \"attention_mask\": attention_mask}\n\n    tokenizer = _DummyTokenizer()\n    ds = TreeOfLifeDataset(\n        spans_file=str(spans_path),\n        tokenizer=tokenizer,  # type: ignore[arg-type]\n        max_length=8,\n        mask_probability=0.15,\n    )\n\n    assert len(ds) == 1\n    sample = ds[0]\n    # Canonical targets come from the first path [0,1,3].\n    assert sample[\"level_targets\"][1] == 1\n    assert sample[\"level_targets\"][2] == 3\n    # All paths are preserved.\n    assert sample[\"paths\"] == [[0, 1, 3], [0, 1, 4]]\n\n\ndef test_eval_retrieval_helpers_basic():\n    \"\"\"\n    Sanity-check compute_relevance_mask, eval_retrieval, and\n    compute_branch_consistency_at_k on a tiny toy example.\n    \"\"\"\n    # Two index items, two queries.\n    index_embs = torch.eye(2, dtype=torch.float32)\n    query_embs = torch.eye(2, dtype=torch.float32)\n\n    # Paths: query 0 matches index 0 at level 1; query 1 matches index 1.\n    index_paths = [[0, 1], [0, 2]]\n    query_paths = [[0, 1], [0, 2]]\n\n    rel = eval_retrieval.compute_relevance_mask(\n        query_paths=query_paths,\n        index_paths=index_paths,\n        min_level=1,\n    )","source_hash":"569916a895377791b1ccb6b8d8f47469f70691ac8b88df7997708184227c5915","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:tests.test_data_and_metrics.test_eval_retrieval_helpers_basic","uri":"program://TOLBERT/function/tests.test_data_and_metrics.test_eval_retrieval_helpers_basic#L138-L177","kind":"function","name":"test_eval_retrieval_helpers_basic","path":"tests/test_data_and_metrics.py","language":"python","start_line":138,"end_line":177,"context_start_line":118,"context_end_line":179,"code":"            attention_mask = (input_ids != 0).long()\n            return {\"input_ids\": input_ids, \"attention_mask\": attention_mask}\n\n    tokenizer = _DummyTokenizer()\n    ds = TreeOfLifeDataset(\n        spans_file=str(spans_path),\n        tokenizer=tokenizer,  # type: ignore[arg-type]\n        max_length=8,\n        mask_probability=0.15,\n    )\n\n    assert len(ds) == 1\n    sample = ds[0]\n    # Canonical targets come from the first path [0,1,3].\n    assert sample[\"level_targets\"][1] == 1\n    assert sample[\"level_targets\"][2] == 3\n    # All paths are preserved.\n    assert sample[\"paths\"] == [[0, 1, 3], [0, 1, 4]]\n\n\ndef test_eval_retrieval_helpers_basic():\n    \"\"\"\n    Sanity-check compute_relevance_mask, eval_retrieval, and\n    compute_branch_consistency_at_k on a tiny toy example.\n    \"\"\"\n    # Two index items, two queries.\n    index_embs = torch.eye(2, dtype=torch.float32)\n    query_embs = torch.eye(2, dtype=torch.float32)\n\n    # Paths: query 0 matches index 0 at level 1; query 1 matches index 1.\n    index_paths = [[0, 1], [0, 2]]\n    query_paths = [[0, 1], [0, 2]]\n\n    rel = eval_retrieval.compute_relevance_mask(\n        query_paths=query_paths,\n        index_paths=index_paths,\n        min_level=1,\n    )\n    assert rel == [[True, False], [False, True]]\n\n    mrr, p_at_1 = eval_retrieval.eval_retrieval(\n        query_embs=query_embs,\n        index_embs=index_embs,\n        relevant=rel,\n        k=1,\n    )\n    # Each query retrieves its exact match at rank 1.\n    assert abs(mrr - 1.0) < 1e-6\n    assert abs(p_at_1 - 1.0) < 1e-6\n\n    bc = eval_retrieval.compute_branch_consistency_at_k(\n        query_embs=query_embs,\n        index_embs=index_embs,\n        query_paths=query_paths,\n        index_paths=index_paths,\n        k=1,\n    )\n    # At depth 1, all retrieved items share the same node as the query.\n    assert 1 in bc\n    assert abs(bc[1] - 1.0) < 1e-6\n\n","source_hash":"569916a895377791b1ccb6b8d8f47469f70691ac8b88df7997708184227c5915","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:tests.test_data_and_metrics._DummyTokenizer","uri":"program://TOLBERT/class/tests.test_data_and_metrics._DummyTokenizer#L106-L119","kind":"class","name":"_DummyTokenizer","path":"tests/test_data_and_metrics.py","language":"python","start_line":106,"end_line":119,"context_start_line":86,"context_end_line":139,"code":"    \"\"\"\n    Verify that when `node_paths` (multiple valid paths) is provided:\n      - the first path is used as canonical `level_targets`,\n      - all paths are preserved in the `paths` field for DAG-aware losses.\n    \"\"\"\n    spans_path = tmp_path / \"spans_multi.jsonl\"\n    records = [\n        {\n            \"span_id\": \"s1\",\n            \"text\": \"multi path span\",\n            \"node_paths\": [\n                [0, 1, 3],\n                [0, 1, 4],\n            ],\n        },\n    ]\n    with spans_path.open(\"w\", encoding=\"utf-8\") as f:\n        for rec in records:\n            f.write(json.dumps(rec) + \"\\n\")\n\n    class _DummyTokenizer:\n        def __init__(self):\n            self.vocab_size = 100\n            self.mask_token_id = 99\n\n        def get_special_tokens_mask(self, ids, already_has_special_tokens=True):\n            return [0] * len(ids)\n\n        def __call__(self, text, return_tensors, truncation, padding, max_length):\n            ids = list(range(1, min(len(text) + 1, max_length - 2)))\n            ids = ids + [0] * (max_length - len(ids))\n            input_ids = torch.tensor(ids, dtype=torch.long).unsqueeze(0)\n            attention_mask = (input_ids != 0).long()\n            return {\"input_ids\": input_ids, \"attention_mask\": attention_mask}\n\n    tokenizer = _DummyTokenizer()\n    ds = TreeOfLifeDataset(\n        spans_file=str(spans_path),\n        tokenizer=tokenizer,  # type: ignore[arg-type]\n        max_length=8,\n        mask_probability=0.15,\n    )\n\n    assert len(ds) == 1\n    sample = ds[0]\n    # Canonical targets come from the first path [0,1,3].\n    assert sample[\"level_targets\"][1] == 1\n    assert sample[\"level_targets\"][2] == 3\n    # All paths are preserved.\n    assert sample[\"paths\"] == [[0, 1, 3], [0, 1, 4]]\n\n\ndef test_eval_retrieval_helpers_basic():\n    \"\"\"","source_hash":"569916a895377791b1ccb6b8d8f47469f70691ac8b88df7997708184227c5915","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:tests.test_data_and_metrics.__init__","uri":"program://TOLBERT/function/tests.test_data_and_metrics.__init__#L107-L109","kind":"function","name":"__init__","path":"tests/test_data_and_metrics.py","language":"python","start_line":107,"end_line":109,"context_start_line":87,"context_end_line":129,"code":"    Verify that when `node_paths` (multiple valid paths) is provided:\n      - the first path is used as canonical `level_targets`,\n      - all paths are preserved in the `paths` field for DAG-aware losses.\n    \"\"\"\n    spans_path = tmp_path / \"spans_multi.jsonl\"\n    records = [\n        {\n            \"span_id\": \"s1\",\n            \"text\": \"multi path span\",\n            \"node_paths\": [\n                [0, 1, 3],\n                [0, 1, 4],\n            ],\n        },\n    ]\n    with spans_path.open(\"w\", encoding=\"utf-8\") as f:\n        for rec in records:\n            f.write(json.dumps(rec) + \"\\n\")\n\n    class _DummyTokenizer:\n        def __init__(self):\n            self.vocab_size = 100\n            self.mask_token_id = 99\n\n        def get_special_tokens_mask(self, ids, already_has_special_tokens=True):\n            return [0] * len(ids)\n\n        def __call__(self, text, return_tensors, truncation, padding, max_length):\n            ids = list(range(1, min(len(text) + 1, max_length - 2)))\n            ids = ids + [0] * (max_length - len(ids))\n            input_ids = torch.tensor(ids, dtype=torch.long).unsqueeze(0)\n            attention_mask = (input_ids != 0).long()\n            return {\"input_ids\": input_ids, \"attention_mask\": attention_mask}\n\n    tokenizer = _DummyTokenizer()\n    ds = TreeOfLifeDataset(\n        spans_file=str(spans_path),\n        tokenizer=tokenizer,  # type: ignore[arg-type]\n        max_length=8,\n        mask_probability=0.15,\n    )\n\n    assert len(ds) == 1","source_hash":"569916a895377791b1ccb6b8d8f47469f70691ac8b88df7997708184227c5915","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:tests.test_data_and_metrics.get_special_tokens_mask","uri":"program://TOLBERT/function/tests.test_data_and_metrics.get_special_tokens_mask#L111-L112","kind":"function","name":"get_special_tokens_mask","path":"tests/test_data_and_metrics.py","language":"python","start_line":111,"end_line":112,"context_start_line":91,"context_end_line":132,"code":"    spans_path = tmp_path / \"spans_multi.jsonl\"\n    records = [\n        {\n            \"span_id\": \"s1\",\n            \"text\": \"multi path span\",\n            \"node_paths\": [\n                [0, 1, 3],\n                [0, 1, 4],\n            ],\n        },\n    ]\n    with spans_path.open(\"w\", encoding=\"utf-8\") as f:\n        for rec in records:\n            f.write(json.dumps(rec) + \"\\n\")\n\n    class _DummyTokenizer:\n        def __init__(self):\n            self.vocab_size = 100\n            self.mask_token_id = 99\n\n        def get_special_tokens_mask(self, ids, already_has_special_tokens=True):\n            return [0] * len(ids)\n\n        def __call__(self, text, return_tensors, truncation, padding, max_length):\n            ids = list(range(1, min(len(text) + 1, max_length - 2)))\n            ids = ids + [0] * (max_length - len(ids))\n            input_ids = torch.tensor(ids, dtype=torch.long).unsqueeze(0)\n            attention_mask = (input_ids != 0).long()\n            return {\"input_ids\": input_ids, \"attention_mask\": attention_mask}\n\n    tokenizer = _DummyTokenizer()\n    ds = TreeOfLifeDataset(\n        spans_file=str(spans_path),\n        tokenizer=tokenizer,  # type: ignore[arg-type]\n        max_length=8,\n        mask_probability=0.15,\n    )\n\n    assert len(ds) == 1\n    sample = ds[0]\n    # Canonical targets come from the first path [0,1,3].\n    assert sample[\"level_targets\"][1] == 1","source_hash":"569916a895377791b1ccb6b8d8f47469f70691ac8b88df7997708184227c5915","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:tests.test_data_and_metrics.__call__","uri":"program://TOLBERT/function/tests.test_data_and_metrics.__call__#L114-L119","kind":"function","name":"__call__","path":"tests/test_data_and_metrics.py","language":"python","start_line":114,"end_line":119,"context_start_line":94,"context_end_line":139,"code":"            \"span_id\": \"s1\",\n            \"text\": \"multi path span\",\n            \"node_paths\": [\n                [0, 1, 3],\n                [0, 1, 4],\n            ],\n        },\n    ]\n    with spans_path.open(\"w\", encoding=\"utf-8\") as f:\n        for rec in records:\n            f.write(json.dumps(rec) + \"\\n\")\n\n    class _DummyTokenizer:\n        def __init__(self):\n            self.vocab_size = 100\n            self.mask_token_id = 99\n\n        def get_special_tokens_mask(self, ids, already_has_special_tokens=True):\n            return [0] * len(ids)\n\n        def __call__(self, text, return_tensors, truncation, padding, max_length):\n            ids = list(range(1, min(len(text) + 1, max_length - 2)))\n            ids = ids + [0] * (max_length - len(ids))\n            input_ids = torch.tensor(ids, dtype=torch.long).unsqueeze(0)\n            attention_mask = (input_ids != 0).long()\n            return {\"input_ids\": input_ids, \"attention_mask\": attention_mask}\n\n    tokenizer = _DummyTokenizer()\n    ds = TreeOfLifeDataset(\n        spans_file=str(spans_path),\n        tokenizer=tokenizer,  # type: ignore[arg-type]\n        max_length=8,\n        mask_probability=0.15,\n    )\n\n    assert len(ds) == 1\n    sample = ds[0]\n    # Canonical targets come from the first path [0,1,3].\n    assert sample[\"level_targets\"][1] == 1\n    assert sample[\"level_targets\"][2] == 3\n    # All paths are preserved.\n    assert sample[\"paths\"] == [[0, 1, 3], [0, 1, 4]]\n\n\ndef test_eval_retrieval_helpers_basic():\n    \"\"\"","source_hash":"569916a895377791b1ccb6b8d8f47469f70691ac8b88df7997708184227c5915","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:tests.test_builders","uri":"program://TOLBERT/module/tests.test_builders#L1-L273","kind":"module","name":"tests.test_builders","path":"tests/test_builders.py","language":"python","start_line":1,"end_line":273,"context_start_line":1,"context_end_line":273,"code":"import csv\nimport json\nfrom pathlib import Path\nimport sys\nfrom typing import Dict\n\n# Ensure project root is on sys.path so we import the local `scripts` package\n# instead of any third-party package named `scripts`.\nPROJECT_ROOT = Path(__file__).resolve().parents[1]\nif str(PROJECT_ROOT) not in sys.path:\n    sys.path.insert(0, str(PROJECT_ROOT))\n\nfrom scripts import (\n    build_wos_spans,\n    build_researchhierarchy_spans,\n    build_codehierarchy_spans,\n    build_joint_code_paper_tol,\n)\n\n\ndef test_build_wos_spans_helpers(tmp_path: Path):\n    \"\"\"\n    Smoke test for build_wos_spans:\n      - load_wos_csv parses a small CSV,\n      - build_ontology assigns ids at each level,\n      - build_spans produces node_path with expected structure.\n    \"\"\"\n    csv_path = tmp_path / \"wos_small.csv\"\n    with csv_path.open(\"w\", encoding=\"utf-8\", newline=\"\") as f:\n        writer = csv.DictWriter(f, fieldnames=[\"text\", \"level1\", \"level2\", \"level3\"])\n        writer.writeheader()\n        writer.writerow(\n            {\n                \"text\": \"doc about machine learning\",\n                \"level1\": \"Computer Science\",\n                \"level2\": \"Artificial Intelligence\",\n                \"level3\": \"Machine Learning\",\n            }\n        )\n        writer.writerow(\n            {\n                \"text\": \"doc about physics\",\n                \"level1\": \"Physics\",\n                \"level2\": \"Quantum\",\n                \"level3\": \"Quantum Mechanics\",\n            }\n        )\n\n    rows = build_wos_spans.load_wos_csv(\n        path=csv_path,\n        text_col=\"text\",\n        l1_col=\"level1\",\n        l2_col=\"level2\",\n        l3_col=\"level3\",\n    )\n    assert len(rows) == 2\n\n    l1_ids, l2_ids, l3_ids = build_wos_spans.build_ontology(rows)\n    assert len(l1_ids) == 2\n    assert len(l2_ids) == 2\n    assert len(l3_ids) == 2\n\n    spans = build_wos_spans.build_spans(rows, l1_ids, l2_ids, l3_ids)\n    assert len(spans) == 2\n    for rec in spans:\n        path = rec[\"node_path\"]\n        # Root + three levels if all labels are present.\n        assert isinstance(path, list)\n        assert len(path) == 4\n        assert path[0] == 0\n\n\ndef test_build_researchhierarchy_spans_helpers(tmp_path: Path):\n    \"\"\"\n    Smoke test for build_researchhierarchy_spans helpers:\n      - load_metadata parses a small CSV,\n      - build_ontology assigns ids,\n      - build_span_records produces the expected node_path layout.\n    \"\"\"\n    csv_path = tmp_path / \"research_small.csv\"\n    with csv_path.open(\"w\", encoding=\"utf-8\", newline=\"\") as f:\n        writer = csv.DictWriter(\n            f,\n            fieldnames=[\"doc_id\", \"field\", \"subfield\", \"discipline\", \"text\"],\n        )\n        writer.writeheader()\n        writer.writerow(\n            {\n                \"doc_id\": \"D1\",\n                \"field\": \"Computer Science\",\n                \"subfield\": \"AI\",\n                \"discipline\": \"ML\",\n                \"text\": \"title and abstract about ML\",\n            }\n        )\n\n    metas = build_researchhierarchy_spans.load_metadata(\n        path=csv_path,\n        id_col=\"doc_id\",\n        field_col=\"field\",\n        subfield_col=\"subfield\",\n        discipline_col=\"discipline\",\n        text_col=\"text\",\n        pdf_path_col=None,\n        source_col=None,\n    )\n    assert len(metas) == 1\n\n    field_ids, subfield_ids, discipline_ids = build_researchhierarchy_spans.build_ontology(\n        metas\n    )\n    assert len(field_ids) == 1\n    assert len(subfield_ids) == 1\n    assert len(discipline_ids) == 1\n\n    spans = build_researchhierarchy_spans.build_span_records(\n        metas, field_ids, subfield_ids, discipline_ids\n    )\n    assert len(spans) == 1\n    rec = spans[0]\n    path = rec[\"node_path\"]\n    assert isinstance(path, list)\n    # root + field + subfield + discipline\n    assert len(path) == 4\n    assert path[0] == 0\n\n\ndef test_build_codehierarchy_spans_helpers(tmp_path: Path):\n    \"\"\"\n    Smoke test for build_codehierarchy_spans helpers:\n      - load_metadata parses a small metadata file,\n      - build_ontology assigns ids for languages, categories, repos,\n      - build_span_records produces spans with expected node_path layout.\n    \"\"\"\n    # Create a fake repos_root with two repos and one file each.\n    repos_root = tmp_path / \"repos\"\n    repo1 = repos_root / \"repo1\"\n    repo2 = repos_root / \"repo2\"\n    repo1.mkdir(parents=True)\n    repo2.mkdir(parents=True)\n    (repo1 / \"file1.py\").write_text(\"print('hello')\\n\", encoding=\"utf-8\")\n    (repo2 / \"file2.cpp\").write_text(\"int main() { return 0; }\\n\", encoding=\"utf-8\")\n\n    meta_path = tmp_path / \"meta.csv\"\n    with meta_path.open(\"w\", encoding=\"utf-8\", newline=\"\") as f:\n        writer = csv.DictWriter(f, fieldnames=[\"repo_name\", \"language\", \"category\"])\n        writer.writeheader()\n        writer.writerow({\"repo_name\": \"repo1\", \"language\": \"Python\", \"category\": \"ML\"})\n        writer.writerow({\"repo_name\": \"repo2\", \"language\": \"C++\", \"category\": \"Systems\"})\n\n    metas = build_codehierarchy_spans.load_metadata(meta_path)\n    assert len(metas) == 2\n\n    lang_ids, cat_ids, repo_ids = build_codehierarchy_spans.build_ontology(metas)\n    assert len(lang_ids) == 2\n    assert len(cat_ids) == 2\n    assert len(repo_ids) == 2\n\n    spans = build_codehierarchy_spans.build_span_records(\n        repos_root=repos_root,\n        metas=metas,\n        lang_ids=lang_ids,\n        cat_ids=cat_ids,\n        repo_ids=repo_ids,\n    )\n    # One span per file.\n    assert len(spans) == 2\n    for rec in spans:\n        path = rec[\"node_path\"]\n        assert isinstance(path, list)\n        # root + language + category + repo\n        assert len(path) == 4\n        assert path[0] == 0\n\n\ndef test_build_joint_code_paper_tol_helpers(tmp_path: Path):\n    \"\"\"\n    Smoke test for build_joint_code_paper_tol core helpers:\n      - _build_joint_ontology merges two small ontologies,\n      - _rewrite_spans remaps node_path ids into the joint space,\n      - _write_level_sizes produces a dict[level -> count] excluding root.\n    \"\"\"\n    # Build minimal code and paper nodes.jsonl\n    code_nodes_path = tmp_path / \"code_nodes.jsonl\"\n    paper_nodes_path = tmp_path / \"paper_nodes.jsonl\"\n\n    def _write_nodes(path: Path, levels: Dict[int, int]) -> None:\n        with path.open(\"w\", encoding=\"utf-8\") as f:\n            # local root\n            f.write(\n                json.dumps(\n                    {\n                        \"node_id\": 0,\n                        \"level\": 0,\n                        \"type\": \"root\",\n                        \"parent_id\": None,\n                        \"name\": \"Root\",\n                        \"attributes\": {},\n                    }\n                )\n                + \"\\n\"\n            )\n            nid = 1\n            for lvl, count in levels.items():\n                for i in range(count):\n                    parent_id = 0 if lvl == 1 else nid - 1\n                    f.write(\n                        json.dumps(\n                            {\n                                \"node_id\": nid,\n                                \"level\": lvl,\n                                \"type\": f\"lvl{lvl}\",\n                                \"parent_id\": parent_id,\n                                \"name\": f\"n{lvl}_{i}\",\n                                \"attributes\": {},\n                            }\n                        )\n                        + \"\\n\"\n                    )\n                    nid += 1\n\n    _write_nodes(code_nodes_path, {1: 1, 2: 1})\n    _write_nodes(paper_nodes_path, {1: 1, 2: 1})\n\n    code_nodes = build_joint_code_paper_tol._load_nodes(code_nodes_path)\n    paper_nodes = build_joint_code_paper_tol._load_nodes(paper_nodes_path)\n\n    joint_nodes, code_map, paper_map, level_counts = build_joint_code_paper_tol._build_joint_ontology(\n        code_nodes=code_nodes,\n        paper_nodes=paper_nodes,\n        code_domain_name=\"Code\",\n        paper_domain_name=\"Papers\",\n    )\n    # Root + 2 domain nodes + remapped nodes from both ontologies.\n    assert 0 in joint_nodes\n    assert level_counts[1] == 2  # Code, Papers\n    # There should be some nodes at deeper levels.\n    assert any(lvl > 1 for lvl in level_counts.keys())\n    assert code_map and paper_map\n\n    # Create minimal spans that refer to old node ids and ensure they get remapped.\n    code_spans_path = tmp_path / \"code_spans.jsonl\"\n    paper_spans_path = tmp_path / \"paper_spans.jsonl\"\n    with code_spans_path.open(\"w\", encoding=\"utf-8\") as f:\n        f.write(json.dumps({\"span_id\": \"c1\", \"text\": \"code\", \"node_path\": [0, 1, 2]}) + \"\\n\")\n    with paper_spans_path.open(\"w\", encoding=\"utf-8\") as f:\n        f.write(json.dumps({\"span_id\": \"p1\", \"text\": \"paper\", \"node_path\": [0, 1, 2]}) + \"\\n\")\n\n    # Use internal helpers directly.\n    code_domain_id = 1  # first domain under root in joint ontology\n    paper_domain_id = 2  # second domain\n    remapped_code_spans = build_joint_code_paper_tol._rewrite_spans(\n        code_spans_path, domain_node_id=code_domain_id, id_map=code_map\n    )\n    remapped_paper_spans = build_joint_code_paper_tol._rewrite_spans(\n        paper_spans_path, domain_node_id=paper_domain_id, id_map=paper_map\n    )\n\n    assert remapped_code_spans[0][\"node_path\"][0] == 0\n    assert remapped_code_spans[0][\"node_path\"][1] == code_domain_id\n    assert remapped_paper_spans[0][\"node_path\"][0] == 0\n    assert remapped_paper_spans[0][\"node_path\"][1] == paper_domain_id\n\n    # Check level_sizes writing.\n    level_sizes_path = tmp_path / \"level_sizes.json\"\n    build_joint_code_paper_tol._write_level_sizes(level_counts, level_sizes_path)\n    contents = json.loads(level_sizes_path.read_text(encoding=\"utf-8\"))\n    assert \"level_sizes\" in contents\n    # Root (0) should not be present.\n    assert 0 not in contents[\"level_sizes\"]\n\n\n","source_hash":"e54370468bc4cb2c6f68bf01d13939be270b9fbc84b4bb8e4b6b0cc0d67ddfc4","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:tests.test_builders.test_build_wos_spans_helpers","uri":"program://TOLBERT/function/tests.test_builders.test_build_wos_spans_helpers#L21-L70","kind":"function","name":"test_build_wos_spans_helpers","path":"tests/test_builders.py","language":"python","start_line":21,"end_line":70,"context_start_line":1,"context_end_line":90,"code":"import csv\nimport json\nfrom pathlib import Path\nimport sys\nfrom typing import Dict\n\n# Ensure project root is on sys.path so we import the local `scripts` package\n# instead of any third-party package named `scripts`.\nPROJECT_ROOT = Path(__file__).resolve().parents[1]\nif str(PROJECT_ROOT) not in sys.path:\n    sys.path.insert(0, str(PROJECT_ROOT))\n\nfrom scripts import (\n    build_wos_spans,\n    build_researchhierarchy_spans,\n    build_codehierarchy_spans,\n    build_joint_code_paper_tol,\n)\n\n\ndef test_build_wos_spans_helpers(tmp_path: Path):\n    \"\"\"\n    Smoke test for build_wos_spans:\n      - load_wos_csv parses a small CSV,\n      - build_ontology assigns ids at each level,\n      - build_spans produces node_path with expected structure.\n    \"\"\"\n    csv_path = tmp_path / \"wos_small.csv\"\n    with csv_path.open(\"w\", encoding=\"utf-8\", newline=\"\") as f:\n        writer = csv.DictWriter(f, fieldnames=[\"text\", \"level1\", \"level2\", \"level3\"])\n        writer.writeheader()\n        writer.writerow(\n            {\n                \"text\": \"doc about machine learning\",\n                \"level1\": \"Computer Science\",\n                \"level2\": \"Artificial Intelligence\",\n                \"level3\": \"Machine Learning\",\n            }\n        )\n        writer.writerow(\n            {\n                \"text\": \"doc about physics\",\n                \"level1\": \"Physics\",\n                \"level2\": \"Quantum\",\n                \"level3\": \"Quantum Mechanics\",\n            }\n        )\n\n    rows = build_wos_spans.load_wos_csv(\n        path=csv_path,\n        text_col=\"text\",\n        l1_col=\"level1\",\n        l2_col=\"level2\",\n        l3_col=\"level3\",\n    )\n    assert len(rows) == 2\n\n    l1_ids, l2_ids, l3_ids = build_wos_spans.build_ontology(rows)\n    assert len(l1_ids) == 2\n    assert len(l2_ids) == 2\n    assert len(l3_ids) == 2\n\n    spans = build_wos_spans.build_spans(rows, l1_ids, l2_ids, l3_ids)\n    assert len(spans) == 2\n    for rec in spans:\n        path = rec[\"node_path\"]\n        # Root + three levels if all labels are present.\n        assert isinstance(path, list)\n        assert len(path) == 4\n        assert path[0] == 0\n\n\ndef test_build_researchhierarchy_spans_helpers(tmp_path: Path):\n    \"\"\"\n    Smoke test for build_researchhierarchy_spans helpers:\n      - load_metadata parses a small CSV,\n      - build_ontology assigns ids,\n      - build_span_records produces the expected node_path layout.\n    \"\"\"\n    csv_path = tmp_path / \"research_small.csv\"\n    with csv_path.open(\"w\", encoding=\"utf-8\", newline=\"\") as f:\n        writer = csv.DictWriter(\n            f,\n            fieldnames=[\"doc_id\", \"field\", \"subfield\", \"discipline\", \"text\"],\n        )\n        writer.writeheader()\n        writer.writerow(\n            {\n                \"doc_id\": \"D1\",\n                \"field\": \"Computer Science\",","source_hash":"e54370468bc4cb2c6f68bf01d13939be270b9fbc84b4bb8e4b6b0cc0d67ddfc4","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:tests.test_builders.test_build_researchhierarchy_spans_helpers","uri":"program://TOLBERT/function/tests.test_builders.test_build_researchhierarchy_spans_helpers#L73-L125","kind":"function","name":"test_build_researchhierarchy_spans_helpers","path":"tests/test_builders.py","language":"python","start_line":73,"end_line":125,"context_start_line":53,"context_end_line":145,"code":"        l2_col=\"level2\",\n        l3_col=\"level3\",\n    )\n    assert len(rows) == 2\n\n    l1_ids, l2_ids, l3_ids = build_wos_spans.build_ontology(rows)\n    assert len(l1_ids) == 2\n    assert len(l2_ids) == 2\n    assert len(l3_ids) == 2\n\n    spans = build_wos_spans.build_spans(rows, l1_ids, l2_ids, l3_ids)\n    assert len(spans) == 2\n    for rec in spans:\n        path = rec[\"node_path\"]\n        # Root + three levels if all labels are present.\n        assert isinstance(path, list)\n        assert len(path) == 4\n        assert path[0] == 0\n\n\ndef test_build_researchhierarchy_spans_helpers(tmp_path: Path):\n    \"\"\"\n    Smoke test for build_researchhierarchy_spans helpers:\n      - load_metadata parses a small CSV,\n      - build_ontology assigns ids,\n      - build_span_records produces the expected node_path layout.\n    \"\"\"\n    csv_path = tmp_path / \"research_small.csv\"\n    with csv_path.open(\"w\", encoding=\"utf-8\", newline=\"\") as f:\n        writer = csv.DictWriter(\n            f,\n            fieldnames=[\"doc_id\", \"field\", \"subfield\", \"discipline\", \"text\"],\n        )\n        writer.writeheader()\n        writer.writerow(\n            {\n                \"doc_id\": \"D1\",\n                \"field\": \"Computer Science\",\n                \"subfield\": \"AI\",\n                \"discipline\": \"ML\",\n                \"text\": \"title and abstract about ML\",\n            }\n        )\n\n    metas = build_researchhierarchy_spans.load_metadata(\n        path=csv_path,\n        id_col=\"doc_id\",\n        field_col=\"field\",\n        subfield_col=\"subfield\",\n        discipline_col=\"discipline\",\n        text_col=\"text\",\n        pdf_path_col=None,\n        source_col=None,\n    )\n    assert len(metas) == 1\n\n    field_ids, subfield_ids, discipline_ids = build_researchhierarchy_spans.build_ontology(\n        metas\n    )\n    assert len(field_ids) == 1\n    assert len(subfield_ids) == 1\n    assert len(discipline_ids) == 1\n\n    spans = build_researchhierarchy_spans.build_span_records(\n        metas, field_ids, subfield_ids, discipline_ids\n    )\n    assert len(spans) == 1\n    rec = spans[0]\n    path = rec[\"node_path\"]\n    assert isinstance(path, list)\n    # root + field + subfield + discipline\n    assert len(path) == 4\n    assert path[0] == 0\n\n\ndef test_build_codehierarchy_spans_helpers(tmp_path: Path):\n    \"\"\"\n    Smoke test for build_codehierarchy_spans helpers:\n      - load_metadata parses a small metadata file,\n      - build_ontology assigns ids for languages, categories, repos,\n      - build_span_records produces spans with expected node_path layout.\n    \"\"\"\n    # Create a fake repos_root with two repos and one file each.\n    repos_root = tmp_path / \"repos\"\n    repo1 = repos_root / \"repo1\"\n    repo2 = repos_root / \"repo2\"\n    repo1.mkdir(parents=True)\n    repo2.mkdir(parents=True)\n    (repo1 / \"file1.py\").write_text(\"print('hello')\\n\", encoding=\"utf-8\")\n    (repo2 / \"file2.cpp\").write_text(\"int main() { return 0; }\\n\", encoding=\"utf-8\")\n\n    meta_path = tmp_path / \"meta.csv\"\n    with meta_path.open(\"w\", encoding=\"utf-8\", newline=\"\") as f:","source_hash":"e54370468bc4cb2c6f68bf01d13939be270b9fbc84b4bb8e4b6b0cc0d67ddfc4","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:tests.test_builders.test_build_codehierarchy_spans_helpers","uri":"program://TOLBERT/function/tests.test_builders.test_build_codehierarchy_spans_helpers#L128-L173","kind":"function","name":"test_build_codehierarchy_spans_helpers","path":"tests/test_builders.py","language":"python","start_line":128,"end_line":173,"context_start_line":108,"context_end_line":193,"code":"\n    field_ids, subfield_ids, discipline_ids = build_researchhierarchy_spans.build_ontology(\n        metas\n    )\n    assert len(field_ids) == 1\n    assert len(subfield_ids) == 1\n    assert len(discipline_ids) == 1\n\n    spans = build_researchhierarchy_spans.build_span_records(\n        metas, field_ids, subfield_ids, discipline_ids\n    )\n    assert len(spans) == 1\n    rec = spans[0]\n    path = rec[\"node_path\"]\n    assert isinstance(path, list)\n    # root + field + subfield + discipline\n    assert len(path) == 4\n    assert path[0] == 0\n\n\ndef test_build_codehierarchy_spans_helpers(tmp_path: Path):\n    \"\"\"\n    Smoke test for build_codehierarchy_spans helpers:\n      - load_metadata parses a small metadata file,\n      - build_ontology assigns ids for languages, categories, repos,\n      - build_span_records produces spans with expected node_path layout.\n    \"\"\"\n    # Create a fake repos_root with two repos and one file each.\n    repos_root = tmp_path / \"repos\"\n    repo1 = repos_root / \"repo1\"\n    repo2 = repos_root / \"repo2\"\n    repo1.mkdir(parents=True)\n    repo2.mkdir(parents=True)\n    (repo1 / \"file1.py\").write_text(\"print('hello')\\n\", encoding=\"utf-8\")\n    (repo2 / \"file2.cpp\").write_text(\"int main() { return 0; }\\n\", encoding=\"utf-8\")\n\n    meta_path = tmp_path / \"meta.csv\"\n    with meta_path.open(\"w\", encoding=\"utf-8\", newline=\"\") as f:\n        writer = csv.DictWriter(f, fieldnames=[\"repo_name\", \"language\", \"category\"])\n        writer.writeheader()\n        writer.writerow({\"repo_name\": \"repo1\", \"language\": \"Python\", \"category\": \"ML\"})\n        writer.writerow({\"repo_name\": \"repo2\", \"language\": \"C++\", \"category\": \"Systems\"})\n\n    metas = build_codehierarchy_spans.load_metadata(meta_path)\n    assert len(metas) == 2\n\n    lang_ids, cat_ids, repo_ids = build_codehierarchy_spans.build_ontology(metas)\n    assert len(lang_ids) == 2\n    assert len(cat_ids) == 2\n    assert len(repo_ids) == 2\n\n    spans = build_codehierarchy_spans.build_span_records(\n        repos_root=repos_root,\n        metas=metas,\n        lang_ids=lang_ids,\n        cat_ids=cat_ids,\n        repo_ids=repo_ids,\n    )\n    # One span per file.\n    assert len(spans) == 2\n    for rec in spans:\n        path = rec[\"node_path\"]\n        assert isinstance(path, list)\n        # root + language + category + repo\n        assert len(path) == 4\n        assert path[0] == 0\n\n\ndef test_build_joint_code_paper_tol_helpers(tmp_path: Path):\n    \"\"\"\n    Smoke test for build_joint_code_paper_tol core helpers:\n      - _build_joint_ontology merges two small ontologies,\n      - _rewrite_spans remaps node_path ids into the joint space,\n      - _write_level_sizes produces a dict[level -> count] excluding root.\n    \"\"\"\n    # Build minimal code and paper nodes.jsonl\n    code_nodes_path = tmp_path / \"code_nodes.jsonl\"\n    paper_nodes_path = tmp_path / \"paper_nodes.jsonl\"\n\n    def _write_nodes(path: Path, levels: Dict[int, int]) -> None:\n        with path.open(\"w\", encoding=\"utf-8\") as f:\n            # local root\n            f.write(\n                json.dumps(\n                    {\n                        \"node_id\": 0,","source_hash":"e54370468bc4cb2c6f68bf01d13939be270b9fbc84b4bb8e4b6b0cc0d67ddfc4","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:tests.test_builders.test_build_joint_code_paper_tol_helpers","uri":"program://TOLBERT/function/tests.test_builders.test_build_joint_code_paper_tol_helpers#L176-L270","kind":"function","name":"test_build_joint_code_paper_tol_helpers","path":"tests/test_builders.py","language":"python","start_line":176,"end_line":270,"context_start_line":156,"context_end_line":273,"code":"    assert len(cat_ids) == 2\n    assert len(repo_ids) == 2\n\n    spans = build_codehierarchy_spans.build_span_records(\n        repos_root=repos_root,\n        metas=metas,\n        lang_ids=lang_ids,\n        cat_ids=cat_ids,\n        repo_ids=repo_ids,\n    )\n    # One span per file.\n    assert len(spans) == 2\n    for rec in spans:\n        path = rec[\"node_path\"]\n        assert isinstance(path, list)\n        # root + language + category + repo\n        assert len(path) == 4\n        assert path[0] == 0\n\n\ndef test_build_joint_code_paper_tol_helpers(tmp_path: Path):\n    \"\"\"\n    Smoke test for build_joint_code_paper_tol core helpers:\n      - _build_joint_ontology merges two small ontologies,\n      - _rewrite_spans remaps node_path ids into the joint space,\n      - _write_level_sizes produces a dict[level -> count] excluding root.\n    \"\"\"\n    # Build minimal code and paper nodes.jsonl\n    code_nodes_path = tmp_path / \"code_nodes.jsonl\"\n    paper_nodes_path = tmp_path / \"paper_nodes.jsonl\"\n\n    def _write_nodes(path: Path, levels: Dict[int, int]) -> None:\n        with path.open(\"w\", encoding=\"utf-8\") as f:\n            # local root\n            f.write(\n                json.dumps(\n                    {\n                        \"node_id\": 0,\n                        \"level\": 0,\n                        \"type\": \"root\",\n                        \"parent_id\": None,\n                        \"name\": \"Root\",\n                        \"attributes\": {},\n                    }\n                )\n                + \"\\n\"\n            )\n            nid = 1\n            for lvl, count in levels.items():\n                for i in range(count):\n                    parent_id = 0 if lvl == 1 else nid - 1\n                    f.write(\n                        json.dumps(\n                            {\n                                \"node_id\": nid,\n                                \"level\": lvl,\n                                \"type\": f\"lvl{lvl}\",\n                                \"parent_id\": parent_id,\n                                \"name\": f\"n{lvl}_{i}\",\n                                \"attributes\": {},\n                            }\n                        )\n                        + \"\\n\"\n                    )\n                    nid += 1\n\n    _write_nodes(code_nodes_path, {1: 1, 2: 1})\n    _write_nodes(paper_nodes_path, {1: 1, 2: 1})\n\n    code_nodes = build_joint_code_paper_tol._load_nodes(code_nodes_path)\n    paper_nodes = build_joint_code_paper_tol._load_nodes(paper_nodes_path)\n\n    joint_nodes, code_map, paper_map, level_counts = build_joint_code_paper_tol._build_joint_ontology(\n        code_nodes=code_nodes,\n        paper_nodes=paper_nodes,\n        code_domain_name=\"Code\",\n        paper_domain_name=\"Papers\",\n    )\n    # Root + 2 domain nodes + remapped nodes from both ontologies.\n    assert 0 in joint_nodes\n    assert level_counts[1] == 2  # Code, Papers\n    # There should be some nodes at deeper levels.\n    assert any(lvl > 1 for lvl in level_counts.keys())\n    assert code_map and paper_map\n\n    # Create minimal spans that refer to old node ids and ensure they get remapped.\n    code_spans_path = tmp_path / \"code_spans.jsonl\"\n    paper_spans_path = tmp_path / \"paper_spans.jsonl\"\n    with code_spans_path.open(\"w\", encoding=\"utf-8\") as f:\n        f.write(json.dumps({\"span_id\": \"c1\", \"text\": \"code\", \"node_path\": [0, 1, 2]}) + \"\\n\")\n    with paper_spans_path.open(\"w\", encoding=\"utf-8\") as f:\n        f.write(json.dumps({\"span_id\": \"p1\", \"text\": \"paper\", \"node_path\": [0, 1, 2]}) + \"\\n\")\n\n    # Use internal helpers directly.\n    code_domain_id = 1  # first domain under root in joint ontology\n    paper_domain_id = 2  # second domain\n    remapped_code_spans = build_joint_code_paper_tol._rewrite_spans(\n        code_spans_path, domain_node_id=code_domain_id, id_map=code_map\n    )\n    remapped_paper_spans = build_joint_code_paper_tol._rewrite_spans(\n        paper_spans_path, domain_node_id=paper_domain_id, id_map=paper_map\n    )\n\n    assert remapped_code_spans[0][\"node_path\"][0] == 0\n    assert remapped_code_spans[0][\"node_path\"][1] == code_domain_id\n    assert remapped_paper_spans[0][\"node_path\"][0] == 0\n    assert remapped_paper_spans[0][\"node_path\"][1] == paper_domain_id\n\n    # Check level_sizes writing.\n    level_sizes_path = tmp_path / \"level_sizes.json\"\n    build_joint_code_paper_tol._write_level_sizes(level_counts, level_sizes_path)\n    contents = json.loads(level_sizes_path.read_text(encoding=\"utf-8\"))\n    assert \"level_sizes\" in contents\n    # Root (0) should not be present.\n    assert 0 not in contents[\"level_sizes\"]\n\n\n","source_hash":"e54370468bc4cb2c6f68bf01d13939be270b9fbc84b4bb8e4b6b0cc0d67ddfc4","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:tests.test_builders._write_nodes","uri":"program://TOLBERT/function/tests.test_builders._write_nodes#L187-L220","kind":"function","name":"_write_nodes","path":"tests/test_builders.py","language":"python","start_line":187,"end_line":220,"context_start_line":167,"context_end_line":240,"code":"    assert len(spans) == 2\n    for rec in spans:\n        path = rec[\"node_path\"]\n        assert isinstance(path, list)\n        # root + language + category + repo\n        assert len(path) == 4\n        assert path[0] == 0\n\n\ndef test_build_joint_code_paper_tol_helpers(tmp_path: Path):\n    \"\"\"\n    Smoke test for build_joint_code_paper_tol core helpers:\n      - _build_joint_ontology merges two small ontologies,\n      - _rewrite_spans remaps node_path ids into the joint space,\n      - _write_level_sizes produces a dict[level -> count] excluding root.\n    \"\"\"\n    # Build minimal code and paper nodes.jsonl\n    code_nodes_path = tmp_path / \"code_nodes.jsonl\"\n    paper_nodes_path = tmp_path / \"paper_nodes.jsonl\"\n\n    def _write_nodes(path: Path, levels: Dict[int, int]) -> None:\n        with path.open(\"w\", encoding=\"utf-8\") as f:\n            # local root\n            f.write(\n                json.dumps(\n                    {\n                        \"node_id\": 0,\n                        \"level\": 0,\n                        \"type\": \"root\",\n                        \"parent_id\": None,\n                        \"name\": \"Root\",\n                        \"attributes\": {},\n                    }\n                )\n                + \"\\n\"\n            )\n            nid = 1\n            for lvl, count in levels.items():\n                for i in range(count):\n                    parent_id = 0 if lvl == 1 else nid - 1\n                    f.write(\n                        json.dumps(\n                            {\n                                \"node_id\": nid,\n                                \"level\": lvl,\n                                \"type\": f\"lvl{lvl}\",\n                                \"parent_id\": parent_id,\n                                \"name\": f\"n{lvl}_{i}\",\n                                \"attributes\": {},\n                            }\n                        )\n                        + \"\\n\"\n                    )\n                    nid += 1\n\n    _write_nodes(code_nodes_path, {1: 1, 2: 1})\n    _write_nodes(paper_nodes_path, {1: 1, 2: 1})\n\n    code_nodes = build_joint_code_paper_tol._load_nodes(code_nodes_path)\n    paper_nodes = build_joint_code_paper_tol._load_nodes(paper_nodes_path)\n\n    joint_nodes, code_map, paper_map, level_counts = build_joint_code_paper_tol._build_joint_ontology(\n        code_nodes=code_nodes,\n        paper_nodes=paper_nodes,\n        code_domain_name=\"Code\",\n        paper_domain_name=\"Papers\",\n    )\n    # Root + 2 domain nodes + remapped nodes from both ontologies.\n    assert 0 in joint_nodes\n    assert level_counts[1] == 2  # Code, Papers\n    # There should be some nodes at deeper levels.\n    assert any(lvl > 1 for lvl in level_counts.keys())\n    assert code_map and paper_map\n","source_hash":"e54370468bc4cb2c6f68bf01d13939be270b9fbc84b4bb8e4b6b0cc0d67ddfc4","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:tests.test_losses_and_decoding","uri":"program://TOLBERT/module/tests.test_losses_and_decoding#L1-L83","kind":"module","name":"tests.test_losses_and_decoding","path":"tests/test_losses_and_decoding.py","language":"python","start_line":1,"end_line":83,"context_start_line":1,"context_end_line":83,"code":"import torch\nfrom pathlib import Path\nimport sys\n\n# Ensure project root is on sys.path so `tolbert` imports resolve consistently.\nPROJECT_ROOT = Path(__file__).resolve().parents[1]\nif str(PROJECT_ROOT) not in sys.path:\n    sys.path.insert(0, str(PROJECT_ROOT))\n\nfrom tolbert import losses\nfrom tolbert import decoding\n\n\ndef test_tree_contrastive_loss_zero_when_no_shared_ancestors():\n    \"\"\"\n    If no pairs share any non-root ancestor, the contrastive loss should be 0.\n    \"\"\"\n    emb = torch.randn(3, 8)\n    # All paths differ immediately after root.\n    paths = [\n        [0, 1],\n        [0, 2],\n        [0, 3],\n    ]\n    loss = losses.tree_contrastive_loss(emb, paths, temperature=0.1)\n    assert torch.isclose(loss, torch.tensor(0.0), atol=1e-6)\n\n\ndef test_tree_contrastive_loss_positive_with_shared_depth():\n    \"\"\"\n    When some pairs share deeper ancestors, the loss should be strictly positive.\n    \"\"\"\n    # Make embeddings small and deterministic for stability.\n    emb = torch.eye(4, dtype=torch.float32)\n    # First three share the same label at depth 1; last one is in a different branch.\n    paths = [\n        [0, 1],\n        [0, 1],\n        [0, 1],\n        [0, 2],\n    ]\n    loss = losses.tree_contrastive_loss(emb, paths, temperature=0.1)\n    # Loss should be finite and non-negative.\n    assert torch.isfinite(loss)\n    assert loss.item() >= 0.0\n\n\ndef test_greedy_hierarchical_decode_respects_parent_child_mapping():\n    \"\"\"\n    Ensure that greedy_hierarchical_decode:\n      - performs unconstrained argmax at the first level,\n      - then restricts the next level to children of the chosen parent.\n    \"\"\"\n    batch_size = 1\n\n    # Level 1: two parents, prefer index 1.\n    l1_logits = torch.tensor([[0.0, 5.0]])  # (1, 2)\n    # Level 2: three children; unconstrained argmax would pick index 2.\n    l2_logits = torch.tensor([[10.0, 0.0, 1.0]])  # (1, 3)\n\n    level_logits = {\"1\": l1_logits, \"2\": l2_logits}\n\n    # Parent-to-children mapping: at level 2, parent 1 can only choose child 0.\n    parent_to_children = {\n        2: {\n            0: [1, 2],\n            1: [0],\n        }\n    }\n\n    preds = decoding.greedy_hierarchical_decode(\n        level_logits=level_logits,\n        parent_to_children=parent_to_children,\n        levels=[1, 2],\n    )\n\n    # Level 1: picks parent 1.\n    assert preds[1].tolist() == [1]\n    # Level 2: must choose from children of parent 1, i.e., [0]; so prediction is 0,\n    # even though the global argmax of l2 logits is index 2.\n    assert preds[2].tolist() == [0]\n\n","source_hash":"8e425f43a898b67c4ce378a22847e7602bf39402d30194c89309b62c2fa08b98","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:tests.test_losses_and_decoding.test_tree_contrastive_loss_zero_when_no_shared_ancestors","uri":"program://TOLBERT/function/tests.test_losses_and_decoding.test_tree_contrastive_loss_zero_when_no_shared_ancestors#L14-L26","kind":"function","name":"test_tree_contrastive_loss_zero_when_no_shared_ancestors","path":"tests/test_losses_and_decoding.py","language":"python","start_line":14,"end_line":26,"context_start_line":1,"context_end_line":46,"code":"import torch\nfrom pathlib import Path\nimport sys\n\n# Ensure project root is on sys.path so `tolbert` imports resolve consistently.\nPROJECT_ROOT = Path(__file__).resolve().parents[1]\nif str(PROJECT_ROOT) not in sys.path:\n    sys.path.insert(0, str(PROJECT_ROOT))\n\nfrom tolbert import losses\nfrom tolbert import decoding\n\n\ndef test_tree_contrastive_loss_zero_when_no_shared_ancestors():\n    \"\"\"\n    If no pairs share any non-root ancestor, the contrastive loss should be 0.\n    \"\"\"\n    emb = torch.randn(3, 8)\n    # All paths differ immediately after root.\n    paths = [\n        [0, 1],\n        [0, 2],\n        [0, 3],\n    ]\n    loss = losses.tree_contrastive_loss(emb, paths, temperature=0.1)\n    assert torch.isclose(loss, torch.tensor(0.0), atol=1e-6)\n\n\ndef test_tree_contrastive_loss_positive_with_shared_depth():\n    \"\"\"\n    When some pairs share deeper ancestors, the loss should be strictly positive.\n    \"\"\"\n    # Make embeddings small and deterministic for stability.\n    emb = torch.eye(4, dtype=torch.float32)\n    # First three share the same label at depth 1; last one is in a different branch.\n    paths = [\n        [0, 1],\n        [0, 1],\n        [0, 1],\n        [0, 2],\n    ]\n    loss = losses.tree_contrastive_loss(emb, paths, temperature=0.1)\n    # Loss should be finite and non-negative.\n    assert torch.isfinite(loss)\n    assert loss.item() >= 0.0\n","source_hash":"8e425f43a898b67c4ce378a22847e7602bf39402d30194c89309b62c2fa08b98","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:tests.test_losses_and_decoding.test_tree_contrastive_loss_positive_with_shared_depth","uri":"program://TOLBERT/function/tests.test_losses_and_decoding.test_tree_contrastive_loss_positive_with_shared_depth#L29-L45","kind":"function","name":"test_tree_contrastive_loss_positive_with_shared_depth","path":"tests/test_losses_and_decoding.py","language":"python","start_line":29,"end_line":45,"context_start_line":9,"context_end_line":65,"code":"\nfrom tolbert import losses\nfrom tolbert import decoding\n\n\ndef test_tree_contrastive_loss_zero_when_no_shared_ancestors():\n    \"\"\"\n    If no pairs share any non-root ancestor, the contrastive loss should be 0.\n    \"\"\"\n    emb = torch.randn(3, 8)\n    # All paths differ immediately after root.\n    paths = [\n        [0, 1],\n        [0, 2],\n        [0, 3],\n    ]\n    loss = losses.tree_contrastive_loss(emb, paths, temperature=0.1)\n    assert torch.isclose(loss, torch.tensor(0.0), atol=1e-6)\n\n\ndef test_tree_contrastive_loss_positive_with_shared_depth():\n    \"\"\"\n    When some pairs share deeper ancestors, the loss should be strictly positive.\n    \"\"\"\n    # Make embeddings small and deterministic for stability.\n    emb = torch.eye(4, dtype=torch.float32)\n    # First three share the same label at depth 1; last one is in a different branch.\n    paths = [\n        [0, 1],\n        [0, 1],\n        [0, 1],\n        [0, 2],\n    ]\n    loss = losses.tree_contrastive_loss(emb, paths, temperature=0.1)\n    # Loss should be finite and non-negative.\n    assert torch.isfinite(loss)\n    assert loss.item() >= 0.0\n\n\ndef test_greedy_hierarchical_decode_respects_parent_child_mapping():\n    \"\"\"\n    Ensure that greedy_hierarchical_decode:\n      - performs unconstrained argmax at the first level,\n      - then restricts the next level to children of the chosen parent.\n    \"\"\"\n    batch_size = 1\n\n    # Level 1: two parents, prefer index 1.\n    l1_logits = torch.tensor([[0.0, 5.0]])  # (1, 2)\n    # Level 2: three children; unconstrained argmax would pick index 2.\n    l2_logits = torch.tensor([[10.0, 0.0, 1.0]])  # (1, 3)\n\n    level_logits = {\"1\": l1_logits, \"2\": l2_logits}\n\n    # Parent-to-children mapping: at level 2, parent 1 can only choose child 0.\n    parent_to_children = {\n        2: {","source_hash":"8e425f43a898b67c4ce378a22847e7602bf39402d30194c89309b62c2fa08b98","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:tests.test_losses_and_decoding.test_greedy_hierarchical_decode_respects_parent_child_mapping","uri":"program://TOLBERT/function/tests.test_losses_and_decoding.test_greedy_hierarchical_decode_respects_parent_child_mapping#L48-L81","kind":"function","name":"test_greedy_hierarchical_decode_respects_parent_child_mapping","path":"tests/test_losses_and_decoding.py","language":"python","start_line":48,"end_line":81,"context_start_line":28,"context_end_line":83,"code":"\ndef test_tree_contrastive_loss_positive_with_shared_depth():\n    \"\"\"\n    When some pairs share deeper ancestors, the loss should be strictly positive.\n    \"\"\"\n    # Make embeddings small and deterministic for stability.\n    emb = torch.eye(4, dtype=torch.float32)\n    # First three share the same label at depth 1; last one is in a different branch.\n    paths = [\n        [0, 1],\n        [0, 1],\n        [0, 1],\n        [0, 2],\n    ]\n    loss = losses.tree_contrastive_loss(emb, paths, temperature=0.1)\n    # Loss should be finite and non-negative.\n    assert torch.isfinite(loss)\n    assert loss.item() >= 0.0\n\n\ndef test_greedy_hierarchical_decode_respects_parent_child_mapping():\n    \"\"\"\n    Ensure that greedy_hierarchical_decode:\n      - performs unconstrained argmax at the first level,\n      - then restricts the next level to children of the chosen parent.\n    \"\"\"\n    batch_size = 1\n\n    # Level 1: two parents, prefer index 1.\n    l1_logits = torch.tensor([[0.0, 5.0]])  # (1, 2)\n    # Level 2: three children; unconstrained argmax would pick index 2.\n    l2_logits = torch.tensor([[10.0, 0.0, 1.0]])  # (1, 3)\n\n    level_logits = {\"1\": l1_logits, \"2\": l2_logits}\n\n    # Parent-to-children mapping: at level 2, parent 1 can only choose child 0.\n    parent_to_children = {\n        2: {\n            0: [1, 2],\n            1: [0],\n        }\n    }\n\n    preds = decoding.greedy_hierarchical_decode(\n        level_logits=level_logits,\n        parent_to_children=parent_to_children,\n        levels=[1, 2],\n    )\n\n    # Level 1: picks parent 1.\n    assert preds[1].tolist() == [1]\n    # Level 2: must choose from children of parent 1, i.e., [0]; so prediction is 0,\n    # even though the global argmax of l2 logits is index 2.\n    assert preds[2].tolist() == [0]\n\n","source_hash":"8e425f43a898b67c4ce378a22847e7602bf39402d30194c89309b62c2fa08b98","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:tolbert.config","uri":"program://TOLBERT/module/tolbert.config#L1-L35","kind":"module","name":"tolbert.config","path":"tolbert/config.py","language":"python","start_line":1,"end_line":35,"context_start_line":1,"context_end_line":35,"code":"import json\nfrom pathlib import Path\nfrom typing import Any, Dict\n\n\ndef load_tolbert_config(path: str) -> Dict[str, Any]:\n    \"\"\"\n    Load a simple YAML or JSON config file into a Python dict.\n\n    - If the extension is .yaml or .yml, this function requires PyYAML.\n    - If the extension is .json, it uses the standard library.\n    \"\"\"\n    cfg_path = Path(path)\n    if not cfg_path.exists():\n        raise FileNotFoundError(f\"Config file not found: {cfg_path}\")\n\n    suffix = cfg_path.suffix.lower()\n    if suffix in {\".yaml\", \".yml\"}:\n        try:\n            import yaml  # type: ignore\n        except ImportError as e:\n            raise ImportError(\n                \"PyYAML is required to load YAML configs. Install with `pip install pyyaml`.\"\n            ) from e\n\n        with cfg_path.open(\"r\", encoding=\"utf-8\") as f:\n            return yaml.safe_load(f)\n\n    if suffix == \".json\":\n        with cfg_path.open(\"r\", encoding=\"utf-8\") as f:\n            return json.load(f)\n\n    raise ValueError(f\"Unsupported config extension: {suffix} (expected .yaml, .yml, or .json)\")\n\n","source_hash":"271ccda44a2d59d42fe6674d5025f484744a0e709742fd432dbca6d5c97b0a8f","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:tolbert.config.load_tolbert_config","uri":"program://TOLBERT/function/tolbert.config.load_tolbert_config#L6-L33","kind":"function","name":"load_tolbert_config","path":"tolbert/config.py","language":"python","start_line":6,"end_line":33,"context_start_line":1,"context_end_line":35,"code":"import json\nfrom pathlib import Path\nfrom typing import Any, Dict\n\n\ndef load_tolbert_config(path: str) -> Dict[str, Any]:\n    \"\"\"\n    Load a simple YAML or JSON config file into a Python dict.\n\n    - If the extension is .yaml or .yml, this function requires PyYAML.\n    - If the extension is .json, it uses the standard library.\n    \"\"\"\n    cfg_path = Path(path)\n    if not cfg_path.exists():\n        raise FileNotFoundError(f\"Config file not found: {cfg_path}\")\n\n    suffix = cfg_path.suffix.lower()\n    if suffix in {\".yaml\", \".yml\"}:\n        try:\n            import yaml  # type: ignore\n        except ImportError as e:\n            raise ImportError(\n                \"PyYAML is required to load YAML configs. Install with `pip install pyyaml`.\"\n            ) from e\n\n        with cfg_path.open(\"r\", encoding=\"utf-8\") as f:\n            return yaml.safe_load(f)\n\n    if suffix == \".json\":\n        with cfg_path.open(\"r\", encoding=\"utf-8\") as f:\n            return json.load(f)\n\n    raise ValueError(f\"Unsupported config extension: {suffix} (expected .yaml, .yml, or .json)\")\n\n","source_hash":"271ccda44a2d59d42fe6674d5025f484744a0e709742fd432dbca6d5c97b0a8f","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:tolbert.modeling","uri":"program://TOLBERT/module/tolbert.modeling#L1-L301","kind":"module","name":"tolbert.modeling","path":"tolbert/modeling.py","language":"python","start_line":1,"end_line":301,"context_start_line":1,"context_end_line":301,"code":"from dataclasses import dataclass\nfrom typing import Any, Dict, Optional, Sequence\n\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nfrom transformers import AutoModel\n\n\n@dataclass\nclass TOLBERTConfig:\n    \"\"\"\n    Minimal configuration for the TOLBERT encoder.\n    \n    This mirrors the sketch in `docs/api_reference.md` and is intended\n    to be extended with any additional hyperparameters you need.\n    \"\"\"\n\n    base_model_name: str\n    level_sizes: Dict[int, int]\n    proj_dim: int = 256\n    # Overall weight on hierarchical classification loss\n    lambda_hier: float = 1.0\n    # Weight on path-consistency regularization term\n    lambda_path: float = 0.0\n    # Kept for completeness; used in the training script when adding contrastive loss.\n    lambda_contrast: float = 0.0\n\n\nclass TOLBERT(nn.Module):\n    \"\"\"\n    BERT/RoBERTa-style encoder with multi-level heads and a projection head.\n    \n    Forward returns:\n      - loss: aggregated loss (MLM + hierarchical + optional path) if labels provided.\n      - loss_components: dict with individual loss terms.\n      - mlm_logits: token-level logits for MLM.\n      - level_logits: dict[level_str] -> logits over nodes at that level.\n      - proj: normalized CLS projection for contrastive / retrieval use.\n    \"\"\"\n\n    def __init__(self, config: TOLBERTConfig):\n        super().__init__()\n        self.config = config\n\n        # Backbone encoder\n        self.encoder = AutoModel.from_pretrained(\n            config.base_model_name,\n            cache_dir=\"/data/checkpoints/\",  # noqa: E501\n        )\n        hidden_dim = self.encoder.config.hidden_size\n\n        # Simple MLM head (you can replace with the base model's own head)\n        self.mlm_head = nn.Linear(hidden_dim, self.encoder.config.vocab_size)\n\n        # Hierarchical heads per level\n        self.level_heads = nn.ModuleDict()\n        for level, size in config.level_sizes.items():\n            self.level_heads[str(level)] = nn.Linear(hidden_dim, size)\n\n        # Contrastive projection head\n        self.proj = nn.Linear(hidden_dim, config.proj_dim)\n\n        # Pre-sort levels once for stable ordering in losses\n        self._sorted_levels = sorted(config.level_sizes.keys())\n\n    @classmethod\n    def from_pretrained(\n        cls,\n        checkpoint: str,\n        config: Optional[TOLBERTConfig] = None,\n    ) -> \"TOLBERT\":\n        \"\"\"\n        Very minimal `from_pretrained` helper.\n\n        - `checkpoint` is expected to be a `torch.save(model.state_dict())` file.\n        - You must supply a `config` that matches the saved model.\n        \"\"\"\n        if config is None:\n            raise ValueError(\"TOLBERT.from_pretrained requires a TOLBERTConfig.\")\n\n        model = cls(config)\n        state_dict = torch.load(checkpoint, map_location=\"cpu\")\n        model.load_state_dict(state_dict)\n        return model\n\n    def _compute_path_consistency_loss(\n        self,\n        level_logits: Dict[str, torch.Tensor],\n        paths: Optional[Sequence[Sequence[int]] | Sequence[Sequence[Sequence[int]]]],\n    ) -> Optional[torch.Tensor]:\n        \"\"\"\n        Batch-local implementation of the path-consistency loss described\n        in the paper / training docs, extended to handle DAGs / multi-parent\n        ontologies.\n\n        For each adjacent level pair (ℓ-1, ℓ), we:\n          - build a parent -> {child,...} mapping from the observed `paths`\n            across the batch (allowing multiple parents per child),\n          - compute softmax over level-ℓ logits,\n          - roll level-ℓ probabilities up to the parent space and\n            encourage agreement between:\n                - the distribution implied by children, and\n                - the model's own distribution at level ℓ-1.\n\n        In a pure tree, each child has exactly one parent; in a DAG, a child\n        may appear under multiple parents across the provided paths. This\n        implementation treats all observed parent-child relations as valid.\n        \"\"\"\n        if paths is None:\n            return None\n\n        if len(self._sorted_levels) < 2:\n            return None\n\n        device = next(self.parameters()).device\n\n        # Normalize paths into per-example path sets to support DAGs.\n        # Each element in `path_sets` is a list of paths (lists of node ids).\n        path_sets: list[list[list[int]]] = []\n        for p in paths:\n            if not p:\n                path_sets.append([])\n                continue\n            first = p[0]\n            if isinstance(first, int):\n                path_sets.append([[int(x) for x in p]])  # type: ignore[arg-type]\n            else:\n                path_set: list[list[int]] = []\n                for sub in p:  # type: ignore[assignment]\n                    if isinstance(sub, (list, tuple)):\n                        path_set.append([int(x) for x in sub])\n                path_sets.append(path_set)\n\n        batch_size = len(path_sets)\n\n        total_kl = 0.0\n        num_terms = 0\n\n        # We assume level index ℓ in the paper corresponds to path index ℓ,\n        # with ℓ = 1..L (and index 0 being the root, which we do not have a head for).\n        # For model heads we use integer \"levels\" taken from config.level_sizes.\n        for idx in range(1, len(self._sorted_levels)):\n            level_prev = self._sorted_levels[idx - 1]\n            level_curr = self._sorted_levels[idx]\n\n            if str(level_prev) not in level_logits or str(level_curr) not in level_logits:\n                continue\n\n            logits_prev = level_logits[str(level_prev)]  # (B, C_prev)\n            logits_curr = level_logits[str(level_curr)]  # (B, C_curr)\n\n            probs_prev = F.softmax(logits_prev, dim=-1)  # (B, C_prev)\n            probs_curr = F.softmax(logits_curr, dim=-1)  # (B, C_curr)\n\n            # Build parent -> children map for this level-pair from batch paths.\n            parent_to_children: Dict[int, set[int]] = {}\n            for b in range(batch_size):\n                for path in path_sets[b]:\n                    if len(path) <= max(level_prev, level_curr):\n                        continue\n                    parent_id = path[level_prev]\n                    child_id = path[level_curr]\n                    if parent_id < 0 or child_id < 0:\n                        continue\n                    if parent_id not in parent_to_children:\n                        parent_to_children[parent_id] = set()\n                    parent_to_children[parent_id].add(child_id)\n\n            if not parent_to_children:\n                continue\n\n            num_parents = logits_prev.size(-1)\n            rolled = torch.zeros_like(probs_prev)\n            for parent_id, children_ids in parent_to_children.items():\n                if parent_id < 0 or parent_id >= num_parents:\n                    continue\n                children_idx = torch.tensor(\n                    list(children_ids),\n                    dtype=torch.long,\n                    device=device,\n                )\n                children_idx = children_idx[\n                    (children_idx >= 0) & (children_idx < probs_curr.size(-1))\n                ]\n                if children_idx.numel() == 0:\n                    continue\n                rolled[:, parent_id] = probs_curr[:, children_idx].sum(dim=-1)\n\n            # Renormalize rolled-up distribution to avoid degenerate zeros.\n            rolled_sum = rolled.sum(dim=-1, keepdim=True)\n            rolled_sum = torch.clamp(rolled_sum, min=1e-8)\n            rolled = rolled / rolled_sum\n\n            # Ensure numerical stability for KL\n            probs_prev_clamped = torch.clamp(probs_prev, min=1e-8)\n            rolled_clamped = torch.clamp(rolled, min=1e-8)\n\n            kl = F.kl_div(\n                probs_prev_clamped.log(),\n                rolled_clamped,\n                reduction=\"batchmean\",\n            )\n            total_kl = total_kl + kl\n            num_terms += 1\n\n        if num_terms == 0:\n            return None\n\n        return total_kl / float(num_terms)\n\n    def forward(\n        self,\n        input_ids: torch.Tensor,\n        attention_mask: Optional[torch.Tensor] = None,\n        labels_mlm: Optional[torch.Tensor] = None,\n        level_targets: Optional[Dict[int, torch.Tensor]] = None,\n        paths: Optional[Sequence[Sequence[int]] | Sequence[Sequence[Sequence[int]]]] = None,\n    ) -> Dict[str, Any]:\n        \"\"\"\n        Args:\n            input_ids: (batch, seq_len)\n            attention_mask: (batch, seq_len)\n            labels_mlm: (batch, seq_len) with -100 for non-MLM positions.\n            level_targets: dict {level(int): tensor(batch,)} with class indices.\n            paths: optional sequence of per-example label paths, each a\n                   sequence of node ids [root, c1, c2, ..., cL]. Used for\n                   path-consistency loss.\n        \"\"\"\n        outputs = self.encoder(input_ids=input_ids, attention_mask=attention_mask)\n        hidden_states = outputs.last_hidden_state  # (batch, seq, hidden)\n        cls = hidden_states[:, 0, :]  # (batch, hidden)\n\n        # MLM logits\n        mlm_logits = self.mlm_head(hidden_states)  # (batch, seq, vocab)\n\n        # Hierarchical logits\n        level_logits: Dict[str, torch.Tensor] = {}\n        for level, head in self.level_heads.items():\n            level_logits[level] = head(cls)  # (batch, C_level)\n\n        # Contrastive projection\n        proj = F.normalize(self.proj(cls), dim=-1)\n\n        loss: Optional[torch.Tensor] = None\n        loss_dict: Dict[str, torch.Tensor] = {}\n\n        # MLM loss\n        mlm_loss = None\n        if labels_mlm is not None:\n            mlm_loss_fct = nn.CrossEntropyLoss(ignore_index=-100)\n            mlm_loss = mlm_loss_fct(\n                mlm_logits.view(-1, mlm_logits.size(-1)),\n                labels_mlm.view(-1),\n            )\n            loss_dict[\"mlm\"] = mlm_loss\n\n        # Hierarchical classification loss (sum over levels, excluding ignore_index)\n        hier_loss = None\n        if level_targets is not None and len(level_targets) > 0:\n            ce = nn.CrossEntropyLoss(ignore_index=-100)\n            per_level_losses = []\n            for level_int in self._sorted_levels:\n                if level_int not in level_targets:\n                    continue\n                logits = level_logits[str(level_int)]\n                targets = level_targets[level_int]\n                level_loss = ce(logits, targets)\n                loss_dict[f\"level_{level_int}\"] = level_loss\n                per_level_losses.append(level_loss)\n\n            if per_level_losses:\n                hier_loss = torch.stack(per_level_losses).mean()\n                loss_dict[\"hier\"] = hier_loss\n\n        # Path-consistency loss (uses predicted distributions only)\n        path_loss = None\n        if paths is not None:\n            path_loss = self._compute_path_consistency_loss(level_logits, paths)\n            if path_loss is not None:\n                loss_dict[\"path\"] = path_loss\n\n        # Aggregate total loss with configuration weights.\n        components = []\n        if mlm_loss is not None:\n            components.append(mlm_loss)\n        if hier_loss is not None and self.config.lambda_hier != 0.0:\n            components.append(self.config.lambda_hier * hier_loss)\n        if path_loss is not None and self.config.lambda_path != 0.0:\n            components.append(self.config.lambda_path * path_loss)\n\n        if components:\n            loss = sum(components)\n\n        return {\n            \"loss\": loss,\n            \"loss_components\": loss_dict,\n            \"mlm_logits\": mlm_logits,\n            \"level_logits\": level_logits,\n            \"proj\": proj,\n        }","source_hash":"3db428a7a0c04a6a556bf9b462e69ac73b5cb342a3bbfb42bd0e80200cd4a34c","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:tolbert.modeling.TOLBERTConfig","uri":"program://TOLBERT/class/tolbert.modeling.TOLBERTConfig#L11-L27","kind":"class","name":"TOLBERTConfig","path":"tolbert/modeling.py","language":"python","start_line":11,"end_line":27,"context_start_line":1,"context_end_line":47,"code":"from dataclasses import dataclass\nfrom typing import Any, Dict, Optional, Sequence\n\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nfrom transformers import AutoModel\n\n\n@dataclass\nclass TOLBERTConfig:\n    \"\"\"\n    Minimal configuration for the TOLBERT encoder.\n    \n    This mirrors the sketch in `docs/api_reference.md` and is intended\n    to be extended with any additional hyperparameters you need.\n    \"\"\"\n\n    base_model_name: str\n    level_sizes: Dict[int, int]\n    proj_dim: int = 256\n    # Overall weight on hierarchical classification loss\n    lambda_hier: float = 1.0\n    # Weight on path-consistency regularization term\n    lambda_path: float = 0.0\n    # Kept for completeness; used in the training script when adding contrastive loss.\n    lambda_contrast: float = 0.0\n\n\nclass TOLBERT(nn.Module):\n    \"\"\"\n    BERT/RoBERTa-style encoder with multi-level heads and a projection head.\n    \n    Forward returns:\n      - loss: aggregated loss (MLM + hierarchical + optional path) if labels provided.\n      - loss_components: dict with individual loss terms.\n      - mlm_logits: token-level logits for MLM.\n      - level_logits: dict[level_str] -> logits over nodes at that level.\n      - proj: normalized CLS projection for contrastive / retrieval use.\n    \"\"\"\n\n    def __init__(self, config: TOLBERTConfig):\n        super().__init__()\n        self.config = config\n\n        # Backbone encoder\n        self.encoder = AutoModel.from_pretrained(","source_hash":"3db428a7a0c04a6a556bf9b462e69ac73b5cb342a3bbfb42bd0e80200cd4a34c","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:tolbert.modeling.TOLBERT","uri":"program://TOLBERT/class/tolbert.modeling.TOLBERT#L30-L301","kind":"class","name":"TOLBERT","path":"tolbert/modeling.py","language":"python","start_line":30,"end_line":301,"context_start_line":10,"context_end_line":301,"code":"@dataclass\nclass TOLBERTConfig:\n    \"\"\"\n    Minimal configuration for the TOLBERT encoder.\n    \n    This mirrors the sketch in `docs/api_reference.md` and is intended\n    to be extended with any additional hyperparameters you need.\n    \"\"\"\n\n    base_model_name: str\n    level_sizes: Dict[int, int]\n    proj_dim: int = 256\n    # Overall weight on hierarchical classification loss\n    lambda_hier: float = 1.0\n    # Weight on path-consistency regularization term\n    lambda_path: float = 0.0\n    # Kept for completeness; used in the training script when adding contrastive loss.\n    lambda_contrast: float = 0.0\n\n\nclass TOLBERT(nn.Module):\n    \"\"\"\n    BERT/RoBERTa-style encoder with multi-level heads and a projection head.\n    \n    Forward returns:\n      - loss: aggregated loss (MLM + hierarchical + optional path) if labels provided.\n      - loss_components: dict with individual loss terms.\n      - mlm_logits: token-level logits for MLM.\n      - level_logits: dict[level_str] -> logits over nodes at that level.\n      - proj: normalized CLS projection for contrastive / retrieval use.\n    \"\"\"\n\n    def __init__(self, config: TOLBERTConfig):\n        super().__init__()\n        self.config = config\n\n        # Backbone encoder\n        self.encoder = AutoModel.from_pretrained(\n            config.base_model_name,\n            cache_dir=\"/data/checkpoints/\",  # noqa: E501\n        )\n        hidden_dim = self.encoder.config.hidden_size\n\n        # Simple MLM head (you can replace with the base model's own head)\n        self.mlm_head = nn.Linear(hidden_dim, self.encoder.config.vocab_size)\n\n        # Hierarchical heads per level\n        self.level_heads = nn.ModuleDict()\n        for level, size in config.level_sizes.items():\n            self.level_heads[str(level)] = nn.Linear(hidden_dim, size)\n\n        # Contrastive projection head\n        self.proj = nn.Linear(hidden_dim, config.proj_dim)\n\n        # Pre-sort levels once for stable ordering in losses\n        self._sorted_levels = sorted(config.level_sizes.keys())\n\n    @classmethod\n    def from_pretrained(\n        cls,\n        checkpoint: str,\n        config: Optional[TOLBERTConfig] = None,\n    ) -> \"TOLBERT\":\n        \"\"\"\n        Very minimal `from_pretrained` helper.\n\n        - `checkpoint` is expected to be a `torch.save(model.state_dict())` file.\n        - You must supply a `config` that matches the saved model.\n        \"\"\"\n        if config is None:\n            raise ValueError(\"TOLBERT.from_pretrained requires a TOLBERTConfig.\")\n\n        model = cls(config)\n        state_dict = torch.load(checkpoint, map_location=\"cpu\")\n        model.load_state_dict(state_dict)\n        return model\n\n    def _compute_path_consistency_loss(\n        self,\n        level_logits: Dict[str, torch.Tensor],\n        paths: Optional[Sequence[Sequence[int]] | Sequence[Sequence[Sequence[int]]]],\n    ) -> Optional[torch.Tensor]:\n        \"\"\"\n        Batch-local implementation of the path-consistency loss described\n        in the paper / training docs, extended to handle DAGs / multi-parent\n        ontologies.\n\n        For each adjacent level pair (ℓ-1, ℓ), we:\n          - build a parent -> {child,...} mapping from the observed `paths`\n            across the batch (allowing multiple parents per child),\n          - compute softmax over level-ℓ logits,\n          - roll level-ℓ probabilities up to the parent space and\n            encourage agreement between:\n                - the distribution implied by children, and\n                - the model's own distribution at level ℓ-1.\n\n        In a pure tree, each child has exactly one parent; in a DAG, a child\n        may appear under multiple parents across the provided paths. This\n        implementation treats all observed parent-child relations as valid.\n        \"\"\"\n        if paths is None:\n            return None\n\n        if len(self._sorted_levels) < 2:\n            return None\n\n        device = next(self.parameters()).device\n\n        # Normalize paths into per-example path sets to support DAGs.\n        # Each element in `path_sets` is a list of paths (lists of node ids).\n        path_sets: list[list[list[int]]] = []\n        for p in paths:\n            if not p:\n                path_sets.append([])\n                continue\n            first = p[0]\n            if isinstance(first, int):\n                path_sets.append([[int(x) for x in p]])  # type: ignore[arg-type]\n            else:\n                path_set: list[list[int]] = []\n                for sub in p:  # type: ignore[assignment]\n                    if isinstance(sub, (list, tuple)):\n                        path_set.append([int(x) for x in sub])\n                path_sets.append(path_set)\n\n        batch_size = len(path_sets)\n\n        total_kl = 0.0\n        num_terms = 0\n\n        # We assume level index ℓ in the paper corresponds to path index ℓ,\n        # with ℓ = 1..L (and index 0 being the root, which we do not have a head for).\n        # For model heads we use integer \"levels\" taken from config.level_sizes.\n        for idx in range(1, len(self._sorted_levels)):\n            level_prev = self._sorted_levels[idx - 1]\n            level_curr = self._sorted_levels[idx]\n\n            if str(level_prev) not in level_logits or str(level_curr) not in level_logits:\n                continue\n\n            logits_prev = level_logits[str(level_prev)]  # (B, C_prev)\n            logits_curr = level_logits[str(level_curr)]  # (B, C_curr)\n\n            probs_prev = F.softmax(logits_prev, dim=-1)  # (B, C_prev)\n            probs_curr = F.softmax(logits_curr, dim=-1)  # (B, C_curr)\n\n            # Build parent -> children map for this level-pair from batch paths.\n            parent_to_children: Dict[int, set[int]] = {}\n            for b in range(batch_size):\n                for path in path_sets[b]:\n                    if len(path) <= max(level_prev, level_curr):\n                        continue\n                    parent_id = path[level_prev]\n                    child_id = path[level_curr]\n                    if parent_id < 0 or child_id < 0:\n                        continue\n                    if parent_id not in parent_to_children:\n                        parent_to_children[parent_id] = set()\n                    parent_to_children[parent_id].add(child_id)\n\n            if not parent_to_children:\n                continue\n\n            num_parents = logits_prev.size(-1)\n            rolled = torch.zeros_like(probs_prev)\n            for parent_id, children_ids in parent_to_children.items():\n                if parent_id < 0 or parent_id >= num_parents:\n                    continue\n                children_idx = torch.tensor(\n                    list(children_ids),\n                    dtype=torch.long,\n                    device=device,\n                )\n                children_idx = children_idx[\n                    (children_idx >= 0) & (children_idx < probs_curr.size(-1))\n                ]\n                if children_idx.numel() == 0:\n                    continue\n                rolled[:, parent_id] = probs_curr[:, children_idx].sum(dim=-1)\n\n            # Renormalize rolled-up distribution to avoid degenerate zeros.\n            rolled_sum = rolled.sum(dim=-1, keepdim=True)\n            rolled_sum = torch.clamp(rolled_sum, min=1e-8)\n            rolled = rolled / rolled_sum\n\n            # Ensure numerical stability for KL\n            probs_prev_clamped = torch.clamp(probs_prev, min=1e-8)\n            rolled_clamped = torch.clamp(rolled, min=1e-8)\n\n            kl = F.kl_div(\n                probs_prev_clamped.log(),\n                rolled_clamped,\n                reduction=\"batchmean\",\n            )\n            total_kl = total_kl + kl\n            num_terms += 1\n\n        if num_terms == 0:\n            return None\n\n        return total_kl / float(num_terms)\n\n    def forward(\n        self,\n        input_ids: torch.Tensor,\n        attention_mask: Optional[torch.Tensor] = None,\n        labels_mlm: Optional[torch.Tensor] = None,\n        level_targets: Optional[Dict[int, torch.Tensor]] = None,\n        paths: Optional[Sequence[Sequence[int]] | Sequence[Sequence[Sequence[int]]]] = None,\n    ) -> Dict[str, Any]:\n        \"\"\"\n        Args:\n            input_ids: (batch, seq_len)\n            attention_mask: (batch, seq_len)\n            labels_mlm: (batch, seq_len) with -100 for non-MLM positions.\n            level_targets: dict {level(int): tensor(batch,)} with class indices.\n            paths: optional sequence of per-example label paths, each a\n                   sequence of node ids [root, c1, c2, ..., cL]. Used for\n                   path-consistency loss.\n        \"\"\"\n        outputs = self.encoder(input_ids=input_ids, attention_mask=attention_mask)\n        hidden_states = outputs.last_hidden_state  # (batch, seq, hidden)\n        cls = hidden_states[:, 0, :]  # (batch, hidden)\n\n        # MLM logits\n        mlm_logits = self.mlm_head(hidden_states)  # (batch, seq, vocab)\n\n        # Hierarchical logits\n        level_logits: Dict[str, torch.Tensor] = {}\n        for level, head in self.level_heads.items():\n            level_logits[level] = head(cls)  # (batch, C_level)\n\n        # Contrastive projection\n        proj = F.normalize(self.proj(cls), dim=-1)\n\n        loss: Optional[torch.Tensor] = None\n        loss_dict: Dict[str, torch.Tensor] = {}\n\n        # MLM loss\n        mlm_loss = None\n        if labels_mlm is not None:\n            mlm_loss_fct = nn.CrossEntropyLoss(ignore_index=-100)\n            mlm_loss = mlm_loss_fct(\n                mlm_logits.view(-1, mlm_logits.size(-1)),\n                labels_mlm.view(-1),\n            )\n            loss_dict[\"mlm\"] = mlm_loss\n\n        # Hierarchical classification loss (sum over levels, excluding ignore_index)\n        hier_loss = None\n        if level_targets is not None and len(level_targets) > 0:\n            ce = nn.CrossEntropyLoss(ignore_index=-100)\n            per_level_losses = []\n            for level_int in self._sorted_levels:\n                if level_int not in level_targets:\n                    continue\n                logits = level_logits[str(level_int)]\n                targets = level_targets[level_int]\n                level_loss = ce(logits, targets)\n                loss_dict[f\"level_{level_int}\"] = level_loss\n                per_level_losses.append(level_loss)\n\n            if per_level_losses:\n                hier_loss = torch.stack(per_level_losses).mean()\n                loss_dict[\"hier\"] = hier_loss\n\n        # Path-consistency loss (uses predicted distributions only)\n        path_loss = None\n        if paths is not None:\n            path_loss = self._compute_path_consistency_loss(level_logits, paths)\n            if path_loss is not None:\n                loss_dict[\"path\"] = path_loss\n\n        # Aggregate total loss with configuration weights.\n        components = []\n        if mlm_loss is not None:\n            components.append(mlm_loss)\n        if hier_loss is not None and self.config.lambda_hier != 0.0:\n            components.append(self.config.lambda_hier * hier_loss)\n        if path_loss is not None and self.config.lambda_path != 0.0:\n            components.append(self.config.lambda_path * path_loss)\n\n        if components:\n            loss = sum(components)\n\n        return {\n            \"loss\": loss,\n            \"loss_components\": loss_dict,\n            \"mlm_logits\": mlm_logits,\n            \"level_logits\": level_logits,\n            \"proj\": proj,\n        }","source_hash":"3db428a7a0c04a6a556bf9b462e69ac73b5cb342a3bbfb42bd0e80200cd4a34c","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:tolbert.modeling.__init__","uri":"program://TOLBERT/function/tolbert.modeling.__init__#L42-L65","kind":"function","name":"__init__","path":"tolbert/modeling.py","language":"python","start_line":42,"end_line":65,"context_start_line":22,"context_end_line":85,"code":"    # Overall weight on hierarchical classification loss\n    lambda_hier: float = 1.0\n    # Weight on path-consistency regularization term\n    lambda_path: float = 0.0\n    # Kept for completeness; used in the training script when adding contrastive loss.\n    lambda_contrast: float = 0.0\n\n\nclass TOLBERT(nn.Module):\n    \"\"\"\n    BERT/RoBERTa-style encoder with multi-level heads and a projection head.\n    \n    Forward returns:\n      - loss: aggregated loss (MLM + hierarchical + optional path) if labels provided.\n      - loss_components: dict with individual loss terms.\n      - mlm_logits: token-level logits for MLM.\n      - level_logits: dict[level_str] -> logits over nodes at that level.\n      - proj: normalized CLS projection for contrastive / retrieval use.\n    \"\"\"\n\n    def __init__(self, config: TOLBERTConfig):\n        super().__init__()\n        self.config = config\n\n        # Backbone encoder\n        self.encoder = AutoModel.from_pretrained(\n            config.base_model_name,\n            cache_dir=\"/data/checkpoints/\",  # noqa: E501\n        )\n        hidden_dim = self.encoder.config.hidden_size\n\n        # Simple MLM head (you can replace with the base model's own head)\n        self.mlm_head = nn.Linear(hidden_dim, self.encoder.config.vocab_size)\n\n        # Hierarchical heads per level\n        self.level_heads = nn.ModuleDict()\n        for level, size in config.level_sizes.items():\n            self.level_heads[str(level)] = nn.Linear(hidden_dim, size)\n\n        # Contrastive projection head\n        self.proj = nn.Linear(hidden_dim, config.proj_dim)\n\n        # Pre-sort levels once for stable ordering in losses\n        self._sorted_levels = sorted(config.level_sizes.keys())\n\n    @classmethod\n    def from_pretrained(\n        cls,\n        checkpoint: str,\n        config: Optional[TOLBERTConfig] = None,\n    ) -> \"TOLBERT\":\n        \"\"\"\n        Very minimal `from_pretrained` helper.\n\n        - `checkpoint` is expected to be a `torch.save(model.state_dict())` file.\n        - You must supply a `config` that matches the saved model.\n        \"\"\"\n        if config is None:\n            raise ValueError(\"TOLBERT.from_pretrained requires a TOLBERTConfig.\")\n\n        model = cls(config)\n        state_dict = torch.load(checkpoint, map_location=\"cpu\")\n        model.load_state_dict(state_dict)\n        return model","source_hash":"3db428a7a0c04a6a556bf9b462e69ac73b5cb342a3bbfb42bd0e80200cd4a34c","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:tolbert.modeling.from_pretrained","uri":"program://TOLBERT/function/tolbert.modeling.from_pretrained#L68-L85","kind":"function","name":"from_pretrained","path":"tolbert/modeling.py","language":"python","start_line":68,"end_line":85,"context_start_line":48,"context_end_line":105,"code":"            config.base_model_name,\n            cache_dir=\"/data/checkpoints/\",  # noqa: E501\n        )\n        hidden_dim = self.encoder.config.hidden_size\n\n        # Simple MLM head (you can replace with the base model's own head)\n        self.mlm_head = nn.Linear(hidden_dim, self.encoder.config.vocab_size)\n\n        # Hierarchical heads per level\n        self.level_heads = nn.ModuleDict()\n        for level, size in config.level_sizes.items():\n            self.level_heads[str(level)] = nn.Linear(hidden_dim, size)\n\n        # Contrastive projection head\n        self.proj = nn.Linear(hidden_dim, config.proj_dim)\n\n        # Pre-sort levels once for stable ordering in losses\n        self._sorted_levels = sorted(config.level_sizes.keys())\n\n    @classmethod\n    def from_pretrained(\n        cls,\n        checkpoint: str,\n        config: Optional[TOLBERTConfig] = None,\n    ) -> \"TOLBERT\":\n        \"\"\"\n        Very minimal `from_pretrained` helper.\n\n        - `checkpoint` is expected to be a `torch.save(model.state_dict())` file.\n        - You must supply a `config` that matches the saved model.\n        \"\"\"\n        if config is None:\n            raise ValueError(\"TOLBERT.from_pretrained requires a TOLBERTConfig.\")\n\n        model = cls(config)\n        state_dict = torch.load(checkpoint, map_location=\"cpu\")\n        model.load_state_dict(state_dict)\n        return model\n\n    def _compute_path_consistency_loss(\n        self,\n        level_logits: Dict[str, torch.Tensor],\n        paths: Optional[Sequence[Sequence[int]] | Sequence[Sequence[Sequence[int]]]],\n    ) -> Optional[torch.Tensor]:\n        \"\"\"\n        Batch-local implementation of the path-consistency loss described\n        in the paper / training docs, extended to handle DAGs / multi-parent\n        ontologies.\n\n        For each adjacent level pair (ℓ-1, ℓ), we:\n          - build a parent -> {child,...} mapping from the observed `paths`\n            across the batch (allowing multiple parents per child),\n          - compute softmax over level-ℓ logits,\n          - roll level-ℓ probabilities up to the parent space and\n            encourage agreement between:\n                - the distribution implied by children, and\n                - the model's own distribution at level ℓ-1.\n","source_hash":"3db428a7a0c04a6a556bf9b462e69ac73b5cb342a3bbfb42bd0e80200cd4a34c","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:tolbert.modeling._compute_path_consistency_loss","uri":"program://TOLBERT/function/tolbert.modeling._compute_path_consistency_loss#L87-L210","kind":"function","name":"_compute_path_consistency_loss","path":"tolbert/modeling.py","language":"python","start_line":87,"end_line":210,"context_start_line":67,"context_end_line":230,"code":"    @classmethod\n    def from_pretrained(\n        cls,\n        checkpoint: str,\n        config: Optional[TOLBERTConfig] = None,\n    ) -> \"TOLBERT\":\n        \"\"\"\n        Very minimal `from_pretrained` helper.\n\n        - `checkpoint` is expected to be a `torch.save(model.state_dict())` file.\n        - You must supply a `config` that matches the saved model.\n        \"\"\"\n        if config is None:\n            raise ValueError(\"TOLBERT.from_pretrained requires a TOLBERTConfig.\")\n\n        model = cls(config)\n        state_dict = torch.load(checkpoint, map_location=\"cpu\")\n        model.load_state_dict(state_dict)\n        return model\n\n    def _compute_path_consistency_loss(\n        self,\n        level_logits: Dict[str, torch.Tensor],\n        paths: Optional[Sequence[Sequence[int]] | Sequence[Sequence[Sequence[int]]]],\n    ) -> Optional[torch.Tensor]:\n        \"\"\"\n        Batch-local implementation of the path-consistency loss described\n        in the paper / training docs, extended to handle DAGs / multi-parent\n        ontologies.\n\n        For each adjacent level pair (ℓ-1, ℓ), we:\n          - build a parent -> {child,...} mapping from the observed `paths`\n            across the batch (allowing multiple parents per child),\n          - compute softmax over level-ℓ logits,\n          - roll level-ℓ probabilities up to the parent space and\n            encourage agreement between:\n                - the distribution implied by children, and\n                - the model's own distribution at level ℓ-1.\n\n        In a pure tree, each child has exactly one parent; in a DAG, a child\n        may appear under multiple parents across the provided paths. This\n        implementation treats all observed parent-child relations as valid.\n        \"\"\"\n        if paths is None:\n            return None\n\n        if len(self._sorted_levels) < 2:\n            return None\n\n        device = next(self.parameters()).device\n\n        # Normalize paths into per-example path sets to support DAGs.\n        # Each element in `path_sets` is a list of paths (lists of node ids).\n        path_sets: list[list[list[int]]] = []\n        for p in paths:\n            if not p:\n                path_sets.append([])\n                continue\n            first = p[0]\n            if isinstance(first, int):\n                path_sets.append([[int(x) for x in p]])  # type: ignore[arg-type]\n            else:\n                path_set: list[list[int]] = []\n                for sub in p:  # type: ignore[assignment]\n                    if isinstance(sub, (list, tuple)):\n                        path_set.append([int(x) for x in sub])\n                path_sets.append(path_set)\n\n        batch_size = len(path_sets)\n\n        total_kl = 0.0\n        num_terms = 0\n\n        # We assume level index ℓ in the paper corresponds to path index ℓ,\n        # with ℓ = 1..L (and index 0 being the root, which we do not have a head for).\n        # For model heads we use integer \"levels\" taken from config.level_sizes.\n        for idx in range(1, len(self._sorted_levels)):\n            level_prev = self._sorted_levels[idx - 1]\n            level_curr = self._sorted_levels[idx]\n\n            if str(level_prev) not in level_logits or str(level_curr) not in level_logits:\n                continue\n\n            logits_prev = level_logits[str(level_prev)]  # (B, C_prev)\n            logits_curr = level_logits[str(level_curr)]  # (B, C_curr)\n\n            probs_prev = F.softmax(logits_prev, dim=-1)  # (B, C_prev)\n            probs_curr = F.softmax(logits_curr, dim=-1)  # (B, C_curr)\n\n            # Build parent -> children map for this level-pair from batch paths.\n            parent_to_children: Dict[int, set[int]] = {}\n            for b in range(batch_size):\n                for path in path_sets[b]:\n                    if len(path) <= max(level_prev, level_curr):\n                        continue\n                    parent_id = path[level_prev]\n                    child_id = path[level_curr]\n                    if parent_id < 0 or child_id < 0:\n                        continue\n                    if parent_id not in parent_to_children:\n                        parent_to_children[parent_id] = set()\n                    parent_to_children[parent_id].add(child_id)\n\n            if not parent_to_children:\n                continue\n\n            num_parents = logits_prev.size(-1)\n            rolled = torch.zeros_like(probs_prev)\n            for parent_id, children_ids in parent_to_children.items():\n                if parent_id < 0 or parent_id >= num_parents:\n                    continue\n                children_idx = torch.tensor(\n                    list(children_ids),\n                    dtype=torch.long,\n                    device=device,\n                )\n                children_idx = children_idx[\n                    (children_idx >= 0) & (children_idx < probs_curr.size(-1))\n                ]\n                if children_idx.numel() == 0:\n                    continue\n                rolled[:, parent_id] = probs_curr[:, children_idx].sum(dim=-1)\n\n            # Renormalize rolled-up distribution to avoid degenerate zeros.\n            rolled_sum = rolled.sum(dim=-1, keepdim=True)\n            rolled_sum = torch.clamp(rolled_sum, min=1e-8)\n            rolled = rolled / rolled_sum\n\n            # Ensure numerical stability for KL\n            probs_prev_clamped = torch.clamp(probs_prev, min=1e-8)\n            rolled_clamped = torch.clamp(rolled, min=1e-8)\n\n            kl = F.kl_div(\n                probs_prev_clamped.log(),\n                rolled_clamped,\n                reduction=\"batchmean\",\n            )\n            total_kl = total_kl + kl\n            num_terms += 1\n\n        if num_terms == 0:\n            return None\n\n        return total_kl / float(num_terms)\n\n    def forward(\n        self,\n        input_ids: torch.Tensor,\n        attention_mask: Optional[torch.Tensor] = None,\n        labels_mlm: Optional[torch.Tensor] = None,\n        level_targets: Optional[Dict[int, torch.Tensor]] = None,\n        paths: Optional[Sequence[Sequence[int]] | Sequence[Sequence[Sequence[int]]]] = None,\n    ) -> Dict[str, Any]:\n        \"\"\"\n        Args:\n            input_ids: (batch, seq_len)\n            attention_mask: (batch, seq_len)\n            labels_mlm: (batch, seq_len) with -100 for non-MLM positions.\n            level_targets: dict {level(int): tensor(batch,)} with class indices.\n            paths: optional sequence of per-example label paths, each a\n                   sequence of node ids [root, c1, c2, ..., cL]. Used for\n                   path-consistency loss.\n        \"\"\"\n        outputs = self.encoder(input_ids=input_ids, attention_mask=attention_mask)","source_hash":"3db428a7a0c04a6a556bf9b462e69ac73b5cb342a3bbfb42bd0e80200cd4a34c","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:tolbert.modeling.forward","uri":"program://TOLBERT/function/tolbert.modeling.forward#L212-L301","kind":"function","name":"forward","path":"tolbert/modeling.py","language":"python","start_line":212,"end_line":301,"context_start_line":192,"context_end_line":301,"code":"            rolled_sum = torch.clamp(rolled_sum, min=1e-8)\n            rolled = rolled / rolled_sum\n\n            # Ensure numerical stability for KL\n            probs_prev_clamped = torch.clamp(probs_prev, min=1e-8)\n            rolled_clamped = torch.clamp(rolled, min=1e-8)\n\n            kl = F.kl_div(\n                probs_prev_clamped.log(),\n                rolled_clamped,\n                reduction=\"batchmean\",\n            )\n            total_kl = total_kl + kl\n            num_terms += 1\n\n        if num_terms == 0:\n            return None\n\n        return total_kl / float(num_terms)\n\n    def forward(\n        self,\n        input_ids: torch.Tensor,\n        attention_mask: Optional[torch.Tensor] = None,\n        labels_mlm: Optional[torch.Tensor] = None,\n        level_targets: Optional[Dict[int, torch.Tensor]] = None,\n        paths: Optional[Sequence[Sequence[int]] | Sequence[Sequence[Sequence[int]]]] = None,\n    ) -> Dict[str, Any]:\n        \"\"\"\n        Args:\n            input_ids: (batch, seq_len)\n            attention_mask: (batch, seq_len)\n            labels_mlm: (batch, seq_len) with -100 for non-MLM positions.\n            level_targets: dict {level(int): tensor(batch,)} with class indices.\n            paths: optional sequence of per-example label paths, each a\n                   sequence of node ids [root, c1, c2, ..., cL]. Used for\n                   path-consistency loss.\n        \"\"\"\n        outputs = self.encoder(input_ids=input_ids, attention_mask=attention_mask)\n        hidden_states = outputs.last_hidden_state  # (batch, seq, hidden)\n        cls = hidden_states[:, 0, :]  # (batch, hidden)\n\n        # MLM logits\n        mlm_logits = self.mlm_head(hidden_states)  # (batch, seq, vocab)\n\n        # Hierarchical logits\n        level_logits: Dict[str, torch.Tensor] = {}\n        for level, head in self.level_heads.items():\n            level_logits[level] = head(cls)  # (batch, C_level)\n\n        # Contrastive projection\n        proj = F.normalize(self.proj(cls), dim=-1)\n\n        loss: Optional[torch.Tensor] = None\n        loss_dict: Dict[str, torch.Tensor] = {}\n\n        # MLM loss\n        mlm_loss = None\n        if labels_mlm is not None:\n            mlm_loss_fct = nn.CrossEntropyLoss(ignore_index=-100)\n            mlm_loss = mlm_loss_fct(\n                mlm_logits.view(-1, mlm_logits.size(-1)),\n                labels_mlm.view(-1),\n            )\n            loss_dict[\"mlm\"] = mlm_loss\n\n        # Hierarchical classification loss (sum over levels, excluding ignore_index)\n        hier_loss = None\n        if level_targets is not None and len(level_targets) > 0:\n            ce = nn.CrossEntropyLoss(ignore_index=-100)\n            per_level_losses = []\n            for level_int in self._sorted_levels:\n                if level_int not in level_targets:\n                    continue\n                logits = level_logits[str(level_int)]\n                targets = level_targets[level_int]\n                level_loss = ce(logits, targets)\n                loss_dict[f\"level_{level_int}\"] = level_loss\n                per_level_losses.append(level_loss)\n\n            if per_level_losses:\n                hier_loss = torch.stack(per_level_losses).mean()\n                loss_dict[\"hier\"] = hier_loss\n\n        # Path-consistency loss (uses predicted distributions only)\n        path_loss = None\n        if paths is not None:\n            path_loss = self._compute_path_consistency_loss(level_logits, paths)\n            if path_loss is not None:\n                loss_dict[\"path\"] = path_loss\n\n        # Aggregate total loss with configuration weights.\n        components = []\n        if mlm_loss is not None:\n            components.append(mlm_loss)\n        if hier_loss is not None and self.config.lambda_hier != 0.0:\n            components.append(self.config.lambda_hier * hier_loss)\n        if path_loss is not None and self.config.lambda_path != 0.0:\n            components.append(self.config.lambda_path * path_loss)\n\n        if components:\n            loss = sum(components)\n\n        return {\n            \"loss\": loss,\n            \"loss_components\": loss_dict,\n            \"mlm_logits\": mlm_logits,\n            \"level_logits\": level_logits,\n            \"proj\": proj,\n        }","source_hash":"3db428a7a0c04a6a556bf9b462e69ac73b5cb342a3bbfb42bd0e80200cd4a34c","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:tolbert.losses","uri":"program://TOLBERT/module/tolbert.losses#L1-L199","kind":"module","name":"tolbert.losses","path":"tolbert/losses.py","language":"python","start_line":1,"end_line":199,"context_start_line":1,"context_end_line":199,"code":"from typing import List, Sequence\n\nimport torch\n\n\ndef _compute_shared_depth(pi: Sequence[int], pj: Sequence[int]) -> int:\n    \"\"\"\n    Depth of deepest shared label beyond the root.\n\n    We treat index 0 in the path as the root. The shared depth is the\n    number of consecutive matching labels starting from index 1.\n    \"\"\"\n    max_len = min(len(pi), len(pj))\n    depth = 0\n    # Start from index 1 to skip the root.\n    for idx in range(1, max_len):\n        if pi[idx] != pj[idx]:\n            break\n        depth += 1\n    return depth\n\n\ndef _normalize_paths_arg(\n    paths: Sequence[Sequence[int]] | Sequence[Sequence[Sequence[int]]],\n) -> List[List[List[int]]]:\n    \"\"\"\n    Normalize `paths` into a list of per-example path sets.\n\n    Accepted input formats:\n      - Tree-style (single path per example):\n            paths = [[v0, v1, ...], [v0, v1', ...], ...]\n      - DAG-style (multiple valid paths per example):\n            paths = [\n              [[v0, v1, ...], [v0, v1', ...]],\n              [[v0, u1, ...]],\n              ...\n            ]\n\n    Output format:\n        List[ List[List[int]] ], where outer index is batch example and each\n        inner list is one valid path for that example.\n    \"\"\"\n    norm: List[List[List[int]]] = []\n    for p in paths:\n        if not p:\n            norm.append([])\n            continue\n        first = p[0]\n        # If first element is an int, we have a single path.\n        if isinstance(first, int):\n            norm.append([[int(x) for x in p]])  # type: ignore[arg-type]\n        else:\n            # Assume list/tuple of paths.\n            path_set: List[List[int]] = []\n            for sub in p:  # type: ignore[assignment]\n                if isinstance(sub, (list, tuple)):\n                    path_set.append([int(x) for x in sub])\n            norm.append(path_set)\n    return norm\n\n\ndef _compute_shared_depth_sets(\n    paths_i: List[List[int]],\n    paths_j: List[List[int]],\n) -> int:\n    \"\"\"\n    Deepest shared depth between two *sets* of paths (for DAGs).\n\n    We take the maximum shared depth over all path pairs (pi in paths_i,\n    pj in paths_j).\n    \"\"\"\n    max_depth = 0\n    for pi in paths_i:\n        for pj in paths_j:\n            d = _compute_shared_depth(pi, pj)\n            if d > max_depth:\n                max_depth = d\n    return max_depth\n\n\ndef tree_contrastive_loss(\n    embeddings: torch.Tensor,\n    paths: Sequence[Sequence[int]] | Sequence[Sequence[Sequence[int]]],\n    temperature: float = 0.07,\n) -> torch.Tensor:\n    \"\"\"\n    Depth-weighted tree-aware InfoNCE-style contrastive loss.\n\n    This implements the hierarchical supervised contrastive objective\n    described in the paper, extended to handle DAGs / multiple paths per\n    example:\n\n      - Each example i has one or more valid paths\n            (y_1^{(i,m)}, ..., y_L^{(i,m)})\n        through the ontology graph.\n      - For a pair (i, j), define depth(i, j) as the deepest level at\n        which they share the same label beyond the root **along any**\n        of their respective paths.\n      - Positives P(i) are all j != i with depth(i, j) >= 1.\n      - Each positive pair is weighted by w_ij ∝ depth(i, j).\n      - Negatives are examples with depth(i, j) == 0 (only root shared).\n\n    Args:\n        embeddings: (batch, dim) L2-normalized embeddings (e.g., proj outputs).\n        paths: sequence of per-example paths, which may be:\n            - a single path per example: [[v0, v1, ...], ...], or\n            - multiple paths per example: [[[v0, v1, ...], [v0, v1', ...]], ...]\n        temperature: softmax temperature for contrastive logits.\n    \"\"\"\n    device = embeddings.device\n    batch_size = embeddings.size(0)\n\n    if batch_size <= 1:\n        return torch.tensor(0.0, device=device)\n\n    # Normalize paths into per-example path sets to support DAGs.\n    path_sets = _normalize_paths_arg(paths)\n\n    # Compute pairwise shared depths over path sets.\n    depth_mat = torch.zeros((batch_size, batch_size), dtype=torch.float32, device=device)\n    for i in range(batch_size):\n        for j in range(batch_size):\n            if i == j:\n                continue\n            d = _compute_shared_depth_sets(path_sets[i], path_sets[j])\n            depth_mat[i, j] = float(d)\n\n    # Positives: depth >= 1\n    pos_mask = depth_mat >= 1.0  # (B, B)\n\n    # If no pairs share any non-root ancestor, the contrastive signal is empty.\n    if not pos_mask.any():\n        return torch.tensor(0.0, device=device)\n\n    # Similarity matrix\n    sim = embeddings @ embeddings.T  # (B, B)\n    sim = sim / temperature\n\n    # Exclude self from denominators by setting diag to a very large\n    # negative value (rather than -inf) to avoid NaNs when multiplied\n    # by zero weights later on.\n    diag_mask = torch.eye(batch_size, dtype=torch.bool, device=device)\n    sim = sim.masked_fill(diag_mask, -1e9)\n\n    # Log-softmax-like normalization per row\n    logsumexp = torch.logsumexp(sim, dim=1, keepdim=True)  # (B, 1)\n    log_probs = sim - logsumexp  # (B, B)\n\n    # Depth-based weights w_ij = depth(i,j) / L_i for positives, where\n    # L_i is the maximum usable depth for anchor i (excluding root).\n    # For DAGs, we use the maximum depth over that example's path set.\n    anchor_depths: List[int] = []\n    for path_set in path_sets:\n        max_len = 1\n        for p in path_set:\n            if len(p) - 1 > max_len:\n                max_len = len(p) - 1\n        anchor_depths.append(max(1, max_len))\n    L = torch.tensor(anchor_depths, dtype=torch.float32, device=device).unsqueeze(1)  # (B, 1)\n\n    # Avoid divide-by-zero; we clamped to at least 1 above.\n    norm_depths = depth_mat / L\n\n    weights = torch.zeros_like(depth_mat)\n    weights[pos_mask] = norm_depths[pos_mask]\n\n    # For each anchor i, compute a weighted average of log_probs over positives.\n    eps = 1e-8\n    row_pos_counts = pos_mask.sum(dim=1)  # (B,)\n    row_weight_sums = weights.sum(dim=1)  # (B,)\n\n    # Avoid divide-by-zero\n    valid_rows = row_pos_counts > 0\n    if not valid_rows.any():\n        return torch.tensor(0.0, device=device)\n\n    # Normalized weights within each row (only over positives)\n    norm_weights = torch.zeros_like(weights)\n    norm_weights[pos_mask] = (\n        weights[pos_mask]\n        / (row_weight_sums.unsqueeze(1).expand_as(weights)[pos_mask] + eps)\n    )\n\n    # For each row i, loss_i = - (1/|P(i)|) Σ_j w_ij_norm * log_probs_ij\n    weighted_log_probs = (norm_weights * log_probs)  # (B, B)\n    row_losses = torch.zeros(batch_size, device=device)\n\n    # Sum over j for each i\n    row_losses = -weighted_log_probs.sum(dim=1)\n    # Divide by |P(i)| for anchors that have positives\n    row_losses = torch.where(\n        valid_rows,\n        row_losses / (row_pos_counts.to(row_losses.dtype) + eps),\n        torch.zeros_like(row_losses),\n    )\n\n    # Average over anchors with at least one positive\n    loss = row_losses[valid_rows].mean()\n    return loss","source_hash":"d175336f15064e20ce4160ea8a4d2a797755a44065422ad6d71b9d8443355825","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:tolbert.losses._compute_shared_depth","uri":"program://TOLBERT/function/tolbert.losses._compute_shared_depth#L6-L20","kind":"function","name":"_compute_shared_depth","path":"tolbert/losses.py","language":"python","start_line":6,"end_line":20,"context_start_line":1,"context_end_line":40,"code":"from typing import List, Sequence\n\nimport torch\n\n\ndef _compute_shared_depth(pi: Sequence[int], pj: Sequence[int]) -> int:\n    \"\"\"\n    Depth of deepest shared label beyond the root.\n\n    We treat index 0 in the path as the root. The shared depth is the\n    number of consecutive matching labels starting from index 1.\n    \"\"\"\n    max_len = min(len(pi), len(pj))\n    depth = 0\n    # Start from index 1 to skip the root.\n    for idx in range(1, max_len):\n        if pi[idx] != pj[idx]:\n            break\n        depth += 1\n    return depth\n\n\ndef _normalize_paths_arg(\n    paths: Sequence[Sequence[int]] | Sequence[Sequence[Sequence[int]]],\n) -> List[List[List[int]]]:\n    \"\"\"\n    Normalize `paths` into a list of per-example path sets.\n\n    Accepted input formats:\n      - Tree-style (single path per example):\n            paths = [[v0, v1, ...], [v0, v1', ...], ...]\n      - DAG-style (multiple valid paths per example):\n            paths = [\n              [[v0, v1, ...], [v0, v1', ...]],\n              [[v0, u1, ...]],\n              ...\n            ]\n\n    Output format:\n        List[ List[List[int]] ], where outer index is batch example and each","source_hash":"d175336f15064e20ce4160ea8a4d2a797755a44065422ad6d71b9d8443355825","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:tolbert.losses._normalize_paths_arg","uri":"program://TOLBERT/function/tolbert.losses._normalize_paths_arg#L23-L59","kind":"function","name":"_normalize_paths_arg","path":"tolbert/losses.py","language":"python","start_line":23,"end_line":59,"context_start_line":3,"context_end_line":79,"code":"import torch\n\n\ndef _compute_shared_depth(pi: Sequence[int], pj: Sequence[int]) -> int:\n    \"\"\"\n    Depth of deepest shared label beyond the root.\n\n    We treat index 0 in the path as the root. The shared depth is the\n    number of consecutive matching labels starting from index 1.\n    \"\"\"\n    max_len = min(len(pi), len(pj))\n    depth = 0\n    # Start from index 1 to skip the root.\n    for idx in range(1, max_len):\n        if pi[idx] != pj[idx]:\n            break\n        depth += 1\n    return depth\n\n\ndef _normalize_paths_arg(\n    paths: Sequence[Sequence[int]] | Sequence[Sequence[Sequence[int]]],\n) -> List[List[List[int]]]:\n    \"\"\"\n    Normalize `paths` into a list of per-example path sets.\n\n    Accepted input formats:\n      - Tree-style (single path per example):\n            paths = [[v0, v1, ...], [v0, v1', ...], ...]\n      - DAG-style (multiple valid paths per example):\n            paths = [\n              [[v0, v1, ...], [v0, v1', ...]],\n              [[v0, u1, ...]],\n              ...\n            ]\n\n    Output format:\n        List[ List[List[int]] ], where outer index is batch example and each\n        inner list is one valid path for that example.\n    \"\"\"\n    norm: List[List[List[int]]] = []\n    for p in paths:\n        if not p:\n            norm.append([])\n            continue\n        first = p[0]\n        # If first element is an int, we have a single path.\n        if isinstance(first, int):\n            norm.append([[int(x) for x in p]])  # type: ignore[arg-type]\n        else:\n            # Assume list/tuple of paths.\n            path_set: List[List[int]] = []\n            for sub in p:  # type: ignore[assignment]\n                if isinstance(sub, (list, tuple)):\n                    path_set.append([int(x) for x in sub])\n            norm.append(path_set)\n    return norm\n\n\ndef _compute_shared_depth_sets(\n    paths_i: List[List[int]],\n    paths_j: List[List[int]],\n) -> int:\n    \"\"\"\n    Deepest shared depth between two *sets* of paths (for DAGs).\n\n    We take the maximum shared depth over all path pairs (pi in paths_i,\n    pj in paths_j).\n    \"\"\"\n    max_depth = 0\n    for pi in paths_i:\n        for pj in paths_j:\n            d = _compute_shared_depth(pi, pj)\n            if d > max_depth:\n                max_depth = d\n    return max_depth\n","source_hash":"d175336f15064e20ce4160ea8a4d2a797755a44065422ad6d71b9d8443355825","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:tolbert.losses._compute_shared_depth_sets","uri":"program://TOLBERT/function/tolbert.losses._compute_shared_depth_sets#L62-L78","kind":"function","name":"_compute_shared_depth_sets","path":"tolbert/losses.py","language":"python","start_line":62,"end_line":78,"context_start_line":42,"context_end_line":98,"code":"    \"\"\"\n    norm: List[List[List[int]]] = []\n    for p in paths:\n        if not p:\n            norm.append([])\n            continue\n        first = p[0]\n        # If first element is an int, we have a single path.\n        if isinstance(first, int):\n            norm.append([[int(x) for x in p]])  # type: ignore[arg-type]\n        else:\n            # Assume list/tuple of paths.\n            path_set: List[List[int]] = []\n            for sub in p:  # type: ignore[assignment]\n                if isinstance(sub, (list, tuple)):\n                    path_set.append([int(x) for x in sub])\n            norm.append(path_set)\n    return norm\n\n\ndef _compute_shared_depth_sets(\n    paths_i: List[List[int]],\n    paths_j: List[List[int]],\n) -> int:\n    \"\"\"\n    Deepest shared depth between two *sets* of paths (for DAGs).\n\n    We take the maximum shared depth over all path pairs (pi in paths_i,\n    pj in paths_j).\n    \"\"\"\n    max_depth = 0\n    for pi in paths_i:\n        for pj in paths_j:\n            d = _compute_shared_depth(pi, pj)\n            if d > max_depth:\n                max_depth = d\n    return max_depth\n\n\ndef tree_contrastive_loss(\n    embeddings: torch.Tensor,\n    paths: Sequence[Sequence[int]] | Sequence[Sequence[Sequence[int]]],\n    temperature: float = 0.07,\n) -> torch.Tensor:\n    \"\"\"\n    Depth-weighted tree-aware InfoNCE-style contrastive loss.\n\n    This implements the hierarchical supervised contrastive objective\n    described in the paper, extended to handle DAGs / multiple paths per\n    example:\n\n      - Each example i has one or more valid paths\n            (y_1^{(i,m)}, ..., y_L^{(i,m)})\n        through the ontology graph.\n      - For a pair (i, j), define depth(i, j) as the deepest level at\n        which they share the same label beyond the root **along any**\n        of their respective paths.","source_hash":"d175336f15064e20ce4160ea8a4d2a797755a44065422ad6d71b9d8443355825","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:tolbert.losses.tree_contrastive_loss","uri":"program://TOLBERT/function/tolbert.losses.tree_contrastive_loss#L81-L199","kind":"function","name":"tree_contrastive_loss","path":"tolbert/losses.py","language":"python","start_line":81,"end_line":199,"context_start_line":61,"context_end_line":199,"code":"\ndef _compute_shared_depth_sets(\n    paths_i: List[List[int]],\n    paths_j: List[List[int]],\n) -> int:\n    \"\"\"\n    Deepest shared depth between two *sets* of paths (for DAGs).\n\n    We take the maximum shared depth over all path pairs (pi in paths_i,\n    pj in paths_j).\n    \"\"\"\n    max_depth = 0\n    for pi in paths_i:\n        for pj in paths_j:\n            d = _compute_shared_depth(pi, pj)\n            if d > max_depth:\n                max_depth = d\n    return max_depth\n\n\ndef tree_contrastive_loss(\n    embeddings: torch.Tensor,\n    paths: Sequence[Sequence[int]] | Sequence[Sequence[Sequence[int]]],\n    temperature: float = 0.07,\n) -> torch.Tensor:\n    \"\"\"\n    Depth-weighted tree-aware InfoNCE-style contrastive loss.\n\n    This implements the hierarchical supervised contrastive objective\n    described in the paper, extended to handle DAGs / multiple paths per\n    example:\n\n      - Each example i has one or more valid paths\n            (y_1^{(i,m)}, ..., y_L^{(i,m)})\n        through the ontology graph.\n      - For a pair (i, j), define depth(i, j) as the deepest level at\n        which they share the same label beyond the root **along any**\n        of their respective paths.\n      - Positives P(i) are all j != i with depth(i, j) >= 1.\n      - Each positive pair is weighted by w_ij ∝ depth(i, j).\n      - Negatives are examples with depth(i, j) == 0 (only root shared).\n\n    Args:\n        embeddings: (batch, dim) L2-normalized embeddings (e.g., proj outputs).\n        paths: sequence of per-example paths, which may be:\n            - a single path per example: [[v0, v1, ...], ...], or\n            - multiple paths per example: [[[v0, v1, ...], [v0, v1', ...]], ...]\n        temperature: softmax temperature for contrastive logits.\n    \"\"\"\n    device = embeddings.device\n    batch_size = embeddings.size(0)\n\n    if batch_size <= 1:\n        return torch.tensor(0.0, device=device)\n\n    # Normalize paths into per-example path sets to support DAGs.\n    path_sets = _normalize_paths_arg(paths)\n\n    # Compute pairwise shared depths over path sets.\n    depth_mat = torch.zeros((batch_size, batch_size), dtype=torch.float32, device=device)\n    for i in range(batch_size):\n        for j in range(batch_size):\n            if i == j:\n                continue\n            d = _compute_shared_depth_sets(path_sets[i], path_sets[j])\n            depth_mat[i, j] = float(d)\n\n    # Positives: depth >= 1\n    pos_mask = depth_mat >= 1.0  # (B, B)\n\n    # If no pairs share any non-root ancestor, the contrastive signal is empty.\n    if not pos_mask.any():\n        return torch.tensor(0.0, device=device)\n\n    # Similarity matrix\n    sim = embeddings @ embeddings.T  # (B, B)\n    sim = sim / temperature\n\n    # Exclude self from denominators by setting diag to a very large\n    # negative value (rather than -inf) to avoid NaNs when multiplied\n    # by zero weights later on.\n    diag_mask = torch.eye(batch_size, dtype=torch.bool, device=device)\n    sim = sim.masked_fill(diag_mask, -1e9)\n\n    # Log-softmax-like normalization per row\n    logsumexp = torch.logsumexp(sim, dim=1, keepdim=True)  # (B, 1)\n    log_probs = sim - logsumexp  # (B, B)\n\n    # Depth-based weights w_ij = depth(i,j) / L_i for positives, where\n    # L_i is the maximum usable depth for anchor i (excluding root).\n    # For DAGs, we use the maximum depth over that example's path set.\n    anchor_depths: List[int] = []\n    for path_set in path_sets:\n        max_len = 1\n        for p in path_set:\n            if len(p) - 1 > max_len:\n                max_len = len(p) - 1\n        anchor_depths.append(max(1, max_len))\n    L = torch.tensor(anchor_depths, dtype=torch.float32, device=device).unsqueeze(1)  # (B, 1)\n\n    # Avoid divide-by-zero; we clamped to at least 1 above.\n    norm_depths = depth_mat / L\n\n    weights = torch.zeros_like(depth_mat)\n    weights[pos_mask] = norm_depths[pos_mask]\n\n    # For each anchor i, compute a weighted average of log_probs over positives.\n    eps = 1e-8\n    row_pos_counts = pos_mask.sum(dim=1)  # (B,)\n    row_weight_sums = weights.sum(dim=1)  # (B,)\n\n    # Avoid divide-by-zero\n    valid_rows = row_pos_counts > 0\n    if not valid_rows.any():\n        return torch.tensor(0.0, device=device)\n\n    # Normalized weights within each row (only over positives)\n    norm_weights = torch.zeros_like(weights)\n    norm_weights[pos_mask] = (\n        weights[pos_mask]\n        / (row_weight_sums.unsqueeze(1).expand_as(weights)[pos_mask] + eps)\n    )\n\n    # For each row i, loss_i = - (1/|P(i)|) Σ_j w_ij_norm * log_probs_ij\n    weighted_log_probs = (norm_weights * log_probs)  # (B, B)\n    row_losses = torch.zeros(batch_size, device=device)\n\n    # Sum over j for each i\n    row_losses = -weighted_log_probs.sum(dim=1)\n    # Divide by |P(i)| for anchors that have positives\n    row_losses = torch.where(\n        valid_rows,\n        row_losses / (row_pos_counts.to(row_losses.dtype) + eps),\n        torch.zeros_like(row_losses),\n    )\n\n    # Average over anchors with at least one positive\n    loss = row_losses[valid_rows].mean()\n    return loss","source_hash":"d175336f15064e20ce4160ea8a4d2a797755a44065422ad6d71b9d8443355825","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:tolbert.data","uri":"program://TOLBERT/module/tolbert.data#L1-L221","kind":"module","name":"tolbert.data","path":"tolbert/data.py","language":"python","start_line":1,"end_line":221,"context_start_line":1,"context_end_line":221,"code":"from __future__ import annotations\n\nimport json\nfrom dataclasses import dataclass\nfrom typing import Dict, List, Optional, Any\n\nimport torch\nfrom torch.utils.data import Dataset\nfrom transformers import PreTrainedTokenizerBase\n\n\n@dataclass\nclass SpanRecord:\n    text: str\n    # Canonical single path used for per-level classification targets.\n    node_path: Optional[List[int]]\n    # Full raw record, which may include richer DAG-style fields such as\n    # `node_paths` (multiple valid paths) in addition to `node_path`.\n    raw: Dict[str, Any]\n\n\nclass TreeOfLifeDataset(Dataset):\n    \"\"\"\n    Minimal dataset for TOLBERT training.\n\n    Assumes a JSONL `spans_file` where each line looks like:\n        {\n          \"span_id\": \"s0\",\n          \"text\": \"def forward(...):\",\n          \"node_path\": [0, 1, 2, 10]   # optional but recommended\n        }\n\n    You are free to extend this to include per-level fields instead of\n    `node_path` (e.g., `level_1_id`, `level_2_id`, ...). This class is\n    intentionally simple and meant as a starting point.\n    \"\"\"\n\n    def __init__(\n        self,\n        spans_file: str,\n        tokenizer: PreTrainedTokenizerBase,\n        max_length: int = 256,\n        mask_probability: float = 0.15,\n    ) -> None:\n        self.spans_file = spans_file\n        self.tokenizer = tokenizer\n        self.max_length = max_length\n        self.mask_probability = mask_probability\n\n        self._records: List[SpanRecord] = []\n        with open(spans_file, \"r\", encoding=\"utf-8\") as f:\n            for line in f:\n                line = line.strip()\n                if not line:\n                    continue\n                obj = json.loads(line)\n                text = obj[\"text\"]\n\n                # Support both legacy single-path and richer DAG-style formats:\n                #   - \"node_path\": [v0, v1, ..., vK]\n                #   - \"node_paths\": [[v0, v1, ..., vK], [v0, v1', ..., vK'], ...]\n                #\n                # We keep a single canonical path (first path if multiple are\n                # provided) for per-level classification, while preserving the\n                # richer structure in `raw` for path-consistency and\n                # contrastive losses.\n                node_path: Optional[List[int]] = None\n                if \"node_paths\" in obj and obj[\"node_paths\"] is not None:\n                    paths_val = obj[\"node_paths\"]\n                    if isinstance(paths_val, list) and paths_val:\n                        first = paths_val[0]\n                        if isinstance(first, (list, tuple)):\n                            node_path = [int(x) for x in first]\n                elif \"node_path\" in obj and obj[\"node_path\"] is not None:\n                    single = obj[\"node_path\"]\n                    if isinstance(single, (list, tuple)):\n                        node_path = [int(x) for x in single]\n\n                self._records.append(SpanRecord(text=text, node_path=node_path, raw=obj))\n\n    def __len__(self) -> int:\n        return len(self._records)\n\n    def _tokenize(self, text: str) -> Dict[str, torch.Tensor]:\n        enc = self.tokenizer(\n            text,\n            return_tensors=\"pt\",\n            truncation=True,\n            padding=\"max_length\",\n            max_length=self.max_length,\n        )\n        # drop batch dimension\n        return {k: v.squeeze(0) for k, v in enc.items()}\n\n    def _make_mlm_labels(self, input_ids: torch.Tensor) -> torch.Tensor:\n        \"\"\"\n        Very small, self-contained dynamic masking implementation.\n\n        - 15% of non-special tokens are selected for prediction.\n        - Of those, 80% replaced with [MASK], 10% with random token,\n          10% left unchanged (BERT-style).\n        \"\"\"\n        labels = input_ids.clone()\n\n        if not hasattr(self.tokenizer, \"get_special_tokens_mask\"):\n            # Fallback: treat everything as non-special\n            special_tokens_mask = torch.zeros_like(input_ids, dtype=torch.bool)\n        else:\n            special_tokens_mask = torch.tensor(\n                self.tokenizer.get_special_tokens_mask(\n                    input_ids.tolist(), already_has_special_tokens=True\n                ),\n                dtype=torch.bool,\n            )\n\n        # mask candidates: non-special tokens\n        probability_matrix = torch.full(labels.shape, self.mask_probability)\n        probability_matrix.masked_fill_(special_tokens_mask, value=0.0)\n\n        masked_indices = torch.bernoulli(probability_matrix).bool()\n        labels[~masked_indices] = -100  # ignore index for unmasked tokens\n\n        # 80% of selected tokens -> [MASK]\n        indices_replaced = torch.bernoulli(torch.full(labels.shape, 0.8)).bool() & masked_indices\n        mask_token_id = self.tokenizer.mask_token_id\n        if mask_token_id is not None:\n            input_ids[indices_replaced] = mask_token_id\n\n        # 10% of selected tokens -> random token\n        indices_random = (\n            torch.bernoulli(torch.full(labels.shape, 0.5)).bool()\n            & masked_indices\n            & ~indices_replaced\n        )\n        random_words = torch.randint(\n            low=0,\n            high=self.tokenizer.vocab_size,\n            size=labels.shape,\n            dtype=torch.long,\n        )\n        input_ids[indices_random] = random_words[indices_random]\n\n        # 10% remain unchanged\n        return labels\n\n    def __getitem__(self, idx: int) -> Dict[str, Any]:\n        rec = self._records[idx]\n        tokens = self._tokenize(rec.text)\n\n        input_ids = tokens[\"input_ids\"]\n        attention_mask = tokens.get(\"attention_mask\", torch.ones_like(input_ids))\n        labels_mlm = self._make_mlm_labels(input_ids.clone())\n\n        # Build per-level targets from canonical node_path if available.\n        level_targets: Dict[int, int] = {}\n        if rec.node_path is not None:\n            for level, node_id in enumerate(rec.node_path):\n                # Level 0 is typically the root; skip if you don't train on it.\n                if level == 0:\n                    continue\n                level_targets[level] = int(node_id)\n\n        sample: Dict[str, Any] = {\n            \"input_ids\": input_ids,\n            \"attention_mask\": attention_mask,\n            \"labels_mlm\": labels_mlm,\n            \"level_targets\": level_targets,\n        }\n\n        # Keep the full path information around for path-consistency and\n        # contrastive losses. Prefer a richer `node_paths` field (multiple\n        # valid paths for DAGs / multi-parent ontologies) if present; fall\n        # back to a single `node_path` otherwise.\n        paths = rec.raw.get(\"node_paths\")\n        if paths is None and rec.node_path is not None:\n            paths = [list(rec.node_path)]\n        if paths is not None:\n            sample[\"paths\"] = paths\n\n        return sample\n\n\ndef collate_tree_of_life_batch(batch: List[Dict[str, Any]]) -> Dict[str, Any]:\n    \"\"\"\n    Custom collate_fn to handle:\n      - dict-of-tensors for `level_targets`\n      - list-of-paths for contrastive loss\n    \"\"\"\n    # Simple stack for standard fields\n    input_ids = torch.stack([b[\"input_ids\"] for b in batch], dim=0)\n    attention_mask = torch.stack([b[\"attention_mask\"] for b in batch], dim=0)\n    labels_mlm = torch.stack([b[\"labels_mlm\"] for b in batch], dim=0)\n\n    # Merge level_targets into dict[level] -> tensor(batch,)\n    # Collect all levels that appear in any sample.\n    all_levels = set()\n    for b in batch:\n        all_levels.update(b[\"level_targets\"].keys())\n\n    level_targets: Dict[int, torch.Tensor] = {}\n    for level in sorted(all_levels):\n        targets_for_level = []\n        for b in batch:\n            # Use -100 for \"unknown\" / missing level for this sample\n            targets_for_level.append(b[\"level_targets\"].get(level, -100))\n        level_targets[level] = torch.tensor(targets_for_level, dtype=torch.long)\n\n    out: Dict[str, Any] = {\n        \"input_ids\": input_ids,\n        \"attention_mask\": attention_mask,\n        \"labels_mlm\": labels_mlm,\n        \"level_targets\": level_targets,\n    }\n\n    # Optional paths for contrastive loss\n    if all(\"paths\" in b for b in batch):\n        out[\"paths\"] = [b[\"paths\"] for b in batch]\n\n    return out\n\n","source_hash":"e1b347cb34f4a22a8a9bcc3759f305f97da1daf4cfd19b35ca34c618ee3cdf03","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:tolbert.data.SpanRecord","uri":"program://TOLBERT/class/tolbert.data.SpanRecord#L13-L19","kind":"class","name":"SpanRecord","path":"tolbert/data.py","language":"python","start_line":13,"end_line":19,"context_start_line":1,"context_end_line":39,"code":"from __future__ import annotations\n\nimport json\nfrom dataclasses import dataclass\nfrom typing import Dict, List, Optional, Any\n\nimport torch\nfrom torch.utils.data import Dataset\nfrom transformers import PreTrainedTokenizerBase\n\n\n@dataclass\nclass SpanRecord:\n    text: str\n    # Canonical single path used for per-level classification targets.\n    node_path: Optional[List[int]]\n    # Full raw record, which may include richer DAG-style fields such as\n    # `node_paths` (multiple valid paths) in addition to `node_path`.\n    raw: Dict[str, Any]\n\n\nclass TreeOfLifeDataset(Dataset):\n    \"\"\"\n    Minimal dataset for TOLBERT training.\n\n    Assumes a JSONL `spans_file` where each line looks like:\n        {\n          \"span_id\": \"s0\",\n          \"text\": \"def forward(...):\",\n          \"node_path\": [0, 1, 2, 10]   # optional but recommended\n        }\n\n    You are free to extend this to include per-level fields instead of\n    `node_path` (e.g., `level_1_id`, `level_2_id`, ...). This class is\n    intentionally simple and meant as a starting point.\n    \"\"\"\n\n    def __init__(\n        self,","source_hash":"e1b347cb34f4a22a8a9bcc3759f305f97da1daf4cfd19b35ca34c618ee3cdf03","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:tolbert.data.TreeOfLifeDataset","uri":"program://TOLBERT/class/tolbert.data.TreeOfLifeDataset#L22-L180","kind":"class","name":"TreeOfLifeDataset","path":"tolbert/data.py","language":"python","start_line":22,"end_line":180,"context_start_line":2,"context_end_line":200,"code":"\nimport json\nfrom dataclasses import dataclass\nfrom typing import Dict, List, Optional, Any\n\nimport torch\nfrom torch.utils.data import Dataset\nfrom transformers import PreTrainedTokenizerBase\n\n\n@dataclass\nclass SpanRecord:\n    text: str\n    # Canonical single path used for per-level classification targets.\n    node_path: Optional[List[int]]\n    # Full raw record, which may include richer DAG-style fields such as\n    # `node_paths` (multiple valid paths) in addition to `node_path`.\n    raw: Dict[str, Any]\n\n\nclass TreeOfLifeDataset(Dataset):\n    \"\"\"\n    Minimal dataset for TOLBERT training.\n\n    Assumes a JSONL `spans_file` where each line looks like:\n        {\n          \"span_id\": \"s0\",\n          \"text\": \"def forward(...):\",\n          \"node_path\": [0, 1, 2, 10]   # optional but recommended\n        }\n\n    You are free to extend this to include per-level fields instead of\n    `node_path` (e.g., `level_1_id`, `level_2_id`, ...). This class is\n    intentionally simple and meant as a starting point.\n    \"\"\"\n\n    def __init__(\n        self,\n        spans_file: str,\n        tokenizer: PreTrainedTokenizerBase,\n        max_length: int = 256,\n        mask_probability: float = 0.15,\n    ) -> None:\n        self.spans_file = spans_file\n        self.tokenizer = tokenizer\n        self.max_length = max_length\n        self.mask_probability = mask_probability\n\n        self._records: List[SpanRecord] = []\n        with open(spans_file, \"r\", encoding=\"utf-8\") as f:\n            for line in f:\n                line = line.strip()\n                if not line:\n                    continue\n                obj = json.loads(line)\n                text = obj[\"text\"]\n\n                # Support both legacy single-path and richer DAG-style formats:\n                #   - \"node_path\": [v0, v1, ..., vK]\n                #   - \"node_paths\": [[v0, v1, ..., vK], [v0, v1', ..., vK'], ...]\n                #\n                # We keep a single canonical path (first path if multiple are\n                # provided) for per-level classification, while preserving the\n                # richer structure in `raw` for path-consistency and\n                # contrastive losses.\n                node_path: Optional[List[int]] = None\n                if \"node_paths\" in obj and obj[\"node_paths\"] is not None:\n                    paths_val = obj[\"node_paths\"]\n                    if isinstance(paths_val, list) and paths_val:\n                        first = paths_val[0]\n                        if isinstance(first, (list, tuple)):\n                            node_path = [int(x) for x in first]\n                elif \"node_path\" in obj and obj[\"node_path\"] is not None:\n                    single = obj[\"node_path\"]\n                    if isinstance(single, (list, tuple)):\n                        node_path = [int(x) for x in single]\n\n                self._records.append(SpanRecord(text=text, node_path=node_path, raw=obj))\n\n    def __len__(self) -> int:\n        return len(self._records)\n\n    def _tokenize(self, text: str) -> Dict[str, torch.Tensor]:\n        enc = self.tokenizer(\n            text,\n            return_tensors=\"pt\",\n            truncation=True,\n            padding=\"max_length\",\n            max_length=self.max_length,\n        )\n        # drop batch dimension\n        return {k: v.squeeze(0) for k, v in enc.items()}\n\n    def _make_mlm_labels(self, input_ids: torch.Tensor) -> torch.Tensor:\n        \"\"\"\n        Very small, self-contained dynamic masking implementation.\n\n        - 15% of non-special tokens are selected for prediction.\n        - Of those, 80% replaced with [MASK], 10% with random token,\n          10% left unchanged (BERT-style).\n        \"\"\"\n        labels = input_ids.clone()\n\n        if not hasattr(self.tokenizer, \"get_special_tokens_mask\"):\n            # Fallback: treat everything as non-special\n            special_tokens_mask = torch.zeros_like(input_ids, dtype=torch.bool)\n        else:\n            special_tokens_mask = torch.tensor(\n                self.tokenizer.get_special_tokens_mask(\n                    input_ids.tolist(), already_has_special_tokens=True\n                ),\n                dtype=torch.bool,\n            )\n\n        # mask candidates: non-special tokens\n        probability_matrix = torch.full(labels.shape, self.mask_probability)\n        probability_matrix.masked_fill_(special_tokens_mask, value=0.0)\n\n        masked_indices = torch.bernoulli(probability_matrix).bool()\n        labels[~masked_indices] = -100  # ignore index for unmasked tokens\n\n        # 80% of selected tokens -> [MASK]\n        indices_replaced = torch.bernoulli(torch.full(labels.shape, 0.8)).bool() & masked_indices\n        mask_token_id = self.tokenizer.mask_token_id\n        if mask_token_id is not None:\n            input_ids[indices_replaced] = mask_token_id\n\n        # 10% of selected tokens -> random token\n        indices_random = (\n            torch.bernoulli(torch.full(labels.shape, 0.5)).bool()\n            & masked_indices\n            & ~indices_replaced\n        )\n        random_words = torch.randint(\n            low=0,\n            high=self.tokenizer.vocab_size,\n            size=labels.shape,\n            dtype=torch.long,\n        )\n        input_ids[indices_random] = random_words[indices_random]\n\n        # 10% remain unchanged\n        return labels\n\n    def __getitem__(self, idx: int) -> Dict[str, Any]:\n        rec = self._records[idx]\n        tokens = self._tokenize(rec.text)\n\n        input_ids = tokens[\"input_ids\"]\n        attention_mask = tokens.get(\"attention_mask\", torch.ones_like(input_ids))\n        labels_mlm = self._make_mlm_labels(input_ids.clone())\n\n        # Build per-level targets from canonical node_path if available.\n        level_targets: Dict[int, int] = {}\n        if rec.node_path is not None:\n            for level, node_id in enumerate(rec.node_path):\n                # Level 0 is typically the root; skip if you don't train on it.\n                if level == 0:\n                    continue\n                level_targets[level] = int(node_id)\n\n        sample: Dict[str, Any] = {\n            \"input_ids\": input_ids,\n            \"attention_mask\": attention_mask,\n            \"labels_mlm\": labels_mlm,\n            \"level_targets\": level_targets,\n        }\n\n        # Keep the full path information around for path-consistency and\n        # contrastive losses. Prefer a richer `node_paths` field (multiple\n        # valid paths for DAGs / multi-parent ontologies) if present; fall\n        # back to a single `node_path` otherwise.\n        paths = rec.raw.get(\"node_paths\")\n        if paths is None and rec.node_path is not None:\n            paths = [list(rec.node_path)]\n        if paths is not None:\n            sample[\"paths\"] = paths\n\n        return sample\n\n\ndef collate_tree_of_life_batch(batch: List[Dict[str, Any]]) -> Dict[str, Any]:\n    \"\"\"\n    Custom collate_fn to handle:\n      - dict-of-tensors for `level_targets`\n      - list-of-paths for contrastive loss\n    \"\"\"\n    # Simple stack for standard fields\n    input_ids = torch.stack([b[\"input_ids\"] for b in batch], dim=0)\n    attention_mask = torch.stack([b[\"attention_mask\"] for b in batch], dim=0)\n    labels_mlm = torch.stack([b[\"labels_mlm\"] for b in batch], dim=0)\n\n    # Merge level_targets into dict[level] -> tensor(batch,)\n    # Collect all levels that appear in any sample.\n    all_levels = set()\n    for b in batch:\n        all_levels.update(b[\"level_targets\"].keys())\n\n    level_targets: Dict[int, torch.Tensor] = {}","source_hash":"e1b347cb34f4a22a8a9bcc3759f305f97da1daf4cfd19b35ca34c618ee3cdf03","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:tolbert.data.collate_tree_of_life_batch","uri":"program://TOLBERT/function/tolbert.data.collate_tree_of_life_batch#L183-L219","kind":"function","name":"collate_tree_of_life_batch","path":"tolbert/data.py","language":"python","start_line":183,"end_line":219,"context_start_line":163,"context_end_line":221,"code":"        sample: Dict[str, Any] = {\n            \"input_ids\": input_ids,\n            \"attention_mask\": attention_mask,\n            \"labels_mlm\": labels_mlm,\n            \"level_targets\": level_targets,\n        }\n\n        # Keep the full path information around for path-consistency and\n        # contrastive losses. Prefer a richer `node_paths` field (multiple\n        # valid paths for DAGs / multi-parent ontologies) if present; fall\n        # back to a single `node_path` otherwise.\n        paths = rec.raw.get(\"node_paths\")\n        if paths is None and rec.node_path is not None:\n            paths = [list(rec.node_path)]\n        if paths is not None:\n            sample[\"paths\"] = paths\n\n        return sample\n\n\ndef collate_tree_of_life_batch(batch: List[Dict[str, Any]]) -> Dict[str, Any]:\n    \"\"\"\n    Custom collate_fn to handle:\n      - dict-of-tensors for `level_targets`\n      - list-of-paths for contrastive loss\n    \"\"\"\n    # Simple stack for standard fields\n    input_ids = torch.stack([b[\"input_ids\"] for b in batch], dim=0)\n    attention_mask = torch.stack([b[\"attention_mask\"] for b in batch], dim=0)\n    labels_mlm = torch.stack([b[\"labels_mlm\"] for b in batch], dim=0)\n\n    # Merge level_targets into dict[level] -> tensor(batch,)\n    # Collect all levels that appear in any sample.\n    all_levels = set()\n    for b in batch:\n        all_levels.update(b[\"level_targets\"].keys())\n\n    level_targets: Dict[int, torch.Tensor] = {}\n    for level in sorted(all_levels):\n        targets_for_level = []\n        for b in batch:\n            # Use -100 for \"unknown\" / missing level for this sample\n            targets_for_level.append(b[\"level_targets\"].get(level, -100))\n        level_targets[level] = torch.tensor(targets_for_level, dtype=torch.long)\n\n    out: Dict[str, Any] = {\n        \"input_ids\": input_ids,\n        \"attention_mask\": attention_mask,\n        \"labels_mlm\": labels_mlm,\n        \"level_targets\": level_targets,\n    }\n\n    # Optional paths for contrastive loss\n    if all(\"paths\" in b for b in batch):\n        out[\"paths\"] = [b[\"paths\"] for b in batch]\n\n    return out\n\n","source_hash":"e1b347cb34f4a22a8a9bcc3759f305f97da1daf4cfd19b35ca34c618ee3cdf03","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:tolbert.data.__init__","uri":"program://TOLBERT/function/tolbert.data.__init__#L38-L79","kind":"function","name":"__init__","path":"tolbert/data.py","language":"python","start_line":38,"end_line":79,"context_start_line":18,"context_end_line":99,"code":"    # `node_paths` (multiple valid paths) in addition to `node_path`.\n    raw: Dict[str, Any]\n\n\nclass TreeOfLifeDataset(Dataset):\n    \"\"\"\n    Minimal dataset for TOLBERT training.\n\n    Assumes a JSONL `spans_file` where each line looks like:\n        {\n          \"span_id\": \"s0\",\n          \"text\": \"def forward(...):\",\n          \"node_path\": [0, 1, 2, 10]   # optional but recommended\n        }\n\n    You are free to extend this to include per-level fields instead of\n    `node_path` (e.g., `level_1_id`, `level_2_id`, ...). This class is\n    intentionally simple and meant as a starting point.\n    \"\"\"\n\n    def __init__(\n        self,\n        spans_file: str,\n        tokenizer: PreTrainedTokenizerBase,\n        max_length: int = 256,\n        mask_probability: float = 0.15,\n    ) -> None:\n        self.spans_file = spans_file\n        self.tokenizer = tokenizer\n        self.max_length = max_length\n        self.mask_probability = mask_probability\n\n        self._records: List[SpanRecord] = []\n        with open(spans_file, \"r\", encoding=\"utf-8\") as f:\n            for line in f:\n                line = line.strip()\n                if not line:\n                    continue\n                obj = json.loads(line)\n                text = obj[\"text\"]\n\n                # Support both legacy single-path and richer DAG-style formats:\n                #   - \"node_path\": [v0, v1, ..., vK]\n                #   - \"node_paths\": [[v0, v1, ..., vK], [v0, v1', ..., vK'], ...]\n                #\n                # We keep a single canonical path (first path if multiple are\n                # provided) for per-level classification, while preserving the\n                # richer structure in `raw` for path-consistency and\n                # contrastive losses.\n                node_path: Optional[List[int]] = None\n                if \"node_paths\" in obj and obj[\"node_paths\"] is not None:\n                    paths_val = obj[\"node_paths\"]\n                    if isinstance(paths_val, list) and paths_val:\n                        first = paths_val[0]\n                        if isinstance(first, (list, tuple)):\n                            node_path = [int(x) for x in first]\n                elif \"node_path\" in obj and obj[\"node_path\"] is not None:\n                    single = obj[\"node_path\"]\n                    if isinstance(single, (list, tuple)):\n                        node_path = [int(x) for x in single]\n\n                self._records.append(SpanRecord(text=text, node_path=node_path, raw=obj))\n\n    def __len__(self) -> int:\n        return len(self._records)\n\n    def _tokenize(self, text: str) -> Dict[str, torch.Tensor]:\n        enc = self.tokenizer(\n            text,\n            return_tensors=\"pt\",\n            truncation=True,\n            padding=\"max_length\",\n            max_length=self.max_length,\n        )\n        # drop batch dimension\n        return {k: v.squeeze(0) for k, v in enc.items()}\n\n    def _make_mlm_labels(self, input_ids: torch.Tensor) -> torch.Tensor:\n        \"\"\"\n        Very small, self-contained dynamic masking implementation.\n\n        - 15% of non-special tokens are selected for prediction.","source_hash":"e1b347cb34f4a22a8a9bcc3759f305f97da1daf4cfd19b35ca34c618ee3cdf03","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:tolbert.data.__len__","uri":"program://TOLBERT/function/tolbert.data.__len__#L81-L82","kind":"function","name":"__len__","path":"tolbert/data.py","language":"python","start_line":81,"end_line":82,"context_start_line":61,"context_end_line":102,"code":"                #   - \"node_paths\": [[v0, v1, ..., vK], [v0, v1', ..., vK'], ...]\n                #\n                # We keep a single canonical path (first path if multiple are\n                # provided) for per-level classification, while preserving the\n                # richer structure in `raw` for path-consistency and\n                # contrastive losses.\n                node_path: Optional[List[int]] = None\n                if \"node_paths\" in obj and obj[\"node_paths\"] is not None:\n                    paths_val = obj[\"node_paths\"]\n                    if isinstance(paths_val, list) and paths_val:\n                        first = paths_val[0]\n                        if isinstance(first, (list, tuple)):\n                            node_path = [int(x) for x in first]\n                elif \"node_path\" in obj and obj[\"node_path\"] is not None:\n                    single = obj[\"node_path\"]\n                    if isinstance(single, (list, tuple)):\n                        node_path = [int(x) for x in single]\n\n                self._records.append(SpanRecord(text=text, node_path=node_path, raw=obj))\n\n    def __len__(self) -> int:\n        return len(self._records)\n\n    def _tokenize(self, text: str) -> Dict[str, torch.Tensor]:\n        enc = self.tokenizer(\n            text,\n            return_tensors=\"pt\",\n            truncation=True,\n            padding=\"max_length\",\n            max_length=self.max_length,\n        )\n        # drop batch dimension\n        return {k: v.squeeze(0) for k, v in enc.items()}\n\n    def _make_mlm_labels(self, input_ids: torch.Tensor) -> torch.Tensor:\n        \"\"\"\n        Very small, self-contained dynamic masking implementation.\n\n        - 15% of non-special tokens are selected for prediction.\n        - Of those, 80% replaced with [MASK], 10% with random token,\n          10% left unchanged (BERT-style).\n        \"\"\"","source_hash":"e1b347cb34f4a22a8a9bcc3759f305f97da1daf4cfd19b35ca34c618ee3cdf03","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:tolbert.data._tokenize","uri":"program://TOLBERT/function/tolbert.data._tokenize#L84-L93","kind":"function","name":"_tokenize","path":"tolbert/data.py","language":"python","start_line":84,"end_line":93,"context_start_line":64,"context_end_line":113,"code":"                # provided) for per-level classification, while preserving the\n                # richer structure in `raw` for path-consistency and\n                # contrastive losses.\n                node_path: Optional[List[int]] = None\n                if \"node_paths\" in obj and obj[\"node_paths\"] is not None:\n                    paths_val = obj[\"node_paths\"]\n                    if isinstance(paths_val, list) and paths_val:\n                        first = paths_val[0]\n                        if isinstance(first, (list, tuple)):\n                            node_path = [int(x) for x in first]\n                elif \"node_path\" in obj and obj[\"node_path\"] is not None:\n                    single = obj[\"node_path\"]\n                    if isinstance(single, (list, tuple)):\n                        node_path = [int(x) for x in single]\n\n                self._records.append(SpanRecord(text=text, node_path=node_path, raw=obj))\n\n    def __len__(self) -> int:\n        return len(self._records)\n\n    def _tokenize(self, text: str) -> Dict[str, torch.Tensor]:\n        enc = self.tokenizer(\n            text,\n            return_tensors=\"pt\",\n            truncation=True,\n            padding=\"max_length\",\n            max_length=self.max_length,\n        )\n        # drop batch dimension\n        return {k: v.squeeze(0) for k, v in enc.items()}\n\n    def _make_mlm_labels(self, input_ids: torch.Tensor) -> torch.Tensor:\n        \"\"\"\n        Very small, self-contained dynamic masking implementation.\n\n        - 15% of non-special tokens are selected for prediction.\n        - Of those, 80% replaced with [MASK], 10% with random token,\n          10% left unchanged (BERT-style).\n        \"\"\"\n        labels = input_ids.clone()\n\n        if not hasattr(self.tokenizer, \"get_special_tokens_mask\"):\n            # Fallback: treat everything as non-special\n            special_tokens_mask = torch.zeros_like(input_ids, dtype=torch.bool)\n        else:\n            special_tokens_mask = torch.tensor(\n                self.tokenizer.get_special_tokens_mask(\n                    input_ids.tolist(), already_has_special_tokens=True\n                ),\n                dtype=torch.bool,","source_hash":"e1b347cb34f4a22a8a9bcc3759f305f97da1daf4cfd19b35ca34c618ee3cdf03","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:tolbert.data._make_mlm_labels","uri":"program://TOLBERT/function/tolbert.data._make_mlm_labels#L95-L144","kind":"function","name":"_make_mlm_labels","path":"tolbert/data.py","language":"python","start_line":95,"end_line":144,"context_start_line":75,"context_end_line":164,"code":"                    single = obj[\"node_path\"]\n                    if isinstance(single, (list, tuple)):\n                        node_path = [int(x) for x in single]\n\n                self._records.append(SpanRecord(text=text, node_path=node_path, raw=obj))\n\n    def __len__(self) -> int:\n        return len(self._records)\n\n    def _tokenize(self, text: str) -> Dict[str, torch.Tensor]:\n        enc = self.tokenizer(\n            text,\n            return_tensors=\"pt\",\n            truncation=True,\n            padding=\"max_length\",\n            max_length=self.max_length,\n        )\n        # drop batch dimension\n        return {k: v.squeeze(0) for k, v in enc.items()}\n\n    def _make_mlm_labels(self, input_ids: torch.Tensor) -> torch.Tensor:\n        \"\"\"\n        Very small, self-contained dynamic masking implementation.\n\n        - 15% of non-special tokens are selected for prediction.\n        - Of those, 80% replaced with [MASK], 10% with random token,\n          10% left unchanged (BERT-style).\n        \"\"\"\n        labels = input_ids.clone()\n\n        if not hasattr(self.tokenizer, \"get_special_tokens_mask\"):\n            # Fallback: treat everything as non-special\n            special_tokens_mask = torch.zeros_like(input_ids, dtype=torch.bool)\n        else:\n            special_tokens_mask = torch.tensor(\n                self.tokenizer.get_special_tokens_mask(\n                    input_ids.tolist(), already_has_special_tokens=True\n                ),\n                dtype=torch.bool,\n            )\n\n        # mask candidates: non-special tokens\n        probability_matrix = torch.full(labels.shape, self.mask_probability)\n        probability_matrix.masked_fill_(special_tokens_mask, value=0.0)\n\n        masked_indices = torch.bernoulli(probability_matrix).bool()\n        labels[~masked_indices] = -100  # ignore index for unmasked tokens\n\n        # 80% of selected tokens -> [MASK]\n        indices_replaced = torch.bernoulli(torch.full(labels.shape, 0.8)).bool() & masked_indices\n        mask_token_id = self.tokenizer.mask_token_id\n        if mask_token_id is not None:\n            input_ids[indices_replaced] = mask_token_id\n\n        # 10% of selected tokens -> random token\n        indices_random = (\n            torch.bernoulli(torch.full(labels.shape, 0.5)).bool()\n            & masked_indices\n            & ~indices_replaced\n        )\n        random_words = torch.randint(\n            low=0,\n            high=self.tokenizer.vocab_size,\n            size=labels.shape,\n            dtype=torch.long,\n        )\n        input_ids[indices_random] = random_words[indices_random]\n\n        # 10% remain unchanged\n        return labels\n\n    def __getitem__(self, idx: int) -> Dict[str, Any]:\n        rec = self._records[idx]\n        tokens = self._tokenize(rec.text)\n\n        input_ids = tokens[\"input_ids\"]\n        attention_mask = tokens.get(\"attention_mask\", torch.ones_like(input_ids))\n        labels_mlm = self._make_mlm_labels(input_ids.clone())\n\n        # Build per-level targets from canonical node_path if available.\n        level_targets: Dict[int, int] = {}\n        if rec.node_path is not None:\n            for level, node_id in enumerate(rec.node_path):\n                # Level 0 is typically the root; skip if you don't train on it.\n                if level == 0:\n                    continue\n                level_targets[level] = int(node_id)\n\n        sample: Dict[str, Any] = {\n            \"input_ids\": input_ids,","source_hash":"e1b347cb34f4a22a8a9bcc3759f305f97da1daf4cfd19b35ca34c618ee3cdf03","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:tolbert.data.__getitem__","uri":"program://TOLBERT/function/tolbert.data.__getitem__#L146-L180","kind":"function","name":"__getitem__","path":"tolbert/data.py","language":"python","start_line":146,"end_line":180,"context_start_line":126,"context_end_line":200,"code":"        if mask_token_id is not None:\n            input_ids[indices_replaced] = mask_token_id\n\n        # 10% of selected tokens -> random token\n        indices_random = (\n            torch.bernoulli(torch.full(labels.shape, 0.5)).bool()\n            & masked_indices\n            & ~indices_replaced\n        )\n        random_words = torch.randint(\n            low=0,\n            high=self.tokenizer.vocab_size,\n            size=labels.shape,\n            dtype=torch.long,\n        )\n        input_ids[indices_random] = random_words[indices_random]\n\n        # 10% remain unchanged\n        return labels\n\n    def __getitem__(self, idx: int) -> Dict[str, Any]:\n        rec = self._records[idx]\n        tokens = self._tokenize(rec.text)\n\n        input_ids = tokens[\"input_ids\"]\n        attention_mask = tokens.get(\"attention_mask\", torch.ones_like(input_ids))\n        labels_mlm = self._make_mlm_labels(input_ids.clone())\n\n        # Build per-level targets from canonical node_path if available.\n        level_targets: Dict[int, int] = {}\n        if rec.node_path is not None:\n            for level, node_id in enumerate(rec.node_path):\n                # Level 0 is typically the root; skip if you don't train on it.\n                if level == 0:\n                    continue\n                level_targets[level] = int(node_id)\n\n        sample: Dict[str, Any] = {\n            \"input_ids\": input_ids,\n            \"attention_mask\": attention_mask,\n            \"labels_mlm\": labels_mlm,\n            \"level_targets\": level_targets,\n        }\n\n        # Keep the full path information around for path-consistency and\n        # contrastive losses. Prefer a richer `node_paths` field (multiple\n        # valid paths for DAGs / multi-parent ontologies) if present; fall\n        # back to a single `node_path` otherwise.\n        paths = rec.raw.get(\"node_paths\")\n        if paths is None and rec.node_path is not None:\n            paths = [list(rec.node_path)]\n        if paths is not None:\n            sample[\"paths\"] = paths\n\n        return sample\n\n\ndef collate_tree_of_life_batch(batch: List[Dict[str, Any]]) -> Dict[str, Any]:\n    \"\"\"\n    Custom collate_fn to handle:\n      - dict-of-tensors for `level_targets`\n      - list-of-paths for contrastive loss\n    \"\"\"\n    # Simple stack for standard fields\n    input_ids = torch.stack([b[\"input_ids\"] for b in batch], dim=0)\n    attention_mask = torch.stack([b[\"attention_mask\"] for b in batch], dim=0)\n    labels_mlm = torch.stack([b[\"labels_mlm\"] for b in batch], dim=0)\n\n    # Merge level_targets into dict[level] -> tensor(batch,)\n    # Collect all levels that appear in any sample.\n    all_levels = set()\n    for b in batch:\n        all_levels.update(b[\"level_targets\"].keys())\n\n    level_targets: Dict[int, torch.Tensor] = {}","source_hash":"e1b347cb34f4a22a8a9bcc3759f305f97da1daf4cfd19b35ca34c618ee3cdf03","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:tolbert.decoding","uri":"program://TOLBERT/module/tolbert.decoding#L1-L114","kind":"module","name":"tolbert.decoding","path":"tolbert/decoding.py","language":"python","start_line":1,"end_line":114,"context_start_line":1,"context_end_line":114,"code":"from __future__ import annotations\n\nfrom typing import Dict, List, Optional, Sequence\n\nimport torch\n\n\ndef greedy_hierarchical_decode(\n    level_logits: Dict[str, torch.Tensor],\n    parent_to_children: Dict[int, Dict[int, List[int]]],\n    levels: Optional[Sequence[int]] = None,\n) -> Dict[int, torch.Tensor]:\n    \"\"\"\n    Greedy top-down decoding of a hierarchical path with child masking.\n\n    This helper mirrors the inference-time procedure described in the TOLBERT\n    paper: for each level, predictions are restricted to children of the\n    previously chosen parent whenever a parent->children mapping is provided.\n\n    Args:\n        level_logits:\n            Mapping from level identifier (as used in TOLBERT.level_heads,\n            typically the string form of an integer like \\\"1\\\", \\\"2\\\", ...) to\n            a tensor of shape (batch, C_level) with logits for that level.\n        parent_to_children:\n            Mapping:\n                level_int -> { parent_idx -> [child_idx, ...] }\n            where indices are in the same class-index space as the logits for\n            that level. For example, for level 2, parent indices live at\n            level 1 and child indices live at level 2.\n        levels:\n            Optional explicit decoding order, e.g. [1, 2, 3]. If omitted, the\n            function sorts the integer level keys found in `level_logits`.\n\n    Returns:\n        dict[level_int] -> tensor(batch,) of predicted class indices per level.\n\n    Notes:\n        - If no children are registered for a given (level, parent_idx), the\n          decoder falls back to an unconstrained argmax over that level's\n          logits for that example.\n        - This helper does not assume anything about how node ids are\n          assigned; it only assumes that the indices in `parent_to_children`\n          are valid indices into the corresponding logits.\n    \"\"\"\n    if not level_logits:\n        return {}\n\n    # Determine decoding order\n    if levels is not None and len(levels) > 0:\n        order = list(levels)\n    else:\n        order = sorted(int(k) for k in level_logits.keys())\n\n    # Sanity: ensure we have logits for all requested levels\n    order = [lvl for lvl in order if str(lvl) in level_logits]\n    if not order:\n        return {}\n\n    batch_size = next(iter(level_logits.values())).size(0)\n    device = next(iter(level_logits.values())).device\n\n    preds: Dict[int, torch.Tensor] = {}\n\n    # First level: plain argmax\n    first_level = order[0]\n    first_logits = level_logits[str(first_level)]\n    preds[first_level] = first_logits.argmax(dim=-1)\n\n    # Subsequent levels: mask by children whenever possible\n    for idx in range(1, len(order)):\n        level = order[idx]\n        prev_level = order[idx - 1]\n\n        logits = level_logits[str(level)]  # (B, C_level)\n        parent_map = parent_to_children.get(level, {})\n\n        # Default: unconstrained argmax for all examples\n        level_preds = logits.argmax(dim=-1)\n\n        if parent_map:\n            # Refine predictions where we know the parent->children mapping.\n            refined: List[int] = []\n            parent_preds = preds[prev_level]\n            for b in range(batch_size):\n                parent_idx = int(parent_preds[b].item())\n                children = parent_map.get(parent_idx)\n                if not children:\n                    # No constraints for this parent; keep unconstrained argmax.\n                    refined.append(int(level_preds[b].item()))\n                    continue\n\n                # Restrict logits to the valid children for this parent.\n                child_indices = torch.tensor(children, dtype=torch.long, device=device)\n                # Guard against out-of-range indices.\n                child_indices = child_indices[\n                    (child_indices >= 0) & (child_indices < logits.size(-1))\n                ]\n                if child_indices.numel() == 0:\n                    refined.append(int(level_preds[b].item()))\n                    continue\n\n                child_logits = logits[b, child_indices]\n                rel_idx = int(torch.argmax(child_logits).item())\n                refined.append(int(child_indices[rel_idx].item()))\n\n            level_preds = torch.tensor(refined, device=device, dtype=torch.long)\n\n        preds[level] = level_preds\n\n    return preds\n\n\n","source_hash":"2e77feda6009f2bea3c643ddd160f59ef48d6b0d72c51cace59fcdb8d57e3aee","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:tolbert.decoding.greedy_hierarchical_decode","uri":"program://TOLBERT/function/tolbert.decoding.greedy_hierarchical_decode#L8-L111","kind":"function","name":"greedy_hierarchical_decode","path":"tolbert/decoding.py","language":"python","start_line":8,"end_line":111,"context_start_line":1,"context_end_line":114,"code":"from __future__ import annotations\n\nfrom typing import Dict, List, Optional, Sequence\n\nimport torch\n\n\ndef greedy_hierarchical_decode(\n    level_logits: Dict[str, torch.Tensor],\n    parent_to_children: Dict[int, Dict[int, List[int]]],\n    levels: Optional[Sequence[int]] = None,\n) -> Dict[int, torch.Tensor]:\n    \"\"\"\n    Greedy top-down decoding of a hierarchical path with child masking.\n\n    This helper mirrors the inference-time procedure described in the TOLBERT\n    paper: for each level, predictions are restricted to children of the\n    previously chosen parent whenever a parent->children mapping is provided.\n\n    Args:\n        level_logits:\n            Mapping from level identifier (as used in TOLBERT.level_heads,\n            typically the string form of an integer like \\\"1\\\", \\\"2\\\", ...) to\n            a tensor of shape (batch, C_level) with logits for that level.\n        parent_to_children:\n            Mapping:\n                level_int -> { parent_idx -> [child_idx, ...] }\n            where indices are in the same class-index space as the logits for\n            that level. For example, for level 2, parent indices live at\n            level 1 and child indices live at level 2.\n        levels:\n            Optional explicit decoding order, e.g. [1, 2, 3]. If omitted, the\n            function sorts the integer level keys found in `level_logits`.\n\n    Returns:\n        dict[level_int] -> tensor(batch,) of predicted class indices per level.\n\n    Notes:\n        - If no children are registered for a given (level, parent_idx), the\n          decoder falls back to an unconstrained argmax over that level's\n          logits for that example.\n        - This helper does not assume anything about how node ids are\n          assigned; it only assumes that the indices in `parent_to_children`\n          are valid indices into the corresponding logits.\n    \"\"\"\n    if not level_logits:\n        return {}\n\n    # Determine decoding order\n    if levels is not None and len(levels) > 0:\n        order = list(levels)\n    else:\n        order = sorted(int(k) for k in level_logits.keys())\n\n    # Sanity: ensure we have logits for all requested levels\n    order = [lvl for lvl in order if str(lvl) in level_logits]\n    if not order:\n        return {}\n\n    batch_size = next(iter(level_logits.values())).size(0)\n    device = next(iter(level_logits.values())).device\n\n    preds: Dict[int, torch.Tensor] = {}\n\n    # First level: plain argmax\n    first_level = order[0]\n    first_logits = level_logits[str(first_level)]\n    preds[first_level] = first_logits.argmax(dim=-1)\n\n    # Subsequent levels: mask by children whenever possible\n    for idx in range(1, len(order)):\n        level = order[idx]\n        prev_level = order[idx - 1]\n\n        logits = level_logits[str(level)]  # (B, C_level)\n        parent_map = parent_to_children.get(level, {})\n\n        # Default: unconstrained argmax for all examples\n        level_preds = logits.argmax(dim=-1)\n\n        if parent_map:\n            # Refine predictions where we know the parent->children mapping.\n            refined: List[int] = []\n            parent_preds = preds[prev_level]\n            for b in range(batch_size):\n                parent_idx = int(parent_preds[b].item())\n                children = parent_map.get(parent_idx)\n                if not children:\n                    # No constraints for this parent; keep unconstrained argmax.\n                    refined.append(int(level_preds[b].item()))\n                    continue\n\n                # Restrict logits to the valid children for this parent.\n                child_indices = torch.tensor(children, dtype=torch.long, device=device)\n                # Guard against out-of-range indices.\n                child_indices = child_indices[\n                    (child_indices >= 0) & (child_indices < logits.size(-1))\n                ]\n                if child_indices.numel() == 0:\n                    refined.append(int(level_preds[b].item()))\n                    continue\n\n                child_logits = logits[b, child_indices]\n                rel_idx = int(torch.argmax(child_logits).item())\n                refined.append(int(child_indices[rel_idx].item()))\n\n            level_preds = torch.tensor(refined, device=device, dtype=torch.long)\n\n        preds[level] = level_preds\n\n    return preds\n\n\n","source_hash":"2e77feda6009f2bea3c643ddd160f59ef48d6b0d72c51cace59fcdb8d57e3aee","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:modules.program_graph","uri":"program://TOLBERT/module/modules.program_graph#L1-L123","kind":"module","name":"modules.program_graph","path":"modules/program_graph.py","language":"python","start_line":1,"end_line":123,"context_start_line":1,"context_end_line":123,"code":"from __future__ import annotations\n\nfrom dataclasses import dataclass, field\nfrom typing import Any, Dict, Iterable, List, Optional, Tuple\n\n\n# Basic identifiers\nEntityId = str\n\n\n@dataclass(frozen=True)\nclass Span:\n    \"\"\"Inclusive 1-based line span within an artifact.\"\"\"\n\n    start_line: int\n    end_line: int\n\n\n@dataclass\nclass Artifact:\n    \"\"\"\n    Minimal file-level artifact in a program graph.\n\n    - `uri` is typically a `program://` URI.\n    - `type` is a coarse tag such as \"source\", \"header\", \"binary\".\n    - `hash` is an implementation-defined content hash (may be empty).\n    - `span` is optional; whole-file artifacts can leave it as None.\n    \"\"\"\n\n    uri: str\n    type: str\n    hash: str\n    span: Optional[Span] = None\n\n\n@dataclass\nclass Entity:\n    \"\"\"\n    Logical entity in a program graph.\n\n    Common patterns:\n      - Repository / project node.\n      - File / module node.\n      - Function / method / class node.\n\n    `artifact_uri` and `span` are optional and only populated when the\n    entity corresponds to a concrete region in a file.\n    \"\"\"\n\n    id: EntityId\n    kind: str\n    uri: str\n    artifact_uri: Optional[str] = None\n    span: Optional[Span] = None\n    labels: List[str] = field(default_factory=list)\n    attributes: Dict[str, Any] = field(default_factory=dict)\n\n\n@dataclass\nclass Edge:\n    \"\"\"\n    Typed relationship between entities.\n\n    Typical edge types:\n      - \"owns\": containment (repo→file, file→function, module→class, ...)\n      - \"imports\": dependency between modules / files / packages\n      - \"calls\": function/method call\n      - \"tests\": test module or case covering a target\n      - \"similar_to\": embedding- or heuristic-based similarity\n    \"\"\"\n\n    src: EntityId\n    dst: EntityId\n    type: str\n    attributes: Dict[str, Any] = field(default_factory=dict)\n\n\n@dataclass\nclass ResolvedAnchor:\n    \"\"\"\n    Resolution of a URI back onto a concrete artifact region.\n    \"\"\"\n\n    artifact_uri: str\n    span: Span\n    hash: str\n\n\nclass ProgramGraph:\n    \"\"\"\n    Abstract, language-agnostic view over a program / repository.\n\n    Implementations are expected to provide at least:\n      - entities(): iterable of Entity nodes\n      - edges(): iterable of Edge relationships\n      - artifacts(): file-level view\n      - resolve(): URI → concrete anchor\n\n    Subclasses may add richer APIs as needed.\n    \"\"\"\n\n    # The default implementation is intentionally skeletal and returns\n    # empty views; concrete graphs should override these.\n\n    def entities(self) -> Iterable[Entity]:\n        return []\n\n    def edges(self) -> Iterable[Edge]:\n        return []\n\n    def artifacts(self, kind: str) -> Iterable[Artifact]:\n        return []\n\n    def resolve(self, uri: str) -> ResolvedAnchor:\n        raise NotImplementedError(\"resolve() must be implemented by subclasses\")\n\n    def search_refs(self, token: str) -> Iterable[Tuple[EntityId, Span]]:\n        return []\n\n    def subgraph(self, seeds: List[EntityId], radius: int) -> \"ProgramGraph\":\n        return self\n\n","source_hash":"f32dd991ecbf9067178a3703b1be0d4601f339d20349172993dd1ae4f9bfc3c3","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:modules.program_graph.Span","uri":"program://TOLBERT/class/modules.program_graph.Span#L12-L16","kind":"class","name":"Span","path":"modules/program_graph.py","language":"python","start_line":12,"end_line":16,"context_start_line":1,"context_end_line":36,"code":"from __future__ import annotations\n\nfrom dataclasses import dataclass, field\nfrom typing import Any, Dict, Iterable, List, Optional, Tuple\n\n\n# Basic identifiers\nEntityId = str\n\n\n@dataclass(frozen=True)\nclass Span:\n    \"\"\"Inclusive 1-based line span within an artifact.\"\"\"\n\n    start_line: int\n    end_line: int\n\n\n@dataclass\nclass Artifact:\n    \"\"\"\n    Minimal file-level artifact in a program graph.\n\n    - `uri` is typically a `program://` URI.\n    - `type` is a coarse tag such as \"source\", \"header\", \"binary\".\n    - `hash` is an implementation-defined content hash (may be empty).\n    - `span` is optional; whole-file artifacts can leave it as None.\n    \"\"\"\n\n    uri: str\n    type: str\n    hash: str\n    span: Optional[Span] = None\n\n\n@dataclass","source_hash":"f32dd991ecbf9067178a3703b1be0d4601f339d20349172993dd1ae4f9bfc3c3","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:modules.program_graph.Artifact","uri":"program://TOLBERT/class/modules.program_graph.Artifact#L20-L33","kind":"class","name":"Artifact","path":"modules/program_graph.py","language":"python","start_line":20,"end_line":33,"context_start_line":1,"context_end_line":53,"code":"from __future__ import annotations\n\nfrom dataclasses import dataclass, field\nfrom typing import Any, Dict, Iterable, List, Optional, Tuple\n\n\n# Basic identifiers\nEntityId = str\n\n\n@dataclass(frozen=True)\nclass Span:\n    \"\"\"Inclusive 1-based line span within an artifact.\"\"\"\n\n    start_line: int\n    end_line: int\n\n\n@dataclass\nclass Artifact:\n    \"\"\"\n    Minimal file-level artifact in a program graph.\n\n    - `uri` is typically a `program://` URI.\n    - `type` is a coarse tag such as \"source\", \"header\", \"binary\".\n    - `hash` is an implementation-defined content hash (may be empty).\n    - `span` is optional; whole-file artifacts can leave it as None.\n    \"\"\"\n\n    uri: str\n    type: str\n    hash: str\n    span: Optional[Span] = None\n\n\n@dataclass\nclass Entity:\n    \"\"\"\n    Logical entity in a program graph.\n\n    Common patterns:\n      - Repository / project node.\n      - File / module node.\n      - Function / method / class node.\n\n    `artifact_uri` and `span` are optional and only populated when the\n    entity corresponds to a concrete region in a file.\n    \"\"\"\n\n    id: EntityId\n    kind: str\n    uri: str\n    artifact_uri: Optional[str] = None","source_hash":"f32dd991ecbf9067178a3703b1be0d4601f339d20349172993dd1ae4f9bfc3c3","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:modules.program_graph.Entity","uri":"program://TOLBERT/class/modules.program_graph.Entity#L37-L56","kind":"class","name":"Entity","path":"modules/program_graph.py","language":"python","start_line":37,"end_line":56,"context_start_line":17,"context_end_line":76,"code":"\n\n@dataclass\nclass Artifact:\n    \"\"\"\n    Minimal file-level artifact in a program graph.\n\n    - `uri` is typically a `program://` URI.\n    - `type` is a coarse tag such as \"source\", \"header\", \"binary\".\n    - `hash` is an implementation-defined content hash (may be empty).\n    - `span` is optional; whole-file artifacts can leave it as None.\n    \"\"\"\n\n    uri: str\n    type: str\n    hash: str\n    span: Optional[Span] = None\n\n\n@dataclass\nclass Entity:\n    \"\"\"\n    Logical entity in a program graph.\n\n    Common patterns:\n      - Repository / project node.\n      - File / module node.\n      - Function / method / class node.\n\n    `artifact_uri` and `span` are optional and only populated when the\n    entity corresponds to a concrete region in a file.\n    \"\"\"\n\n    id: EntityId\n    kind: str\n    uri: str\n    artifact_uri: Optional[str] = None\n    span: Optional[Span] = None\n    labels: List[str] = field(default_factory=list)\n    attributes: Dict[str, Any] = field(default_factory=dict)\n\n\n@dataclass\nclass Edge:\n    \"\"\"\n    Typed relationship between entities.\n\n    Typical edge types:\n      - \"owns\": containment (repo→file, file→function, module→class, ...)\n      - \"imports\": dependency between modules / files / packages\n      - \"calls\": function/method call\n      - \"tests\": test module or case covering a target\n      - \"similar_to\": embedding- or heuristic-based similarity\n    \"\"\"\n\n    src: EntityId\n    dst: EntityId\n    type: str\n    attributes: Dict[str, Any] = field(default_factory=dict)\n","source_hash":"f32dd991ecbf9067178a3703b1be0d4601f339d20349172993dd1ae4f9bfc3c3","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:modules.program_graph.Edge","uri":"program://TOLBERT/class/modules.program_graph.Edge#L60-L75","kind":"class","name":"Edge","path":"modules/program_graph.py","language":"python","start_line":60,"end_line":75,"context_start_line":40,"context_end_line":95,"code":"\n    Common patterns:\n      - Repository / project node.\n      - File / module node.\n      - Function / method / class node.\n\n    `artifact_uri` and `span` are optional and only populated when the\n    entity corresponds to a concrete region in a file.\n    \"\"\"\n\n    id: EntityId\n    kind: str\n    uri: str\n    artifact_uri: Optional[str] = None\n    span: Optional[Span] = None\n    labels: List[str] = field(default_factory=list)\n    attributes: Dict[str, Any] = field(default_factory=dict)\n\n\n@dataclass\nclass Edge:\n    \"\"\"\n    Typed relationship between entities.\n\n    Typical edge types:\n      - \"owns\": containment (repo→file, file→function, module→class, ...)\n      - \"imports\": dependency between modules / files / packages\n      - \"calls\": function/method call\n      - \"tests\": test module or case covering a target\n      - \"similar_to\": embedding- or heuristic-based similarity\n    \"\"\"\n\n    src: EntityId\n    dst: EntityId\n    type: str\n    attributes: Dict[str, Any] = field(default_factory=dict)\n\n\n@dataclass\nclass ResolvedAnchor:\n    \"\"\"\n    Resolution of a URI back onto a concrete artifact region.\n    \"\"\"\n\n    artifact_uri: str\n    span: Span\n    hash: str\n\n\nclass ProgramGraph:\n    \"\"\"\n    Abstract, language-agnostic view over a program / repository.\n\n    Implementations are expected to provide at least:\n      - entities(): iterable of Entity nodes\n      - edges(): iterable of Edge relationships","source_hash":"f32dd991ecbf9067178a3703b1be0d4601f339d20349172993dd1ae4f9bfc3c3","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:modules.program_graph.ResolvedAnchor","uri":"program://TOLBERT/class/modules.program_graph.ResolvedAnchor#L79-L86","kind":"class","name":"ResolvedAnchor","path":"modules/program_graph.py","language":"python","start_line":79,"end_line":86,"context_start_line":59,"context_end_line":106,"code":"@dataclass\nclass Edge:\n    \"\"\"\n    Typed relationship between entities.\n\n    Typical edge types:\n      - \"owns\": containment (repo→file, file→function, module→class, ...)\n      - \"imports\": dependency between modules / files / packages\n      - \"calls\": function/method call\n      - \"tests\": test module or case covering a target\n      - \"similar_to\": embedding- or heuristic-based similarity\n    \"\"\"\n\n    src: EntityId\n    dst: EntityId\n    type: str\n    attributes: Dict[str, Any] = field(default_factory=dict)\n\n\n@dataclass\nclass ResolvedAnchor:\n    \"\"\"\n    Resolution of a URI back onto a concrete artifact region.\n    \"\"\"\n\n    artifact_uri: str\n    span: Span\n    hash: str\n\n\nclass ProgramGraph:\n    \"\"\"\n    Abstract, language-agnostic view over a program / repository.\n\n    Implementations are expected to provide at least:\n      - entities(): iterable of Entity nodes\n      - edges(): iterable of Edge relationships\n      - artifacts(): file-level view\n      - resolve(): URI → concrete anchor\n\n    Subclasses may add richer APIs as needed.\n    \"\"\"\n\n    # The default implementation is intentionally skeletal and returns\n    # empty views; concrete graphs should override these.\n\n    def entities(self) -> Iterable[Entity]:\n        return []","source_hash":"f32dd991ecbf9067178a3703b1be0d4601f339d20349172993dd1ae4f9bfc3c3","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:modules.program_graph.ProgramGraph","uri":"program://TOLBERT/class/modules.program_graph.ProgramGraph#L89-L121","kind":"class","name":"ProgramGraph","path":"modules/program_graph.py","language":"python","start_line":89,"end_line":121,"context_start_line":69,"context_end_line":123,"code":"      - \"similar_to\": embedding- or heuristic-based similarity\n    \"\"\"\n\n    src: EntityId\n    dst: EntityId\n    type: str\n    attributes: Dict[str, Any] = field(default_factory=dict)\n\n\n@dataclass\nclass ResolvedAnchor:\n    \"\"\"\n    Resolution of a URI back onto a concrete artifact region.\n    \"\"\"\n\n    artifact_uri: str\n    span: Span\n    hash: str\n\n\nclass ProgramGraph:\n    \"\"\"\n    Abstract, language-agnostic view over a program / repository.\n\n    Implementations are expected to provide at least:\n      - entities(): iterable of Entity nodes\n      - edges(): iterable of Edge relationships\n      - artifacts(): file-level view\n      - resolve(): URI → concrete anchor\n\n    Subclasses may add richer APIs as needed.\n    \"\"\"\n\n    # The default implementation is intentionally skeletal and returns\n    # empty views; concrete graphs should override these.\n\n    def entities(self) -> Iterable[Entity]:\n        return []\n\n    def edges(self) -> Iterable[Edge]:\n        return []\n\n    def artifacts(self, kind: str) -> Iterable[Artifact]:\n        return []\n\n    def resolve(self, uri: str) -> ResolvedAnchor:\n        raise NotImplementedError(\"resolve() must be implemented by subclasses\")\n\n    def search_refs(self, token: str) -> Iterable[Tuple[EntityId, Span]]:\n        return []\n\n    def subgraph(self, seeds: List[EntityId], radius: int) -> \"ProgramGraph\":\n        return self\n\n","source_hash":"f32dd991ecbf9067178a3703b1be0d4601f339d20349172993dd1ae4f9bfc3c3","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:modules.program_graph.entities","uri":"program://TOLBERT/function/modules.program_graph.entities#L105-L106","kind":"function","name":"entities","path":"modules/program_graph.py","language":"python","start_line":105,"end_line":106,"context_start_line":85,"context_end_line":123,"code":"    span: Span\n    hash: str\n\n\nclass ProgramGraph:\n    \"\"\"\n    Abstract, language-agnostic view over a program / repository.\n\n    Implementations are expected to provide at least:\n      - entities(): iterable of Entity nodes\n      - edges(): iterable of Edge relationships\n      - artifacts(): file-level view\n      - resolve(): URI → concrete anchor\n\n    Subclasses may add richer APIs as needed.\n    \"\"\"\n\n    # The default implementation is intentionally skeletal and returns\n    # empty views; concrete graphs should override these.\n\n    def entities(self) -> Iterable[Entity]:\n        return []\n\n    def edges(self) -> Iterable[Edge]:\n        return []\n\n    def artifacts(self, kind: str) -> Iterable[Artifact]:\n        return []\n\n    def resolve(self, uri: str) -> ResolvedAnchor:\n        raise NotImplementedError(\"resolve() must be implemented by subclasses\")\n\n    def search_refs(self, token: str) -> Iterable[Tuple[EntityId, Span]]:\n        return []\n\n    def subgraph(self, seeds: List[EntityId], radius: int) -> \"ProgramGraph\":\n        return self\n\n","source_hash":"f32dd991ecbf9067178a3703b1be0d4601f339d20349172993dd1ae4f9bfc3c3","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:modules.program_graph.edges","uri":"program://TOLBERT/function/modules.program_graph.edges#L108-L109","kind":"function","name":"edges","path":"modules/program_graph.py","language":"python","start_line":108,"end_line":109,"context_start_line":88,"context_end_line":123,"code":"\nclass ProgramGraph:\n    \"\"\"\n    Abstract, language-agnostic view over a program / repository.\n\n    Implementations are expected to provide at least:\n      - entities(): iterable of Entity nodes\n      - edges(): iterable of Edge relationships\n      - artifacts(): file-level view\n      - resolve(): URI → concrete anchor\n\n    Subclasses may add richer APIs as needed.\n    \"\"\"\n\n    # The default implementation is intentionally skeletal and returns\n    # empty views; concrete graphs should override these.\n\n    def entities(self) -> Iterable[Entity]:\n        return []\n\n    def edges(self) -> Iterable[Edge]:\n        return []\n\n    def artifacts(self, kind: str) -> Iterable[Artifact]:\n        return []\n\n    def resolve(self, uri: str) -> ResolvedAnchor:\n        raise NotImplementedError(\"resolve() must be implemented by subclasses\")\n\n    def search_refs(self, token: str) -> Iterable[Tuple[EntityId, Span]]:\n        return []\n\n    def subgraph(self, seeds: List[EntityId], radius: int) -> \"ProgramGraph\":\n        return self\n\n","source_hash":"f32dd991ecbf9067178a3703b1be0d4601f339d20349172993dd1ae4f9bfc3c3","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:modules.program_graph.artifacts","uri":"program://TOLBERT/function/modules.program_graph.artifacts#L111-L112","kind":"function","name":"artifacts","path":"modules/program_graph.py","language":"python","start_line":111,"end_line":112,"context_start_line":91,"context_end_line":123,"code":"    Abstract, language-agnostic view over a program / repository.\n\n    Implementations are expected to provide at least:\n      - entities(): iterable of Entity nodes\n      - edges(): iterable of Edge relationships\n      - artifacts(): file-level view\n      - resolve(): URI → concrete anchor\n\n    Subclasses may add richer APIs as needed.\n    \"\"\"\n\n    # The default implementation is intentionally skeletal and returns\n    # empty views; concrete graphs should override these.\n\n    def entities(self) -> Iterable[Entity]:\n        return []\n\n    def edges(self) -> Iterable[Edge]:\n        return []\n\n    def artifacts(self, kind: str) -> Iterable[Artifact]:\n        return []\n\n    def resolve(self, uri: str) -> ResolvedAnchor:\n        raise NotImplementedError(\"resolve() must be implemented by subclasses\")\n\n    def search_refs(self, token: str) -> Iterable[Tuple[EntityId, Span]]:\n        return []\n\n    def subgraph(self, seeds: List[EntityId], radius: int) -> \"ProgramGraph\":\n        return self\n\n","source_hash":"f32dd991ecbf9067178a3703b1be0d4601f339d20349172993dd1ae4f9bfc3c3","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:modules.program_graph.resolve","uri":"program://TOLBERT/function/modules.program_graph.resolve#L114-L115","kind":"function","name":"resolve","path":"modules/program_graph.py","language":"python","start_line":114,"end_line":115,"context_start_line":94,"context_end_line":123,"code":"      - entities(): iterable of Entity nodes\n      - edges(): iterable of Edge relationships\n      - artifacts(): file-level view\n      - resolve(): URI → concrete anchor\n\n    Subclasses may add richer APIs as needed.\n    \"\"\"\n\n    # The default implementation is intentionally skeletal and returns\n    # empty views; concrete graphs should override these.\n\n    def entities(self) -> Iterable[Entity]:\n        return []\n\n    def edges(self) -> Iterable[Edge]:\n        return []\n\n    def artifacts(self, kind: str) -> Iterable[Artifact]:\n        return []\n\n    def resolve(self, uri: str) -> ResolvedAnchor:\n        raise NotImplementedError(\"resolve() must be implemented by subclasses\")\n\n    def search_refs(self, token: str) -> Iterable[Tuple[EntityId, Span]]:\n        return []\n\n    def subgraph(self, seeds: List[EntityId], radius: int) -> \"ProgramGraph\":\n        return self\n\n","source_hash":"f32dd991ecbf9067178a3703b1be0d4601f339d20349172993dd1ae4f9bfc3c3","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:modules.program_graph.search_refs","uri":"program://TOLBERT/function/modules.program_graph.search_refs#L117-L118","kind":"function","name":"search_refs","path":"modules/program_graph.py","language":"python","start_line":117,"end_line":118,"context_start_line":97,"context_end_line":123,"code":"      - resolve(): URI → concrete anchor\n\n    Subclasses may add richer APIs as needed.\n    \"\"\"\n\n    # The default implementation is intentionally skeletal and returns\n    # empty views; concrete graphs should override these.\n\n    def entities(self) -> Iterable[Entity]:\n        return []\n\n    def edges(self) -> Iterable[Edge]:\n        return []\n\n    def artifacts(self, kind: str) -> Iterable[Artifact]:\n        return []\n\n    def resolve(self, uri: str) -> ResolvedAnchor:\n        raise NotImplementedError(\"resolve() must be implemented by subclasses\")\n\n    def search_refs(self, token: str) -> Iterable[Tuple[EntityId, Span]]:\n        return []\n\n    def subgraph(self, seeds: List[EntityId], radius: int) -> \"ProgramGraph\":\n        return self\n\n","source_hash":"f32dd991ecbf9067178a3703b1be0d4601f339d20349172993dd1ae4f9bfc3c3","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:modules.program_graph.subgraph","uri":"program://TOLBERT/function/modules.program_graph.subgraph#L120-L121","kind":"function","name":"subgraph","path":"modules/program_graph.py","language":"python","start_line":120,"end_line":121,"context_start_line":100,"context_end_line":123,"code":"    \"\"\"\n\n    # The default implementation is intentionally skeletal and returns\n    # empty views; concrete graphs should override these.\n\n    def entities(self) -> Iterable[Entity]:\n        return []\n\n    def edges(self) -> Iterable[Edge]:\n        return []\n\n    def artifacts(self, kind: str) -> Iterable[Artifact]:\n        return []\n\n    def resolve(self, uri: str) -> ResolvedAnchor:\n        raise NotImplementedError(\"resolve() must be implemented by subclasses\")\n\n    def search_refs(self, token: str) -> Iterable[Tuple[EntityId, Span]]:\n        return []\n\n    def subgraph(self, seeds: List[EntityId], radius: int) -> \"ProgramGraph\":\n        return self\n\n","source_hash":"f32dd991ecbf9067178a3703b1be0d4601f339d20349172993dd1ae4f9bfc3c3","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.preprocess_pdfs","uri":"program://TOLBERT/module/scripts.preprocess_pdfs#L1-L133","kind":"module","name":"scripts.preprocess_pdfs","path":"scripts/preprocess_pdfs.py","language":"python","start_line":1,"end_line":133,"context_start_line":1,"context_end_line":133,"code":"\"\"\"\nLightweight PDF preprocessing script.\n\nReads PDFs from /arxiv/pdfs/{year}/, extracts structured tokens via P0's tokenizer,\nand writes JSONL chunks (section/equation/figure/table/text) under exports/pdfs_structured/.\n\nUsage:\n  # Specific year range (inclusive)\n  PYTHONPATH=.. python -m models.scripts.preprocess_pdfs --years 2018 2020 --max-files 1000\n\n  # All years and all files (may be large)\n  PYTHONPATH=.. python -m models.scripts.preprocess_pdfs --max-files 0\n\n  # Use a VLM (e.g., Qwen/Qwen3-VL-2B-Instruct) for OCR\n  PYTHONPATH=.. python -m models.scripts.preprocess_pdfs --max-files 0 --qwen-model Qwen/Qwen3-VL-2B-Instruct\n\nSupports resumable runs: existing shards in the output directory are scanned and\ntheir pdf_path entries are skipped, so re-running continues where it left off.\n\"\"\"\n\nimport argparse\nimport json\nimport os\nfrom pathlib import Path\nfrom typing import List\nimport time\n\nfrom models.tier3_pdf.pdf_tokenization import PDFTokenizationModel\n\n\ndef iter_pdf_paths(year_start: int | None, year_end: int | None, limit: int | None) -> List[Path]:\n    paths: List[Path] = []\n    base = Path(\"/arxiv/pdfs\")\n    years = []\n    if year_start and year_end:\n        years = list(range(year_start, year_end + 1))\n    else:\n        years = sorted([int(p.name) for p in base.iterdir() if p.is_dir() and p.name.isdigit()])\n    for y in years:\n        for p in (base / str(y)).glob(\"*.pdf\"):\n            paths.append(p)\n            if limit and len(paths) >= limit:\n                return paths\n    return paths\n\n\ndef main():\n    ap = argparse.ArgumentParser()\n    ap.add_argument(\"--years\", nargs=2, type=int, help=\"Start/end year inclusive\")\n    ap.add_argument(\"--max-files\", type=int, default=1000, help=\"Max PDFs to process (0 = all)\")\n    ap.add_argument(\"--out-dir\", type=str, default=\"exports/pdfs_structured\", help=\"Output directory for JSONL shards\")\n    ap.add_argument(\"--shard-size\", type=int, default=1000, help=\"Records per JSONL shard\")\n    ap.add_argument(\"--progress-every\", type=int, default=100, help=\"Print status every N PDFs\")\n    ap.add_argument(\"--resume\", action=\"store_true\", default=True, help=\"Skip PDFs already present in existing shards\")\n    ap.add_argument(\"--qwen-model\", type=str, default=None, help=\"Optional Qwen VLM model name for OCR (e.g., Qwen/Qwen3-VL-2B-Instruct)\")\n    ap.add_argument(\"--max-pages\", type=int, default=3, help=\"Max pages to parse per PDF for structured tokens\")\n    ap.add_argument(\"--no-ocr\", action=\"store_true\", help=\"Disable OCR (faster)\")\n    ap.add_argument(\"--no-clip\", action=\"store_true\", help=\"Disable CLIP embeddings (faster)\")\n    args = ap.parse_args()\n\n    tok = PDFTokenizationModel()\n    out_dir = Path(args.out_dir)\n    out_dir.mkdir(parents=True, exist_ok=True)\n\n    year_start = args.years[0] if args.years else None\n    year_end = args.years[1] if args.years else None\n    limit = None if args.max_files is not None and args.max_files <= 0 else args.max_files\n    paths = iter_pdf_paths(year_start, year_end, limit)\n\n    # Resume support: gather processed pdf_paths from existing shards.\n    processed = set()\n    shard_idx = 0\n    if args.resume:\n        existing = sorted(out_dir.glob(\"pdf_structured_*.jsonl\"))\n        shard_idx = len(existing)\n        for shard_file in existing:\n            try:\n                with shard_file.open(\"r\", encoding=\"utf-8\") as f:\n                    for line in f:\n                        try:\n                            obj = json.loads(line)\n                            if isinstance(obj, dict) and obj.get(\"pdf_path\"):\n                                processed.add(obj[\"pdf_path\"])\n                        except Exception:\n                            continue\n            except Exception:\n                continue\n\n    shard = []\n    start_time = time.time()\n    total = len(paths)\n    for idx, pdf_path in enumerate(paths):\n        if str(pdf_path) in processed:\n            if (idx + 1) % args.progress_every == 0:\n                elapsed = time.time() - start_time\n                print(f\"[resume] skipped processed {idx + 1}/{total} (elapsed {elapsed:.1f}s)\")\n            continue\n        try:\n            tokens = tok.tokenize(\n                str(pdf_path),\n                vlm_model=args.qwen_model,\n                max_pages=args.max_pages,\n                use_ocr=not args.no_ocr,\n                use_clip=not args.no_clip,\n            )\n        except Exception as exc:\n            print(f\"[warn] failed to tokenize {pdf_path}: {exc}\")\n            continue\n        shard.append({\"pdf_path\": str(pdf_path), \"tokens\": tokens})\n        if len(shard) >= args.shard_size:\n            out_path = out_dir / f\"pdf_structured_{shard_idx:05d}.jsonl\"\n            with out_path.open(\"w\", encoding=\"utf-8\") as f:\n                for rec in shard:\n                    f.write(json.dumps(rec) + \"\\n\")\n            print(f\"[write] shard {shard_idx} ({len(shard)} recs)\")\n            shard = []\n            shard_idx += 1\n        if (idx + 1) % args.progress_every == 0:\n            elapsed = time.time() - start_time\n            print(f\"[status] processed {idx + 1}/{total} (elapsed {elapsed:.1f}s)\")\n    if shard:\n        out_path = out_dir / f\"pdf_structured_{shard_idx:05d}.jsonl\"\n        with out_path.open(\"w\", encoding=\"utf-8\") as f:\n            for rec in shard:\n                f.write(json.dumps(rec) + \"\\n\")\n        print(f\"[write] shard {shard_idx} ({len(shard)} recs)\")\n\n    elapsed = time.time() - start_time\n    print(f\"[done] wrote shards to {out_dir} in {elapsed:.1f}s\")\n\n\nif __name__ == \"__main__\":\n    main()","source_hash":"30f8438c60ae79d09a7c944ac558823c35963546eba2b8f7196a782700099acf","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.preprocess_pdfs.iter_pdf_paths","uri":"program://TOLBERT/function/scripts.preprocess_pdfs.iter_pdf_paths#L31-L44","kind":"function","name":"iter_pdf_paths","path":"scripts/preprocess_pdfs.py","language":"python","start_line":31,"end_line":44,"context_start_line":11,"context_end_line":64,"code":"  # All years and all files (may be large)\n  PYTHONPATH=.. python -m models.scripts.preprocess_pdfs --max-files 0\n\n  # Use a VLM (e.g., Qwen/Qwen3-VL-2B-Instruct) for OCR\n  PYTHONPATH=.. python -m models.scripts.preprocess_pdfs --max-files 0 --qwen-model Qwen/Qwen3-VL-2B-Instruct\n\nSupports resumable runs: existing shards in the output directory are scanned and\ntheir pdf_path entries are skipped, so re-running continues where it left off.\n\"\"\"\n\nimport argparse\nimport json\nimport os\nfrom pathlib import Path\nfrom typing import List\nimport time\n\nfrom models.tier3_pdf.pdf_tokenization import PDFTokenizationModel\n\n\ndef iter_pdf_paths(year_start: int | None, year_end: int | None, limit: int | None) -> List[Path]:\n    paths: List[Path] = []\n    base = Path(\"/arxiv/pdfs\")\n    years = []\n    if year_start and year_end:\n        years = list(range(year_start, year_end + 1))\n    else:\n        years = sorted([int(p.name) for p in base.iterdir() if p.is_dir() and p.name.isdigit()])\n    for y in years:\n        for p in (base / str(y)).glob(\"*.pdf\"):\n            paths.append(p)\n            if limit and len(paths) >= limit:\n                return paths\n    return paths\n\n\ndef main():\n    ap = argparse.ArgumentParser()\n    ap.add_argument(\"--years\", nargs=2, type=int, help=\"Start/end year inclusive\")\n    ap.add_argument(\"--max-files\", type=int, default=1000, help=\"Max PDFs to process (0 = all)\")\n    ap.add_argument(\"--out-dir\", type=str, default=\"exports/pdfs_structured\", help=\"Output directory for JSONL shards\")\n    ap.add_argument(\"--shard-size\", type=int, default=1000, help=\"Records per JSONL shard\")\n    ap.add_argument(\"--progress-every\", type=int, default=100, help=\"Print status every N PDFs\")\n    ap.add_argument(\"--resume\", action=\"store_true\", default=True, help=\"Skip PDFs already present in existing shards\")\n    ap.add_argument(\"--qwen-model\", type=str, default=None, help=\"Optional Qwen VLM model name for OCR (e.g., Qwen/Qwen3-VL-2B-Instruct)\")\n    ap.add_argument(\"--max-pages\", type=int, default=3, help=\"Max pages to parse per PDF for structured tokens\")\n    ap.add_argument(\"--no-ocr\", action=\"store_true\", help=\"Disable OCR (faster)\")\n    ap.add_argument(\"--no-clip\", action=\"store_true\", help=\"Disable CLIP embeddings (faster)\")\n    args = ap.parse_args()\n\n    tok = PDFTokenizationModel()\n    out_dir = Path(args.out_dir)\n    out_dir.mkdir(parents=True, exist_ok=True)\n","source_hash":"30f8438c60ae79d09a7c944ac558823c35963546eba2b8f7196a782700099acf","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.preprocess_pdfs.main","uri":"program://TOLBERT/function/scripts.preprocess_pdfs.main#L47-L129","kind":"function","name":"main","path":"scripts/preprocess_pdfs.py","language":"python","start_line":47,"end_line":129,"context_start_line":27,"context_end_line":133,"code":"\nfrom models.tier3_pdf.pdf_tokenization import PDFTokenizationModel\n\n\ndef iter_pdf_paths(year_start: int | None, year_end: int | None, limit: int | None) -> List[Path]:\n    paths: List[Path] = []\n    base = Path(\"/arxiv/pdfs\")\n    years = []\n    if year_start and year_end:\n        years = list(range(year_start, year_end + 1))\n    else:\n        years = sorted([int(p.name) for p in base.iterdir() if p.is_dir() and p.name.isdigit()])\n    for y in years:\n        for p in (base / str(y)).glob(\"*.pdf\"):\n            paths.append(p)\n            if limit and len(paths) >= limit:\n                return paths\n    return paths\n\n\ndef main():\n    ap = argparse.ArgumentParser()\n    ap.add_argument(\"--years\", nargs=2, type=int, help=\"Start/end year inclusive\")\n    ap.add_argument(\"--max-files\", type=int, default=1000, help=\"Max PDFs to process (0 = all)\")\n    ap.add_argument(\"--out-dir\", type=str, default=\"exports/pdfs_structured\", help=\"Output directory for JSONL shards\")\n    ap.add_argument(\"--shard-size\", type=int, default=1000, help=\"Records per JSONL shard\")\n    ap.add_argument(\"--progress-every\", type=int, default=100, help=\"Print status every N PDFs\")\n    ap.add_argument(\"--resume\", action=\"store_true\", default=True, help=\"Skip PDFs already present in existing shards\")\n    ap.add_argument(\"--qwen-model\", type=str, default=None, help=\"Optional Qwen VLM model name for OCR (e.g., Qwen/Qwen3-VL-2B-Instruct)\")\n    ap.add_argument(\"--max-pages\", type=int, default=3, help=\"Max pages to parse per PDF for structured tokens\")\n    ap.add_argument(\"--no-ocr\", action=\"store_true\", help=\"Disable OCR (faster)\")\n    ap.add_argument(\"--no-clip\", action=\"store_true\", help=\"Disable CLIP embeddings (faster)\")\n    args = ap.parse_args()\n\n    tok = PDFTokenizationModel()\n    out_dir = Path(args.out_dir)\n    out_dir.mkdir(parents=True, exist_ok=True)\n\n    year_start = args.years[0] if args.years else None\n    year_end = args.years[1] if args.years else None\n    limit = None if args.max_files is not None and args.max_files <= 0 else args.max_files\n    paths = iter_pdf_paths(year_start, year_end, limit)\n\n    # Resume support: gather processed pdf_paths from existing shards.\n    processed = set()\n    shard_idx = 0\n    if args.resume:\n        existing = sorted(out_dir.glob(\"pdf_structured_*.jsonl\"))\n        shard_idx = len(existing)\n        for shard_file in existing:\n            try:\n                with shard_file.open(\"r\", encoding=\"utf-8\") as f:\n                    for line in f:\n                        try:\n                            obj = json.loads(line)\n                            if isinstance(obj, dict) and obj.get(\"pdf_path\"):\n                                processed.add(obj[\"pdf_path\"])\n                        except Exception:\n                            continue\n            except Exception:\n                continue\n\n    shard = []\n    start_time = time.time()\n    total = len(paths)\n    for idx, pdf_path in enumerate(paths):\n        if str(pdf_path) in processed:\n            if (idx + 1) % args.progress_every == 0:\n                elapsed = time.time() - start_time\n                print(f\"[resume] skipped processed {idx + 1}/{total} (elapsed {elapsed:.1f}s)\")\n            continue\n        try:\n            tokens = tok.tokenize(\n                str(pdf_path),\n                vlm_model=args.qwen_model,\n                max_pages=args.max_pages,\n                use_ocr=not args.no_ocr,\n                use_clip=not args.no_clip,\n            )\n        except Exception as exc:\n            print(f\"[warn] failed to tokenize {pdf_path}: {exc}\")\n            continue\n        shard.append({\"pdf_path\": str(pdf_path), \"tokens\": tokens})\n        if len(shard) >= args.shard_size:\n            out_path = out_dir / f\"pdf_structured_{shard_idx:05d}.jsonl\"\n            with out_path.open(\"w\", encoding=\"utf-8\") as f:\n                for rec in shard:\n                    f.write(json.dumps(rec) + \"\\n\")\n            print(f\"[write] shard {shard_idx} ({len(shard)} recs)\")\n            shard = []\n            shard_idx += 1\n        if (idx + 1) % args.progress_every == 0:\n            elapsed = time.time() - start_time\n            print(f\"[status] processed {idx + 1}/{total} (elapsed {elapsed:.1f}s)\")\n    if shard:\n        out_path = out_dir / f\"pdf_structured_{shard_idx:05d}.jsonl\"\n        with out_path.open(\"w\", encoding=\"utf-8\") as f:\n            for rec in shard:\n                f.write(json.dumps(rec) + \"\\n\")\n        print(f\"[write] shard {shard_idx} ({len(shard)} recs)\")\n\n    elapsed = time.time() - start_time\n    print(f\"[done] wrote shards to {out_dir} in {elapsed:.1f}s\")\n\n\nif __name__ == \"__main__\":\n    main()","source_hash":"30f8438c60ae79d09a7c944ac558823c35963546eba2b8f7196a782700099acf","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.eval_zero_shot_cross_domain","uri":"program://TOLBERT/module/scripts.eval_zero_shot_cross_domain#L1-L175","kind":"module","name":"scripts.eval_zero_shot_cross_domain","path":"scripts/eval_zero_shot_cross_domain.py","language":"python","start_line":1,"end_line":175,"context_start_line":1,"context_end_line":175,"code":"\"\"\"\nSimple cross-domain zero-shot evaluation script for TOLBERT.\n\nThis wraps the hierarchical classification evaluator to support the scenario:\n\n  - Train TOLBERT on domain A (e.g., CodeHierarchy).\n  - Evaluate the same checkpoint on domain B (e.g., WOS) without further training.\n\nUsage:\n\n  # Evaluate a code-trained model on WOS spans\n  python -m scripts.eval_zero_shot_cross_domain \\\\\n      --config configs/codehierarchy_example.yaml \\\\\n      --checkpoint checkpoints/codehierarchy/tolbert_epoch5.pt \\\\\n      --target-config configs/wos_example.yaml \\\\\n      --target-spans data/wos/spans_test.jsonl\n\nThe script uses:\n  - base_model_name and model head structure from the *source* config\n    (the one used for training),\n  - but evaluation data and tokenizer settings (e.g., max_length) from\n    the *target* config.\n\"\"\"\n\nfrom __future__ import annotations\n\nimport argparse\nfrom pathlib import Path\nfrom typing import Any, Dict\n\nimport torch\nfrom torch.utils.data import DataLoader\nfrom transformers import AutoTokenizer\nimport os\n\nfrom tolbert.config import load_tolbert_config\nfrom tolbert.data import TreeOfLifeDataset, collate_tree_of_life_batch\nfrom tolbert.modeling import TOLBERT, TOLBERTConfig\n\n\ndef build_model(src_cfg: Dict[str, Any], checkpoint: str, device: torch.device) -> TOLBERT:\n    model_cfg = TOLBERTConfig(\n        base_model_name=src_cfg[\"base_model_name\"],\n        level_sizes=src_cfg[\"level_sizes\"],\n        proj_dim=src_cfg.get(\"proj_dim\", 256),\n        lambda_hier=src_cfg.get(\"lambda_hier\", 1.0),\n        lambda_path=src_cfg.get(\"lambda_path\", 0.0),\n        lambda_contrast=0.0,\n    )\n    model = TOLBERT(model_cfg)\n    state = torch.load(checkpoint, map_location=\"cpu\")\n    model.load_state_dict(state)\n    model.to(device)\n    model.eval()\n    return model\n\n\ndef parse_args() -> argparse.Namespace:\n    ap = argparse.ArgumentParser(description=\"Zero-shot cross-domain eval for TOLBERT.\")\n    ap.add_argument(\n        \"--config\",\n        type=str,\n        required=True,\n        help=\"Source (training) config for the model (defines heads).\",\n    )\n    ap.add_argument(\n        \"--checkpoint\",\n        type=str,\n        required=True,\n        help=\"Path to trained model checkpoint on source domain.\",\n    )\n    ap.add_argument(\n        \"--target-config\",\n        type=str,\n        required=True,\n        help=\"Target domain config (used for tokenizer and data params).\",\n    )\n    ap.add_argument(\n        \"--target-spans\",\n        type=str,\n        required=True,\n        help=\"Spans JSONL file from the target domain (with node_path labels).\",\n    )\n    ap.add_argument(\n        \"--batch-size\",\n        type=int,\n        default=64,\n        help=\"Evaluation batch size.\",\n    )\n    ap.add_argument(\n        \"--device\",\n        type=str,\n        default=\"cuda\" if torch.cuda.is_available() else \"cpu\",\n        help=\"Device to use.\",\n    )\n    return ap.parse_args()\n\n\ndef main() -> None:\n    args = parse_args()\n\n    src_cfg = load_tolbert_config(args.config)\n    tgt_cfg = load_tolbert_config(args.target_config)\n    device = torch.device(args.device)\n\n    spans_path = Path(args.target_spans)\n    if not spans_path.exists():\n        raise FileNotFoundError(f\"target_spans not found: {spans_path}\")\n\n    tokenizer = AutoTokenizer.from_pretrained(\n        tgt_cfg[\"base_model_name\"],\n        cache_dir=\"/data/checkpoints/\",  # noqa: E501\n    )\n\n    dataset = TreeOfLifeDataset(\n        spans_file=str(spans_path),\n        tokenizer=tokenizer,\n        max_length=tgt_cfg.get(\"max_length\", 256),\n        mask_probability=tgt_cfg.get(\"mask_probability\", 0.15),\n    )\n    dataloader = DataLoader(\n        dataset,\n        batch_size=args.batch_size,\n        shuffle=False,\n        num_workers=tgt_cfg.get(\"num_workers\", 0),\n        collate_fn=collate_tree_of_life_batch,\n    )\n\n    model = build_model(src_cfg, checkpoint=args.checkpoint, device=device)\n\n    level_correct: Dict[int, int] = {}\n    level_total: Dict[int, int] = {}\n\n    with torch.no_grad():\n        for batch in dataloader:\n            input_ids = batch[\"input_ids\"].to(device)\n            attention_mask = batch[\"attention_mask\"].to(device)\n            level_targets = {\n                level: targets.to(device) for level, targets in batch[\"level_targets\"].items()\n            }\n\n            out = model(\n                input_ids=input_ids,\n                attention_mask=attention_mask,\n                level_targets=level_targets,\n            )\n            level_logits: Dict[str, torch.Tensor] = out[\"level_logits\"]\n\n            for level_int, targets in level_targets.items():\n                logits = level_logits.get(str(level_int))\n                if logits is None:\n                    continue\n                preds = logits.argmax(dim=-1)\n\n                mask = targets != -100\n                if mask.sum().item() == 0:\n                    continue\n\n                correct = (preds == targets) & mask\n                num_correct = correct.sum().item()\n                num_total = mask.sum().item()\n\n                level_correct[level_int] = level_correct.get(level_int, 0) + num_correct\n                level_total[level_int] = level_total.get(level_int, 0) + num_total\n\n    print(\"=== Zero-shot Cross-domain Classification ===\")\n    for level in sorted(level_total.keys()):\n        acc = level_correct[level] / max(1, level_total[level])\n        print(f\"Level {level}: accuracy={acc:.4f} (n={level_total[level]})\")\n\n\nif __name__ == \"__main__\":\n    main()\n\n","source_hash":"e767fb5692f2c8cac3cf173bd350576b6c0101eb0626d929114add875d33f237","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.eval_zero_shot_cross_domain.build_model","uri":"program://TOLBERT/function/scripts.eval_zero_shot_cross_domain.build_model#L41-L55","kind":"function","name":"build_model","path":"scripts/eval_zero_shot_cross_domain.py","language":"python","start_line":41,"end_line":55,"context_start_line":21,"context_end_line":75,"code":"  - but evaluation data and tokenizer settings (e.g., max_length) from\n    the *target* config.\n\"\"\"\n\nfrom __future__ import annotations\n\nimport argparse\nfrom pathlib import Path\nfrom typing import Any, Dict\n\nimport torch\nfrom torch.utils.data import DataLoader\nfrom transformers import AutoTokenizer\nimport os\n\nfrom tolbert.config import load_tolbert_config\nfrom tolbert.data import TreeOfLifeDataset, collate_tree_of_life_batch\nfrom tolbert.modeling import TOLBERT, TOLBERTConfig\n\n\ndef build_model(src_cfg: Dict[str, Any], checkpoint: str, device: torch.device) -> TOLBERT:\n    model_cfg = TOLBERTConfig(\n        base_model_name=src_cfg[\"base_model_name\"],\n        level_sizes=src_cfg[\"level_sizes\"],\n        proj_dim=src_cfg.get(\"proj_dim\", 256),\n        lambda_hier=src_cfg.get(\"lambda_hier\", 1.0),\n        lambda_path=src_cfg.get(\"lambda_path\", 0.0),\n        lambda_contrast=0.0,\n    )\n    model = TOLBERT(model_cfg)\n    state = torch.load(checkpoint, map_location=\"cpu\")\n    model.load_state_dict(state)\n    model.to(device)\n    model.eval()\n    return model\n\n\ndef parse_args() -> argparse.Namespace:\n    ap = argparse.ArgumentParser(description=\"Zero-shot cross-domain eval for TOLBERT.\")\n    ap.add_argument(\n        \"--config\",\n        type=str,\n        required=True,\n        help=\"Source (training) config for the model (defines heads).\",\n    )\n    ap.add_argument(\n        \"--checkpoint\",\n        type=str,\n        required=True,\n        help=\"Path to trained model checkpoint on source domain.\",\n    )\n    ap.add_argument(\n        \"--target-config\",\n        type=str,\n        required=True,","source_hash":"e767fb5692f2c8cac3cf173bd350576b6c0101eb0626d929114add875d33f237","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.eval_zero_shot_cross_domain.parse_args","uri":"program://TOLBERT/function/scripts.eval_zero_shot_cross_domain.parse_args#L58-L96","kind":"function","name":"parse_args","path":"scripts/eval_zero_shot_cross_domain.py","language":"python","start_line":58,"end_line":96,"context_start_line":38,"context_end_line":116,"code":"from tolbert.modeling import TOLBERT, TOLBERTConfig\n\n\ndef build_model(src_cfg: Dict[str, Any], checkpoint: str, device: torch.device) -> TOLBERT:\n    model_cfg = TOLBERTConfig(\n        base_model_name=src_cfg[\"base_model_name\"],\n        level_sizes=src_cfg[\"level_sizes\"],\n        proj_dim=src_cfg.get(\"proj_dim\", 256),\n        lambda_hier=src_cfg.get(\"lambda_hier\", 1.0),\n        lambda_path=src_cfg.get(\"lambda_path\", 0.0),\n        lambda_contrast=0.0,\n    )\n    model = TOLBERT(model_cfg)\n    state = torch.load(checkpoint, map_location=\"cpu\")\n    model.load_state_dict(state)\n    model.to(device)\n    model.eval()\n    return model\n\n\ndef parse_args() -> argparse.Namespace:\n    ap = argparse.ArgumentParser(description=\"Zero-shot cross-domain eval for TOLBERT.\")\n    ap.add_argument(\n        \"--config\",\n        type=str,\n        required=True,\n        help=\"Source (training) config for the model (defines heads).\",\n    )\n    ap.add_argument(\n        \"--checkpoint\",\n        type=str,\n        required=True,\n        help=\"Path to trained model checkpoint on source domain.\",\n    )\n    ap.add_argument(\n        \"--target-config\",\n        type=str,\n        required=True,\n        help=\"Target domain config (used for tokenizer and data params).\",\n    )\n    ap.add_argument(\n        \"--target-spans\",\n        type=str,\n        required=True,\n        help=\"Spans JSONL file from the target domain (with node_path labels).\",\n    )\n    ap.add_argument(\n        \"--batch-size\",\n        type=int,\n        default=64,\n        help=\"Evaluation batch size.\",\n    )\n    ap.add_argument(\n        \"--device\",\n        type=str,\n        default=\"cuda\" if torch.cuda.is_available() else \"cpu\",\n        help=\"Device to use.\",\n    )\n    return ap.parse_args()\n\n\ndef main() -> None:\n    args = parse_args()\n\n    src_cfg = load_tolbert_config(args.config)\n    tgt_cfg = load_tolbert_config(args.target_config)\n    device = torch.device(args.device)\n\n    spans_path = Path(args.target_spans)\n    if not spans_path.exists():\n        raise FileNotFoundError(f\"target_spans not found: {spans_path}\")\n\n    tokenizer = AutoTokenizer.from_pretrained(\n        tgt_cfg[\"base_model_name\"],\n        cache_dir=\"/data/checkpoints/\",  # noqa: E501\n    )\n\n    dataset = TreeOfLifeDataset(\n        spans_file=str(spans_path),","source_hash":"e767fb5692f2c8cac3cf173bd350576b6c0101eb0626d929114add875d33f237","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.eval_zero_shot_cross_domain.main","uri":"program://TOLBERT/function/scripts.eval_zero_shot_cross_domain.main#L99-L169","kind":"function","name":"main","path":"scripts/eval_zero_shot_cross_domain.py","language":"python","start_line":99,"end_line":169,"context_start_line":79,"context_end_line":175,"code":"        \"--target-spans\",\n        type=str,\n        required=True,\n        help=\"Spans JSONL file from the target domain (with node_path labels).\",\n    )\n    ap.add_argument(\n        \"--batch-size\",\n        type=int,\n        default=64,\n        help=\"Evaluation batch size.\",\n    )\n    ap.add_argument(\n        \"--device\",\n        type=str,\n        default=\"cuda\" if torch.cuda.is_available() else \"cpu\",\n        help=\"Device to use.\",\n    )\n    return ap.parse_args()\n\n\ndef main() -> None:\n    args = parse_args()\n\n    src_cfg = load_tolbert_config(args.config)\n    tgt_cfg = load_tolbert_config(args.target_config)\n    device = torch.device(args.device)\n\n    spans_path = Path(args.target_spans)\n    if not spans_path.exists():\n        raise FileNotFoundError(f\"target_spans not found: {spans_path}\")\n\n    tokenizer = AutoTokenizer.from_pretrained(\n        tgt_cfg[\"base_model_name\"],\n        cache_dir=\"/data/checkpoints/\",  # noqa: E501\n    )\n\n    dataset = TreeOfLifeDataset(\n        spans_file=str(spans_path),\n        tokenizer=tokenizer,\n        max_length=tgt_cfg.get(\"max_length\", 256),\n        mask_probability=tgt_cfg.get(\"mask_probability\", 0.15),\n    )\n    dataloader = DataLoader(\n        dataset,\n        batch_size=args.batch_size,\n        shuffle=False,\n        num_workers=tgt_cfg.get(\"num_workers\", 0),\n        collate_fn=collate_tree_of_life_batch,\n    )\n\n    model = build_model(src_cfg, checkpoint=args.checkpoint, device=device)\n\n    level_correct: Dict[int, int] = {}\n    level_total: Dict[int, int] = {}\n\n    with torch.no_grad():\n        for batch in dataloader:\n            input_ids = batch[\"input_ids\"].to(device)\n            attention_mask = batch[\"attention_mask\"].to(device)\n            level_targets = {\n                level: targets.to(device) for level, targets in batch[\"level_targets\"].items()\n            }\n\n            out = model(\n                input_ids=input_ids,\n                attention_mask=attention_mask,\n                level_targets=level_targets,\n            )\n            level_logits: Dict[str, torch.Tensor] = out[\"level_logits\"]\n\n            for level_int, targets in level_targets.items():\n                logits = level_logits.get(str(level_int))\n                if logits is None:\n                    continue\n                preds = logits.argmax(dim=-1)\n\n                mask = targets != -100\n                if mask.sum().item() == 0:\n                    continue\n\n                correct = (preds == targets) & mask\n                num_correct = correct.sum().item()\n                num_total = mask.sum().item()\n\n                level_correct[level_int] = level_correct.get(level_int, 0) + num_correct\n                level_total[level_int] = level_total.get(level_int, 0) + num_total\n\n    print(\"=== Zero-shot Cross-domain Classification ===\")\n    for level in sorted(level_total.keys()):\n        acc = level_correct[level] / max(1, level_total[level])\n        print(f\"Level {level}: accuracy={acc:.4f} (n={level_total[level]})\")\n\n\nif __name__ == \"__main__\":\n    main()\n\n","source_hash":"e767fb5692f2c8cac3cf173bd350576b6c0101eb0626d929114add875d33f237","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.build_wos_spans","uri":"program://TOLBERT/module/scripts.build_wos_spans#L1-L325","kind":"module","name":"scripts.build_wos_spans","path":"scripts/build_wos_spans.py","language":"python","start_line":1,"end_line":325,"context_start_line":1,"context_end_line":325,"code":"\"\"\"\nBuild JSONL spans and ontology metadata for a WOS-style hierarchical text dataset.\n\nThis script is a reference implementation of the ResearchHierarchy construction\ndescribed in the TOLBERT paper. It does **not** ship any WOS data; instead, it\nexpects you to provide a CSV file with one row per document and three levels of\nlabels.\n\nExpected input CSV schema (you can adapt this to your variant as needed):\n\n    text_col:   column containing the text to encode (e.g., abstract)\n    l1_col:     top-level field (e.g., \"Computer Science\")\n    l2_col:     second-level subfield\n    l3_col:     third-level discipline\n\nBy default we assume:\n\n    --text-col text\n    --l1-col   level1\n    --l2-col   level2\n    --l3-col   level3\n\nYou can override these on the command line.\n\nOutputs:\n  - --spans-out:\n      JSONL file with one record per document:\n        {\n          \"span_id\": \"doc_000001\",\n          \"text\": \"... abstract or text ...\",\n          \"source_id\": \"doc_000001\",\n          \"node_path\": [root_id, l1_id, l2_id, l3_id],\n          \"meta\": {\n             \"level1\": \"...\",\n             \"level2\": \"...\",\n             \"level3\": \"...\"\n          }\n        }\n\n  - --nodes-out (optional):\n      JSONL file of ontology nodes with fields:\n        node_id, level, type, parent_id, name\n\n  - --level-sizes-out (optional):\n      Small JSON helper:\n        {\"level_sizes\": {1: num_l1, 2: num_l2, 3: num_l3}}\n\nThese files are compatible with `tolbert.data.TreeOfLifeDataset` and the\ntraining skeleton in `scripts/train_tolbert.py`.\n\"\"\"\n\nfrom __future__ import annotations\n\nimport argparse\nimport csv\nimport json\nfrom dataclasses import dataclass\nfrom pathlib import Path\nfrom typing import Dict, List, Tuple\n\n\n@dataclass\nclass DocRow:\n    text: str\n    l1: str\n    l2: str\n    l3: str\n\n\ndef load_wos_csv(\n    path: Path,\n    text_col: str,\n    l1_col: str,\n    l2_col: str,\n    l3_col: str,\n) -> List[DocRow]:\n    rows: List[DocRow] = []\n    with path.open(\"r\", encoding=\"utf-8\") as f:\n        reader = csv.DictReader(f)\n        for row in reader:\n            text = row.get(text_col, \"\") or \"\"\n            l1 = row.get(l1_col, \"\") or \"\"\n            l2 = row.get(l2_col, \"\") or \"\"\n            l3 = row.get(l3_col, \"\") or \"\"\n            if not text:\n                continue\n            rows.append(DocRow(text=text, l1=l1, l2=l2, l3=l3))\n    return rows\n\n\ndef build_ontology(rows: List[DocRow]) -> Tuple[Dict[str, int], Dict[str, int], Dict[str, int]]:\n    \"\"\"\n    Build integer node IDs for:\n      - level 1: unique l1 labels\n      - level 2: unique (l1, l2) pairs\n      - level 3: unique (l1, l2, l3) triples\n\n    Node IDs are global; path uses:\n      [root_id, l1_id, l2_id, l3_id]\n    \"\"\"\n    next_id = 0\n    root_id = next_id\n    next_id += 1\n\n    l1_ids: Dict[str, int] = {}\n    l2_ids: Dict[str, int] = {}\n    l3_ids: Dict[str, int] = {}\n\n    for r in rows:\n        if r.l1 and r.l1 not in l1_ids:\n            l1_ids[r.l1] = next_id\n            next_id += 1\n        if r.l1 and r.l2:\n            key2 = f\"{r.l1}::{r.l2}\"\n            if key2 not in l2_ids:\n                l2_ids[key2] = next_id\n                next_id += 1\n        if r.l1 and r.l2 and r.l3:\n            key3 = f\"{r.l1}::{r.l2}::{r.l3}\"\n            if key3 not in l3_ids:\n                l3_ids[key3] = next_id\n                next_id += 1\n\n    return l1_ids, l2_ids, l3_ids\n\n\ndef write_nodes_jsonl(\n    out_path: Path,\n    l1_ids: Dict[str, int],\n    l2_ids: Dict[str, int],\n    l3_ids: Dict[str, int],\n) -> None:\n    with out_path.open(\"w\", encoding=\"utf-8\") as f:\n        # Root\n        f.write(\n            json.dumps(\n                {\n                    \"node_id\": 0,\n                    \"level\": 0,\n                    \"type\": \"root\",\n                    \"parent_id\": None,\n                    \"name\": \"Root\",\n                    \"attributes\": {},\n                }\n            )\n            + \"\\n\"\n        )\n\n        # Level 1 nodes\n        for name, nid in l1_ids.items():\n            f.write(\n                json.dumps(\n                    {\n                        \"node_id\": nid,\n                        \"level\": 1,\n                        \"type\": \"field\",\n                        \"parent_id\": 0,\n                        \"name\": name,\n                        \"attributes\": {},\n                    }\n                )\n                + \"\\n\"\n            )\n\n        # Level 2 nodes\n        for key, nid in l2_ids.items():\n            l1, l2 = key.split(\"::\", 1)\n            parent_id = l1_ids[l1]\n            f.write(\n                json.dumps(\n                    {\n                        \"node_id\": nid,\n                        \"level\": 2,\n                        \"type\": \"subfield\",\n                        \"parent_id\": parent_id,\n                        \"name\": l2,\n                        \"attributes\": {\"level1\": l1},\n                    }\n                )\n                + \"\\n\"\n            )\n\n        # Level 3 nodes\n        for key, nid in l3_ids.items():\n            l1, l2, l3 = key.split(\"::\", 2)\n            # Parent is the (l1,l2) node\n            parent_id = l2_ids[f\"{l1}::{l2}\"]\n            f.write(\n                json.dumps(\n                    {\n                        \"node_id\": nid,\n                        \"level\": 3,\n                        \"type\": \"discipline\",\n                        \"parent_id\": parent_id,\n                        \"name\": l3,\n                        \"attributes\": {\"level1\": l1, \"level2\": l2},\n                    }\n                )\n                + \"\\n\"\n            )\n\n\ndef build_spans(\n    rows: List[DocRow],\n    l1_ids: Dict[str, int],\n    l2_ids: Dict[str, int],\n    l3_ids: Dict[str, int],\n) -> List[Dict[str, object]]:\n    spans: List[Dict[str, object]] = []\n    root_id = 0\n    for idx, r in enumerate(rows):\n        span_id = f\"doc_{idx:06d}\"\n        l1_id = l1_ids.get(r.l1)\n        l2_id = None\n        l3_id = None\n        if r.l1 and r.l2:\n            key2 = f\"{r.l1}::{r.l2}\"\n            l2_id = l2_ids.get(key2)\n        if r.l1 and r.l2 and r.l3:\n            key3 = f\"{r.l1}::{r.l2}::{r.l3}\"\n            l3_id = l3_ids.get(key3)\n\n        # Build node_path; allow partially-labeled paths by omitting unknowns.\n        path = [root_id]\n        if l1_id is not None:\n            path.append(l1_id)\n        if l2_id is not None:\n            path.append(l2_id)\n        if l3_id is not None:\n            path.append(l3_id)\n\n        spans.append(\n            {\n                \"span_id\": span_id,\n                \"text\": r.text,\n                \"source_id\": span_id,\n                \"node_path\": path,\n                \"meta\": {\n                    \"level1\": r.l1,\n                    \"level2\": r.l2,\n                    \"level3\": r.l3,\n                },\n            }\n        )\n    return spans\n\n\ndef write_spans_jsonl(spans: List[Dict[str, object]], out_path: Path) -> None:\n    with out_path.open(\"w\", encoding=\"utf-8\") as f:\n        for rec in spans:\n            f.write(json.dumps(rec) + \"\\n\")\n\n\ndef write_level_sizes(\n    l1_ids: Dict[str, int],\n    l2_ids: Dict[str, int],\n    l3_ids: Dict[str, int],\n    out_path: Path,\n) -> None:\n    level_sizes = {\n        1: len(l1_ids),\n        2: len(l2_ids),\n        3: len(l3_ids),\n    }\n    out = {\"level_sizes\": level_sizes}\n    with out_path.open(\"w\", encoding=\"utf-8\") as f:\n        json.dump(out, f, indent=2)\n\n\ndef parse_args() -> argparse.Namespace:\n    ap = argparse.ArgumentParser(description=\"Build WOS-style spans JSONL and ontology metadata.\")\n    ap.add_argument(\"--input-csv\", type=str, required=True, help=\"Input CSV file with text + labels.\")\n    ap.add_argument(\"--spans-out\", type=str, required=True, help=\"Output spans JSONL file.\")\n    ap.add_argument(\"--nodes-out\", type=str, default=\"\", help=\"Optional nodes JSONL output.\")\n    ap.add_argument(\n        \"--level-sizes-out\",\n        type=str,\n        default=\"\",\n        help=\"Optional JSON file with level_sizes helper dict.\",\n    )\n    ap.add_argument(\"--text-col\", type=str, default=\"text\", help=\"Text column name.\")\n    ap.add_argument(\"--l1-col\", type=str, default=\"level1\", help=\"Level-1 label column name.\")\n    ap.add_argument(\"--l2-col\", type=str, default=\"level2\", help=\"Level-2 label column name.\")\n    ap.add_argument(\"--l3-col\", type=str, default=\"level3\", help=\"Level-3 label column name.\")\n    return ap.parse_args()\n\n\ndef main() -> None:\n    args = parse_args()\n\n    csv_path = Path(args.input_csv)\n    if not csv_path.exists():\n        raise FileNotFoundError(f\"Input CSV not found: {csv_path}\")\n\n    rows = load_wos_csv(\n        csv_path,\n        text_col=args.text_col,\n        l1_col=args.l1_col,\n        l2_col=args.l2_col,\n        l3_col=args.l3_col,\n    )\n\n    l1_ids, l2_ids, l3_ids = build_ontology(rows)\n\n    spans = build_spans(rows, l1_ids=l1_ids, l2_ids=l2_ids, l3_ids=l3_ids)\n\n    spans_out = Path(args.spans_out)\n    spans_out.parent.mkdir(parents=True, exist_ok=True)\n    write_spans_jsonl(spans, spans_out)\n\n    if args.nodes_out:\n        nodes_out = Path(args.nodes_out)\n        nodes_out.parent.mkdir(parents=True, exist_ok=True)\n        write_nodes_jsonl(nodes_out, l1_ids=l1_ids, l2_ids=l2_ids, l3_ids=l3_ids)\n\n    if args.level_sizes_out:\n        ls_out = Path(args.level_sizes_out)\n        ls_out.parent.mkdir(parents=True, exist_ok=True)\n        write_level_sizes(l1_ids=l1_ids, l2_ids=l2_ids, l3_ids=l3_ids, out_path=ls_out)\n\n\nif __name__ == \"__main__\":\n    main()\n\n","source_hash":"ddb099315e7bc0048643832ced2f4eaea51afb31ff4bc31f66aeec55ff96ef67","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.build_wos_spans.DocRow","uri":"program://TOLBERT/class/scripts.build_wos_spans.DocRow#L63-L67","kind":"class","name":"DocRow","path":"scripts/build_wos_spans.py","language":"python","start_line":63,"end_line":67,"context_start_line":43,"context_end_line":87,"code":"\n  - --level-sizes-out (optional):\n      Small JSON helper:\n        {\"level_sizes\": {1: num_l1, 2: num_l2, 3: num_l3}}\n\nThese files are compatible with `tolbert.data.TreeOfLifeDataset` and the\ntraining skeleton in `scripts/train_tolbert.py`.\n\"\"\"\n\nfrom __future__ import annotations\n\nimport argparse\nimport csv\nimport json\nfrom dataclasses import dataclass\nfrom pathlib import Path\nfrom typing import Dict, List, Tuple\n\n\n@dataclass\nclass DocRow:\n    text: str\n    l1: str\n    l2: str\n    l3: str\n\n\ndef load_wos_csv(\n    path: Path,\n    text_col: str,\n    l1_col: str,\n    l2_col: str,\n    l3_col: str,\n) -> List[DocRow]:\n    rows: List[DocRow] = []\n    with path.open(\"r\", encoding=\"utf-8\") as f:\n        reader = csv.DictReader(f)\n        for row in reader:\n            text = row.get(text_col, \"\") or \"\"\n            l1 = row.get(l1_col, \"\") or \"\"\n            l2 = row.get(l2_col, \"\") or \"\"\n            l3 = row.get(l3_col, \"\") or \"\"\n            if not text:\n                continue\n            rows.append(DocRow(text=text, l1=l1, l2=l2, l3=l3))","source_hash":"ddb099315e7bc0048643832ced2f4eaea51afb31ff4bc31f66aeec55ff96ef67","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.build_wos_spans.load_wos_csv","uri":"program://TOLBERT/function/scripts.build_wos_spans.load_wos_csv#L70-L88","kind":"function","name":"load_wos_csv","path":"scripts/build_wos_spans.py","language":"python","start_line":70,"end_line":88,"context_start_line":50,"context_end_line":108,"code":"\"\"\"\n\nfrom __future__ import annotations\n\nimport argparse\nimport csv\nimport json\nfrom dataclasses import dataclass\nfrom pathlib import Path\nfrom typing import Dict, List, Tuple\n\n\n@dataclass\nclass DocRow:\n    text: str\n    l1: str\n    l2: str\n    l3: str\n\n\ndef load_wos_csv(\n    path: Path,\n    text_col: str,\n    l1_col: str,\n    l2_col: str,\n    l3_col: str,\n) -> List[DocRow]:\n    rows: List[DocRow] = []\n    with path.open(\"r\", encoding=\"utf-8\") as f:\n        reader = csv.DictReader(f)\n        for row in reader:\n            text = row.get(text_col, \"\") or \"\"\n            l1 = row.get(l1_col, \"\") or \"\"\n            l2 = row.get(l2_col, \"\") or \"\"\n            l3 = row.get(l3_col, \"\") or \"\"\n            if not text:\n                continue\n            rows.append(DocRow(text=text, l1=l1, l2=l2, l3=l3))\n    return rows\n\n\ndef build_ontology(rows: List[DocRow]) -> Tuple[Dict[str, int], Dict[str, int], Dict[str, int]]:\n    \"\"\"\n    Build integer node IDs for:\n      - level 1: unique l1 labels\n      - level 2: unique (l1, l2) pairs\n      - level 3: unique (l1, l2, l3) triples\n\n    Node IDs are global; path uses:\n      [root_id, l1_id, l2_id, l3_id]\n    \"\"\"\n    next_id = 0\n    root_id = next_id\n    next_id += 1\n\n    l1_ids: Dict[str, int] = {}\n    l2_ids: Dict[str, int] = {}\n    l3_ids: Dict[str, int] = {}\n","source_hash":"ddb099315e7bc0048643832ced2f4eaea51afb31ff4bc31f66aeec55ff96ef67","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.build_wos_spans.build_ontology","uri":"program://TOLBERT/function/scripts.build_wos_spans.build_ontology#L91-L124","kind":"function","name":"build_ontology","path":"scripts/build_wos_spans.py","language":"python","start_line":91,"end_line":124,"context_start_line":71,"context_end_line":144,"code":"    path: Path,\n    text_col: str,\n    l1_col: str,\n    l2_col: str,\n    l3_col: str,\n) -> List[DocRow]:\n    rows: List[DocRow] = []\n    with path.open(\"r\", encoding=\"utf-8\") as f:\n        reader = csv.DictReader(f)\n        for row in reader:\n            text = row.get(text_col, \"\") or \"\"\n            l1 = row.get(l1_col, \"\") or \"\"\n            l2 = row.get(l2_col, \"\") or \"\"\n            l3 = row.get(l3_col, \"\") or \"\"\n            if not text:\n                continue\n            rows.append(DocRow(text=text, l1=l1, l2=l2, l3=l3))\n    return rows\n\n\ndef build_ontology(rows: List[DocRow]) -> Tuple[Dict[str, int], Dict[str, int], Dict[str, int]]:\n    \"\"\"\n    Build integer node IDs for:\n      - level 1: unique l1 labels\n      - level 2: unique (l1, l2) pairs\n      - level 3: unique (l1, l2, l3) triples\n\n    Node IDs are global; path uses:\n      [root_id, l1_id, l2_id, l3_id]\n    \"\"\"\n    next_id = 0\n    root_id = next_id\n    next_id += 1\n\n    l1_ids: Dict[str, int] = {}\n    l2_ids: Dict[str, int] = {}\n    l3_ids: Dict[str, int] = {}\n\n    for r in rows:\n        if r.l1 and r.l1 not in l1_ids:\n            l1_ids[r.l1] = next_id\n            next_id += 1\n        if r.l1 and r.l2:\n            key2 = f\"{r.l1}::{r.l2}\"\n            if key2 not in l2_ids:\n                l2_ids[key2] = next_id\n                next_id += 1\n        if r.l1 and r.l2 and r.l3:\n            key3 = f\"{r.l1}::{r.l2}::{r.l3}\"\n            if key3 not in l3_ids:\n                l3_ids[key3] = next_id\n                next_id += 1\n\n    return l1_ids, l2_ids, l3_ids\n\n\ndef write_nodes_jsonl(\n    out_path: Path,\n    l1_ids: Dict[str, int],\n    l2_ids: Dict[str, int],\n    l3_ids: Dict[str, int],\n) -> None:\n    with out_path.open(\"w\", encoding=\"utf-8\") as f:\n        # Root\n        f.write(\n            json.dumps(\n                {\n                    \"node_id\": 0,\n                    \"level\": 0,\n                    \"type\": \"root\",\n                    \"parent_id\": None,\n                    \"name\": \"Root\",\n                    \"attributes\": {},\n                }","source_hash":"ddb099315e7bc0048643832ced2f4eaea51afb31ff4bc31f66aeec55ff96ef67","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.build_wos_spans.write_nodes_jsonl","uri":"program://TOLBERT/function/scripts.build_wos_spans.write_nodes_jsonl#L127-L200","kind":"function","name":"write_nodes_jsonl","path":"scripts/build_wos_spans.py","language":"python","start_line":127,"end_line":200,"context_start_line":107,"context_end_line":220,"code":"    l3_ids: Dict[str, int] = {}\n\n    for r in rows:\n        if r.l1 and r.l1 not in l1_ids:\n            l1_ids[r.l1] = next_id\n            next_id += 1\n        if r.l1 and r.l2:\n            key2 = f\"{r.l1}::{r.l2}\"\n            if key2 not in l2_ids:\n                l2_ids[key2] = next_id\n                next_id += 1\n        if r.l1 and r.l2 and r.l3:\n            key3 = f\"{r.l1}::{r.l2}::{r.l3}\"\n            if key3 not in l3_ids:\n                l3_ids[key3] = next_id\n                next_id += 1\n\n    return l1_ids, l2_ids, l3_ids\n\n\ndef write_nodes_jsonl(\n    out_path: Path,\n    l1_ids: Dict[str, int],\n    l2_ids: Dict[str, int],\n    l3_ids: Dict[str, int],\n) -> None:\n    with out_path.open(\"w\", encoding=\"utf-8\") as f:\n        # Root\n        f.write(\n            json.dumps(\n                {\n                    \"node_id\": 0,\n                    \"level\": 0,\n                    \"type\": \"root\",\n                    \"parent_id\": None,\n                    \"name\": \"Root\",\n                    \"attributes\": {},\n                }\n            )\n            + \"\\n\"\n        )\n\n        # Level 1 nodes\n        for name, nid in l1_ids.items():\n            f.write(\n                json.dumps(\n                    {\n                        \"node_id\": nid,\n                        \"level\": 1,\n                        \"type\": \"field\",\n                        \"parent_id\": 0,\n                        \"name\": name,\n                        \"attributes\": {},\n                    }\n                )\n                + \"\\n\"\n            )\n\n        # Level 2 nodes\n        for key, nid in l2_ids.items():\n            l1, l2 = key.split(\"::\", 1)\n            parent_id = l1_ids[l1]\n            f.write(\n                json.dumps(\n                    {\n                        \"node_id\": nid,\n                        \"level\": 2,\n                        \"type\": \"subfield\",\n                        \"parent_id\": parent_id,\n                        \"name\": l2,\n                        \"attributes\": {\"level1\": l1},\n                    }\n                )\n                + \"\\n\"\n            )\n\n        # Level 3 nodes\n        for key, nid in l3_ids.items():\n            l1, l2, l3 = key.split(\"::\", 2)\n            # Parent is the (l1,l2) node\n            parent_id = l2_ids[f\"{l1}::{l2}\"]\n            f.write(\n                json.dumps(\n                    {\n                        \"node_id\": nid,\n                        \"level\": 3,\n                        \"type\": \"discipline\",\n                        \"parent_id\": parent_id,\n                        \"name\": l3,\n                        \"attributes\": {\"level1\": l1, \"level2\": l2},\n                    }\n                )\n                + \"\\n\"\n            )\n\n\ndef build_spans(\n    rows: List[DocRow],\n    l1_ids: Dict[str, int],\n    l2_ids: Dict[str, int],\n    l3_ids: Dict[str, int],\n) -> List[Dict[str, object]]:\n    spans: List[Dict[str, object]] = []\n    root_id = 0\n    for idx, r in enumerate(rows):\n        span_id = f\"doc_{idx:06d}\"\n        l1_id = l1_ids.get(r.l1)\n        l2_id = None\n        l3_id = None\n        if r.l1 and r.l2:\n            key2 = f\"{r.l1}::{r.l2}\"\n            l2_id = l2_ids.get(key2)\n        if r.l1 and r.l2 and r.l3:\n            key3 = f\"{r.l1}::{r.l2}::{r.l3}\"","source_hash":"ddb099315e7bc0048643832ced2f4eaea51afb31ff4bc31f66aeec55ff96ef67","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.build_wos_spans.build_spans","uri":"program://TOLBERT/function/scripts.build_wos_spans.build_spans#L203-L245","kind":"function","name":"build_spans","path":"scripts/build_wos_spans.py","language":"python","start_line":203,"end_line":245,"context_start_line":183,"context_end_line":265,"code":"        # Level 3 nodes\n        for key, nid in l3_ids.items():\n            l1, l2, l3 = key.split(\"::\", 2)\n            # Parent is the (l1,l2) node\n            parent_id = l2_ids[f\"{l1}::{l2}\"]\n            f.write(\n                json.dumps(\n                    {\n                        \"node_id\": nid,\n                        \"level\": 3,\n                        \"type\": \"discipline\",\n                        \"parent_id\": parent_id,\n                        \"name\": l3,\n                        \"attributes\": {\"level1\": l1, \"level2\": l2},\n                    }\n                )\n                + \"\\n\"\n            )\n\n\ndef build_spans(\n    rows: List[DocRow],\n    l1_ids: Dict[str, int],\n    l2_ids: Dict[str, int],\n    l3_ids: Dict[str, int],\n) -> List[Dict[str, object]]:\n    spans: List[Dict[str, object]] = []\n    root_id = 0\n    for idx, r in enumerate(rows):\n        span_id = f\"doc_{idx:06d}\"\n        l1_id = l1_ids.get(r.l1)\n        l2_id = None\n        l3_id = None\n        if r.l1 and r.l2:\n            key2 = f\"{r.l1}::{r.l2}\"\n            l2_id = l2_ids.get(key2)\n        if r.l1 and r.l2 and r.l3:\n            key3 = f\"{r.l1}::{r.l2}::{r.l3}\"\n            l3_id = l3_ids.get(key3)\n\n        # Build node_path; allow partially-labeled paths by omitting unknowns.\n        path = [root_id]\n        if l1_id is not None:\n            path.append(l1_id)\n        if l2_id is not None:\n            path.append(l2_id)\n        if l3_id is not None:\n            path.append(l3_id)\n\n        spans.append(\n            {\n                \"span_id\": span_id,\n                \"text\": r.text,\n                \"source_id\": span_id,\n                \"node_path\": path,\n                \"meta\": {\n                    \"level1\": r.l1,\n                    \"level2\": r.l2,\n                    \"level3\": r.l3,\n                },\n            }\n        )\n    return spans\n\n\ndef write_spans_jsonl(spans: List[Dict[str, object]], out_path: Path) -> None:\n    with out_path.open(\"w\", encoding=\"utf-8\") as f:\n        for rec in spans:\n            f.write(json.dumps(rec) + \"\\n\")\n\n\ndef write_level_sizes(\n    l1_ids: Dict[str, int],\n    l2_ids: Dict[str, int],\n    l3_ids: Dict[str, int],\n    out_path: Path,\n) -> None:\n    level_sizes = {\n        1: len(l1_ids),\n        2: len(l2_ids),\n        3: len(l3_ids),\n    }\n    out = {\"level_sizes\": level_sizes}","source_hash":"ddb099315e7bc0048643832ced2f4eaea51afb31ff4bc31f66aeec55ff96ef67","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.build_wos_spans.write_spans_jsonl","uri":"program://TOLBERT/function/scripts.build_wos_spans.write_spans_jsonl#L248-L251","kind":"function","name":"write_spans_jsonl","path":"scripts/build_wos_spans.py","language":"python","start_line":248,"end_line":251,"context_start_line":228,"context_end_line":271,"code":"            path.append(l2_id)\n        if l3_id is not None:\n            path.append(l3_id)\n\n        spans.append(\n            {\n                \"span_id\": span_id,\n                \"text\": r.text,\n                \"source_id\": span_id,\n                \"node_path\": path,\n                \"meta\": {\n                    \"level1\": r.l1,\n                    \"level2\": r.l2,\n                    \"level3\": r.l3,\n                },\n            }\n        )\n    return spans\n\n\ndef write_spans_jsonl(spans: List[Dict[str, object]], out_path: Path) -> None:\n    with out_path.open(\"w\", encoding=\"utf-8\") as f:\n        for rec in spans:\n            f.write(json.dumps(rec) + \"\\n\")\n\n\ndef write_level_sizes(\n    l1_ids: Dict[str, int],\n    l2_ids: Dict[str, int],\n    l3_ids: Dict[str, int],\n    out_path: Path,\n) -> None:\n    level_sizes = {\n        1: len(l1_ids),\n        2: len(l2_ids),\n        3: len(l3_ids),\n    }\n    out = {\"level_sizes\": level_sizes}\n    with out_path.open(\"w\", encoding=\"utf-8\") as f:\n        json.dump(out, f, indent=2)\n\n\ndef parse_args() -> argparse.Namespace:\n    ap = argparse.ArgumentParser(description=\"Build WOS-style spans JSONL and ontology metadata.\")","source_hash":"ddb099315e7bc0048643832ced2f4eaea51afb31ff4bc31f66aeec55ff96ef67","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.build_wos_spans.write_level_sizes","uri":"program://TOLBERT/function/scripts.build_wos_spans.write_level_sizes#L254-L267","kind":"function","name":"write_level_sizes","path":"scripts/build_wos_spans.py","language":"python","start_line":254,"end_line":267,"context_start_line":234,"context_end_line":287,"code":"                \"span_id\": span_id,\n                \"text\": r.text,\n                \"source_id\": span_id,\n                \"node_path\": path,\n                \"meta\": {\n                    \"level1\": r.l1,\n                    \"level2\": r.l2,\n                    \"level3\": r.l3,\n                },\n            }\n        )\n    return spans\n\n\ndef write_spans_jsonl(spans: List[Dict[str, object]], out_path: Path) -> None:\n    with out_path.open(\"w\", encoding=\"utf-8\") as f:\n        for rec in spans:\n            f.write(json.dumps(rec) + \"\\n\")\n\n\ndef write_level_sizes(\n    l1_ids: Dict[str, int],\n    l2_ids: Dict[str, int],\n    l3_ids: Dict[str, int],\n    out_path: Path,\n) -> None:\n    level_sizes = {\n        1: len(l1_ids),\n        2: len(l2_ids),\n        3: len(l3_ids),\n    }\n    out = {\"level_sizes\": level_sizes}\n    with out_path.open(\"w\", encoding=\"utf-8\") as f:\n        json.dump(out, f, indent=2)\n\n\ndef parse_args() -> argparse.Namespace:\n    ap = argparse.ArgumentParser(description=\"Build WOS-style spans JSONL and ontology metadata.\")\n    ap.add_argument(\"--input-csv\", type=str, required=True, help=\"Input CSV file with text + labels.\")\n    ap.add_argument(\"--spans-out\", type=str, required=True, help=\"Output spans JSONL file.\")\n    ap.add_argument(\"--nodes-out\", type=str, default=\"\", help=\"Optional nodes JSONL output.\")\n    ap.add_argument(\n        \"--level-sizes-out\",\n        type=str,\n        default=\"\",\n        help=\"Optional JSON file with level_sizes helper dict.\",\n    )\n    ap.add_argument(\"--text-col\", type=str, default=\"text\", help=\"Text column name.\")\n    ap.add_argument(\"--l1-col\", type=str, default=\"level1\", help=\"Level-1 label column name.\")\n    ap.add_argument(\"--l2-col\", type=str, default=\"level2\", help=\"Level-2 label column name.\")\n    ap.add_argument(\"--l3-col\", type=str, default=\"level3\", help=\"Level-3 label column name.\")\n    return ap.parse_args()\n\n","source_hash":"ddb099315e7bc0048643832ced2f4eaea51afb31ff4bc31f66aeec55ff96ef67","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.build_wos_spans.parse_args","uri":"program://TOLBERT/function/scripts.build_wos_spans.parse_args#L270-L285","kind":"function","name":"parse_args","path":"scripts/build_wos_spans.py","language":"python","start_line":270,"end_line":285,"context_start_line":250,"context_end_line":305,"code":"        for rec in spans:\n            f.write(json.dumps(rec) + \"\\n\")\n\n\ndef write_level_sizes(\n    l1_ids: Dict[str, int],\n    l2_ids: Dict[str, int],\n    l3_ids: Dict[str, int],\n    out_path: Path,\n) -> None:\n    level_sizes = {\n        1: len(l1_ids),\n        2: len(l2_ids),\n        3: len(l3_ids),\n    }\n    out = {\"level_sizes\": level_sizes}\n    with out_path.open(\"w\", encoding=\"utf-8\") as f:\n        json.dump(out, f, indent=2)\n\n\ndef parse_args() -> argparse.Namespace:\n    ap = argparse.ArgumentParser(description=\"Build WOS-style spans JSONL and ontology metadata.\")\n    ap.add_argument(\"--input-csv\", type=str, required=True, help=\"Input CSV file with text + labels.\")\n    ap.add_argument(\"--spans-out\", type=str, required=True, help=\"Output spans JSONL file.\")\n    ap.add_argument(\"--nodes-out\", type=str, default=\"\", help=\"Optional nodes JSONL output.\")\n    ap.add_argument(\n        \"--level-sizes-out\",\n        type=str,\n        default=\"\",\n        help=\"Optional JSON file with level_sizes helper dict.\",\n    )\n    ap.add_argument(\"--text-col\", type=str, default=\"text\", help=\"Text column name.\")\n    ap.add_argument(\"--l1-col\", type=str, default=\"level1\", help=\"Level-1 label column name.\")\n    ap.add_argument(\"--l2-col\", type=str, default=\"level2\", help=\"Level-2 label column name.\")\n    ap.add_argument(\"--l3-col\", type=str, default=\"level3\", help=\"Level-3 label column name.\")\n    return ap.parse_args()\n\n\ndef main() -> None:\n    args = parse_args()\n\n    csv_path = Path(args.input_csv)\n    if not csv_path.exists():\n        raise FileNotFoundError(f\"Input CSV not found: {csv_path}\")\n\n    rows = load_wos_csv(\n        csv_path,\n        text_col=args.text_col,\n        l1_col=args.l1_col,\n        l2_col=args.l2_col,\n        l3_col=args.l3_col,\n    )\n\n    l1_ids, l2_ids, l3_ids = build_ontology(rows)\n\n    spans = build_spans(rows, l1_ids=l1_ids, l2_ids=l2_ids, l3_ids=l3_ids)","source_hash":"ddb099315e7bc0048643832ced2f4eaea51afb31ff4bc31f66aeec55ff96ef67","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.build_wos_spans.main","uri":"program://TOLBERT/function/scripts.build_wos_spans.main#L288-L319","kind":"function","name":"main","path":"scripts/build_wos_spans.py","language":"python","start_line":288,"end_line":319,"context_start_line":268,"context_end_line":325,"code":"\n\ndef parse_args() -> argparse.Namespace:\n    ap = argparse.ArgumentParser(description=\"Build WOS-style spans JSONL and ontology metadata.\")\n    ap.add_argument(\"--input-csv\", type=str, required=True, help=\"Input CSV file with text + labels.\")\n    ap.add_argument(\"--spans-out\", type=str, required=True, help=\"Output spans JSONL file.\")\n    ap.add_argument(\"--nodes-out\", type=str, default=\"\", help=\"Optional nodes JSONL output.\")\n    ap.add_argument(\n        \"--level-sizes-out\",\n        type=str,\n        default=\"\",\n        help=\"Optional JSON file with level_sizes helper dict.\",\n    )\n    ap.add_argument(\"--text-col\", type=str, default=\"text\", help=\"Text column name.\")\n    ap.add_argument(\"--l1-col\", type=str, default=\"level1\", help=\"Level-1 label column name.\")\n    ap.add_argument(\"--l2-col\", type=str, default=\"level2\", help=\"Level-2 label column name.\")\n    ap.add_argument(\"--l3-col\", type=str, default=\"level3\", help=\"Level-3 label column name.\")\n    return ap.parse_args()\n\n\ndef main() -> None:\n    args = parse_args()\n\n    csv_path = Path(args.input_csv)\n    if not csv_path.exists():\n        raise FileNotFoundError(f\"Input CSV not found: {csv_path}\")\n\n    rows = load_wos_csv(\n        csv_path,\n        text_col=args.text_col,\n        l1_col=args.l1_col,\n        l2_col=args.l2_col,\n        l3_col=args.l3_col,\n    )\n\n    l1_ids, l2_ids, l3_ids = build_ontology(rows)\n\n    spans = build_spans(rows, l1_ids=l1_ids, l2_ids=l2_ids, l3_ids=l3_ids)\n\n    spans_out = Path(args.spans_out)\n    spans_out.parent.mkdir(parents=True, exist_ok=True)\n    write_spans_jsonl(spans, spans_out)\n\n    if args.nodes_out:\n        nodes_out = Path(args.nodes_out)\n        nodes_out.parent.mkdir(parents=True, exist_ok=True)\n        write_nodes_jsonl(nodes_out, l1_ids=l1_ids, l2_ids=l2_ids, l3_ids=l3_ids)\n\n    if args.level_sizes_out:\n        ls_out = Path(args.level_sizes_out)\n        ls_out.parent.mkdir(parents=True, exist_ok=True)\n        write_level_sizes(l1_ids=l1_ids, l2_ids=l2_ids, l3_ids=l3_ids, out_path=ls_out)\n\n\nif __name__ == \"__main__\":\n    main()\n\n","source_hash":"ddb099315e7bc0048643832ced2f4eaea51afb31ff4bc31f66aeec55ff96ef67","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.codegraph_core","uri":"program://TOLBERT/module/scripts.codegraph_core#L1-L198","kind":"module","name":"scripts.codegraph_core","path":"scripts/codegraph_core.py","language":"python","start_line":1,"end_line":198,"context_start_line":1,"context_end_line":198,"code":"from __future__ import annotations\n\nimport os\nimport ast\nimport hashlib\nfrom dataclasses import dataclass\nfrom typing import Dict, List, Optional, Tuple, Iterable, Set\n\n\n@dataclass(frozen=True)\nclass FileSpan:\n    file: str           # absolute path\n    start_line: int     # 1-based inclusive\n    end_line: int       # 1-based inclusive\n\n\n@dataclass\nclass CGEntity:\n    id: str             # stable id (e.g., fqn)\n    kind: str           # module|function|class|test\n    name: str\n    file: str           # absolute path\n    owner: Optional[str]\n    start_line: int\n    end_line: int\n\n\n@dataclass\nclass CGEdge:\n    src: str            # CGEntity.id\n    dst: str            # CGEntity.id\n    type: str           # imports|calls|owns|tests\n\n\nclass CodeGraph:\n    def __init__(self, repo_root: str, ignore: Optional[List[str]] = None):\n        self.root = os.path.abspath(repo_root)\n        self.ignore_rules = [s for s in (ignore or []) if s]\n        self.entities_by_id: Dict[str, CGEntity] = {}\n        self.edges_list: List[CGEdge] = []\n        self._file_hash: Dict[str, str] = {}\n        self._id_by_module: Dict[str, str] = {}\n        self._ids_by_file: Dict[str, List[str]] = {}\n        self._index_identifiers: Dict[str, List[str]] = {}\n\n    # Build\n    def build(self) -> \"CodeGraph\":\n        py_files = self._discover_py_files(self.root, self.ignore_rules)\n        for abs_fp in py_files:\n            mod = self._module_name_for(abs_fp)\n            mid = f\"py:{mod}\"\n            self._id_by_module[mod] = mid\n            ent = CGEntity(\n                id=mid, kind=\"module\", name=mod, file=abs_fp, owner=None,\n                start_line=1, end_line=self._safe_count_lines(abs_fp),\n            )\n            self.entities_by_id[mid] = ent\n            self._ids_by_file.setdefault(abs_fp, []).append(mid)\n            self._index_identifiers.setdefault(mod.lower(), []).append(mid)\n            # Parse AST for defs/imports/calls\n            try:\n                with open(abs_fp, \"r\", encoding=\"utf-8\", errors=\"ignore\") as fh:\n                    src = fh.read()\n                tree = ast.parse(src)\n            except Exception:\n                tree = None\n            if tree is None:\n                continue\n            # functions/classes\n            for node in ast.walk(tree):\n                if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):\n                    name = getattr(node, \"name\", \"\")\n                    a = int(getattr(node, \"lineno\", 1))\n                    b = int(getattr(node, \"end_lineno\", a))\n                    fid = f\"py:{mod}.{name}\"\n                    self.entities_by_id[fid] = CGEntity(\n                        id=fid, kind=\"function\", name=name, file=abs_fp, owner=mid,\n                        start_line=a, end_line=b,\n                    )\n                    self._ids_by_file.setdefault(abs_fp, []).append(fid)\n                    self.edges_list.append(CGEdge(src=mid, dst=fid, type=\"owns\"))\n                    self._index_identifiers.setdefault(name.lower(), []).append(fid)\n                elif isinstance(node, ast.ClassDef):\n                    name = getattr(node, \"name\", \"\")\n                    a = int(getattr(node, \"lineno\", 1))\n                    b = int(getattr(node, \"end_lineno\", a))\n                    cid = f\"py:{mod}.{name}\"\n                    self.entities_by_id[cid] = CGEntity(\n                        id=cid, kind=\"class\", name=name, file=abs_fp, owner=mid,\n                        start_line=a, end_line=b,\n                    )\n                    self._ids_by_file.setdefault(abs_fp, []).append(cid)\n                    self.edges_list.append(CGEdge(src=mid, dst=cid, type=\"owns\"))\n                    self._index_identifiers.setdefault(name.lower(), []).append(cid)\n            # imports (module-level)\n            try:\n                for node in ast.walk(tree):\n                    if isinstance(node, ast.Import):\n                        for alias in node.names:\n                            im = alias.name\n                            if not im:\n                                continue\n                            tgt_mod = im\n                            tid = f\"py:{tgt_mod}\"\n                            self.edges_list.append(CGEdge(src=mid, dst=tid, type=\"imports\"))\n                    elif isinstance(node, ast.ImportFrom):\n                        im = node.module or \"\"\n                        if not im:\n                            continue\n                        tgt_mod = im\n                        tid = f\"py:{tgt_mod}\"\n                        self.edges_list.append(CGEdge(src=mid, dst=tid, type=\"imports\"))\n            except Exception:\n                pass\n            # calls (best-effort): record identifiers used in Call nodes\n            try:\n                for node in ast.walk(tree):\n                    if isinstance(node, ast.Call):\n                        fn = getattr(node, \"func\", None)\n                        name = None\n                        if isinstance(fn, ast.Attribute):\n                            name = getattr(fn, \"attr\", None)\n                        elif isinstance(fn, ast.Name):\n                            name = fn.id\n                        if name:\n                            lid = str(name).lower()\n                            for cand in self._index_identifiers.get(lid, []):\n                                self.edges_list.append(CGEdge(src=mid, dst=cand, type=\"calls\"))\n            except Exception:\n                pass\n            # tests tag\n            base = os.path.basename(abs_fp)\n            if base.startswith(\"test_\") or base.endswith(\"_test.py\"):\n                self.entities_by_id[mid].kind = \"test_module\"\n        # finalize file hashes\n        self._precompute_hashes(py_files)\n        return self\n\n    # Public accessors\n    def entities(self) -> Iterable[CGEntity]:\n        return self.entities_by_id.values()\n\n    def edges(self) -> Iterable[CGEdge]:\n        # Filter edges whose endpoints are known (post totality)\n        known = set(self.entities_by_id.keys())\n        for e in self.edges_list:\n            if (e.src in known) and (e.dst in known):\n                yield e\n\n    def file_hash(self, abs_path: str) -> str:\n        return self._file_hash.get(abs_path) or \"\"\n\n    def ids_for_file(self, abs_path: str) -> List[str]:\n        return list(self._ids_by_file.get(abs_path, []))\n\n    def find_identifier_ids(self, token: str) -> List[str]:\n        return list(self._index_identifiers.get(token.lower(), []))\n\n    # Helpers\n    def _discover_py_files(self, root: str, ignore: List[str]) -> List[str]:\n        out: List[str] = []\n        for dirpath, dirnames, filenames in os.walk(root):\n            # naive ignore: drop segments that contain any ignore pattern\n            if any(ig in dirpath for ig in ignore):\n                continue\n            for fn in filenames:\n                if not fn.endswith(\".py\"):\n                    continue\n                ap = os.path.abspath(os.path.join(dirpath, fn))\n                out.append(ap)\n        return out\n\n    def _module_name_for(self, abs_file: str) -> str:\n        # repo-relative without extension, path with dots\n        rel = os.path.relpath(abs_file, self.root).replace(\"\\\\\", \"/\")\n        if rel.endswith(\".py\"):\n            rel = rel[:-3]\n        parts = [p for p in rel.split(\"/\") if p and p != \"__init__\"]\n        return \".\".join(parts) or os.path.splitext(os.path.basename(abs_file))[0]\n\n    def _safe_count_lines(self, abs_file: str) -> int:\n        try:\n            with open(abs_file, \"r\", encoding=\"utf-8\", errors=\"ignore\") as fh:\n                return sum(1 for _ in fh)\n        except Exception:\n            return 1\n\n    def _precompute_hashes(self, files: List[str]) -> None:\n        for fp in files:\n            try:\n                with open(fp, \"rb\") as fh:\n                    raw = fh.read()\n                h = hashlib.sha256(raw).hexdigest()\n            except Exception:\n                h = \"\"\n            self._file_hash[fp] = h\n\n","source_hash":"27d2c9fbe4b62cf66c684b76a8ffba2ba3dad061314037a111259361fe252990","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.codegraph_core.FileSpan","uri":"program://TOLBERT/class/scripts.codegraph_core.FileSpan#L11-L14","kind":"class","name":"FileSpan","path":"scripts/codegraph_core.py","language":"python","start_line":11,"end_line":14,"context_start_line":1,"context_end_line":34,"code":"from __future__ import annotations\n\nimport os\nimport ast\nimport hashlib\nfrom dataclasses import dataclass\nfrom typing import Dict, List, Optional, Tuple, Iterable, Set\n\n\n@dataclass(frozen=True)\nclass FileSpan:\n    file: str           # absolute path\n    start_line: int     # 1-based inclusive\n    end_line: int       # 1-based inclusive\n\n\n@dataclass\nclass CGEntity:\n    id: str             # stable id (e.g., fqn)\n    kind: str           # module|function|class|test\n    name: str\n    file: str           # absolute path\n    owner: Optional[str]\n    start_line: int\n    end_line: int\n\n\n@dataclass\nclass CGEdge:\n    src: str            # CGEntity.id\n    dst: str            # CGEntity.id\n    type: str           # imports|calls|owns|tests\n\n","source_hash":"27d2c9fbe4b62cf66c684b76a8ffba2ba3dad061314037a111259361fe252990","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.codegraph_core.CGEntity","uri":"program://TOLBERT/class/scripts.codegraph_core.CGEntity#L18-L25","kind":"class","name":"CGEntity","path":"scripts/codegraph_core.py","language":"python","start_line":18,"end_line":25,"context_start_line":1,"context_end_line":45,"code":"from __future__ import annotations\n\nimport os\nimport ast\nimport hashlib\nfrom dataclasses import dataclass\nfrom typing import Dict, List, Optional, Tuple, Iterable, Set\n\n\n@dataclass(frozen=True)\nclass FileSpan:\n    file: str           # absolute path\n    start_line: int     # 1-based inclusive\n    end_line: int       # 1-based inclusive\n\n\n@dataclass\nclass CGEntity:\n    id: str             # stable id (e.g., fqn)\n    kind: str           # module|function|class|test\n    name: str\n    file: str           # absolute path\n    owner: Optional[str]\n    start_line: int\n    end_line: int\n\n\n@dataclass\nclass CGEdge:\n    src: str            # CGEntity.id\n    dst: str            # CGEntity.id\n    type: str           # imports|calls|owns|tests\n\n\nclass CodeGraph:\n    def __init__(self, repo_root: str, ignore: Optional[List[str]] = None):\n        self.root = os.path.abspath(repo_root)\n        self.ignore_rules = [s for s in (ignore or []) if s]\n        self.entities_by_id: Dict[str, CGEntity] = {}\n        self.edges_list: List[CGEdge] = []\n        self._file_hash: Dict[str, str] = {}\n        self._id_by_module: Dict[str, str] = {}\n        self._ids_by_file: Dict[str, List[str]] = {}\n        self._index_identifiers: Dict[str, List[str]] = {}\n","source_hash":"27d2c9fbe4b62cf66c684b76a8ffba2ba3dad061314037a111259361fe252990","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.codegraph_core.CGEdge","uri":"program://TOLBERT/class/scripts.codegraph_core.CGEdge#L29-L32","kind":"class","name":"CGEdge","path":"scripts/codegraph_core.py","language":"python","start_line":29,"end_line":32,"context_start_line":9,"context_end_line":52,"code":"\n@dataclass(frozen=True)\nclass FileSpan:\n    file: str           # absolute path\n    start_line: int     # 1-based inclusive\n    end_line: int       # 1-based inclusive\n\n\n@dataclass\nclass CGEntity:\n    id: str             # stable id (e.g., fqn)\n    kind: str           # module|function|class|test\n    name: str\n    file: str           # absolute path\n    owner: Optional[str]\n    start_line: int\n    end_line: int\n\n\n@dataclass\nclass CGEdge:\n    src: str            # CGEntity.id\n    dst: str            # CGEntity.id\n    type: str           # imports|calls|owns|tests\n\n\nclass CodeGraph:\n    def __init__(self, repo_root: str, ignore: Optional[List[str]] = None):\n        self.root = os.path.abspath(repo_root)\n        self.ignore_rules = [s for s in (ignore or []) if s]\n        self.entities_by_id: Dict[str, CGEntity] = {}\n        self.edges_list: List[CGEdge] = []\n        self._file_hash: Dict[str, str] = {}\n        self._id_by_module: Dict[str, str] = {}\n        self._ids_by_file: Dict[str, List[str]] = {}\n        self._index_identifiers: Dict[str, List[str]] = {}\n\n    # Build\n    def build(self) -> \"CodeGraph\":\n        py_files = self._discover_py_files(self.root, self.ignore_rules)\n        for abs_fp in py_files:\n            mod = self._module_name_for(abs_fp)\n            mid = f\"py:{mod}\"\n            self._id_by_module[mod] = mid","source_hash":"27d2c9fbe4b62cf66c684b76a8ffba2ba3dad061314037a111259361fe252990","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.codegraph_core.CodeGraph","uri":"program://TOLBERT/class/scripts.codegraph_core.CodeGraph#L35-L196","kind":"class","name":"CodeGraph","path":"scripts/codegraph_core.py","language":"python","start_line":35,"end_line":196,"context_start_line":15,"context_end_line":198,"code":"\n\n@dataclass\nclass CGEntity:\n    id: str             # stable id (e.g., fqn)\n    kind: str           # module|function|class|test\n    name: str\n    file: str           # absolute path\n    owner: Optional[str]\n    start_line: int\n    end_line: int\n\n\n@dataclass\nclass CGEdge:\n    src: str            # CGEntity.id\n    dst: str            # CGEntity.id\n    type: str           # imports|calls|owns|tests\n\n\nclass CodeGraph:\n    def __init__(self, repo_root: str, ignore: Optional[List[str]] = None):\n        self.root = os.path.abspath(repo_root)\n        self.ignore_rules = [s for s in (ignore or []) if s]\n        self.entities_by_id: Dict[str, CGEntity] = {}\n        self.edges_list: List[CGEdge] = []\n        self._file_hash: Dict[str, str] = {}\n        self._id_by_module: Dict[str, str] = {}\n        self._ids_by_file: Dict[str, List[str]] = {}\n        self._index_identifiers: Dict[str, List[str]] = {}\n\n    # Build\n    def build(self) -> \"CodeGraph\":\n        py_files = self._discover_py_files(self.root, self.ignore_rules)\n        for abs_fp in py_files:\n            mod = self._module_name_for(abs_fp)\n            mid = f\"py:{mod}\"\n            self._id_by_module[mod] = mid\n            ent = CGEntity(\n                id=mid, kind=\"module\", name=mod, file=abs_fp, owner=None,\n                start_line=1, end_line=self._safe_count_lines(abs_fp),\n            )\n            self.entities_by_id[mid] = ent\n            self._ids_by_file.setdefault(abs_fp, []).append(mid)\n            self._index_identifiers.setdefault(mod.lower(), []).append(mid)\n            # Parse AST for defs/imports/calls\n            try:\n                with open(abs_fp, \"r\", encoding=\"utf-8\", errors=\"ignore\") as fh:\n                    src = fh.read()\n                tree = ast.parse(src)\n            except Exception:\n                tree = None\n            if tree is None:\n                continue\n            # functions/classes\n            for node in ast.walk(tree):\n                if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):\n                    name = getattr(node, \"name\", \"\")\n                    a = int(getattr(node, \"lineno\", 1))\n                    b = int(getattr(node, \"end_lineno\", a))\n                    fid = f\"py:{mod}.{name}\"\n                    self.entities_by_id[fid] = CGEntity(\n                        id=fid, kind=\"function\", name=name, file=abs_fp, owner=mid,\n                        start_line=a, end_line=b,\n                    )\n                    self._ids_by_file.setdefault(abs_fp, []).append(fid)\n                    self.edges_list.append(CGEdge(src=mid, dst=fid, type=\"owns\"))\n                    self._index_identifiers.setdefault(name.lower(), []).append(fid)\n                elif isinstance(node, ast.ClassDef):\n                    name = getattr(node, \"name\", \"\")\n                    a = int(getattr(node, \"lineno\", 1))\n                    b = int(getattr(node, \"end_lineno\", a))\n                    cid = f\"py:{mod}.{name}\"\n                    self.entities_by_id[cid] = CGEntity(\n                        id=cid, kind=\"class\", name=name, file=abs_fp, owner=mid,\n                        start_line=a, end_line=b,\n                    )\n                    self._ids_by_file.setdefault(abs_fp, []).append(cid)\n                    self.edges_list.append(CGEdge(src=mid, dst=cid, type=\"owns\"))\n                    self._index_identifiers.setdefault(name.lower(), []).append(cid)\n            # imports (module-level)\n            try:\n                for node in ast.walk(tree):\n                    if isinstance(node, ast.Import):\n                        for alias in node.names:\n                            im = alias.name\n                            if not im:\n                                continue\n                            tgt_mod = im\n                            tid = f\"py:{tgt_mod}\"\n                            self.edges_list.append(CGEdge(src=mid, dst=tid, type=\"imports\"))\n                    elif isinstance(node, ast.ImportFrom):\n                        im = node.module or \"\"\n                        if not im:\n                            continue\n                        tgt_mod = im\n                        tid = f\"py:{tgt_mod}\"\n                        self.edges_list.append(CGEdge(src=mid, dst=tid, type=\"imports\"))\n            except Exception:\n                pass\n            # calls (best-effort): record identifiers used in Call nodes\n            try:\n                for node in ast.walk(tree):\n                    if isinstance(node, ast.Call):\n                        fn = getattr(node, \"func\", None)\n                        name = None\n                        if isinstance(fn, ast.Attribute):\n                            name = getattr(fn, \"attr\", None)\n                        elif isinstance(fn, ast.Name):\n                            name = fn.id\n                        if name:\n                            lid = str(name).lower()\n                            for cand in self._index_identifiers.get(lid, []):\n                                self.edges_list.append(CGEdge(src=mid, dst=cand, type=\"calls\"))\n            except Exception:\n                pass\n            # tests tag\n            base = os.path.basename(abs_fp)\n            if base.startswith(\"test_\") or base.endswith(\"_test.py\"):\n                self.entities_by_id[mid].kind = \"test_module\"\n        # finalize file hashes\n        self._precompute_hashes(py_files)\n        return self\n\n    # Public accessors\n    def entities(self) -> Iterable[CGEntity]:\n        return self.entities_by_id.values()\n\n    def edges(self) -> Iterable[CGEdge]:\n        # Filter edges whose endpoints are known (post totality)\n        known = set(self.entities_by_id.keys())\n        for e in self.edges_list:\n            if (e.src in known) and (e.dst in known):\n                yield e\n\n    def file_hash(self, abs_path: str) -> str:\n        return self._file_hash.get(abs_path) or \"\"\n\n    def ids_for_file(self, abs_path: str) -> List[str]:\n        return list(self._ids_by_file.get(abs_path, []))\n\n    def find_identifier_ids(self, token: str) -> List[str]:\n        return list(self._index_identifiers.get(token.lower(), []))\n\n    # Helpers\n    def _discover_py_files(self, root: str, ignore: List[str]) -> List[str]:\n        out: List[str] = []\n        for dirpath, dirnames, filenames in os.walk(root):\n            # naive ignore: drop segments that contain any ignore pattern\n            if any(ig in dirpath for ig in ignore):\n                continue\n            for fn in filenames:\n                if not fn.endswith(\".py\"):\n                    continue\n                ap = os.path.abspath(os.path.join(dirpath, fn))\n                out.append(ap)\n        return out\n\n    def _module_name_for(self, abs_file: str) -> str:\n        # repo-relative without extension, path with dots\n        rel = os.path.relpath(abs_file, self.root).replace(\"\\\\\", \"/\")\n        if rel.endswith(\".py\"):\n            rel = rel[:-3]\n        parts = [p for p in rel.split(\"/\") if p and p != \"__init__\"]\n        return \".\".join(parts) or os.path.splitext(os.path.basename(abs_file))[0]\n\n    def _safe_count_lines(self, abs_file: str) -> int:\n        try:\n            with open(abs_file, \"r\", encoding=\"utf-8\", errors=\"ignore\") as fh:\n                return sum(1 for _ in fh)\n        except Exception:\n            return 1\n\n    def _precompute_hashes(self, files: List[str]) -> None:\n        for fp in files:\n            try:\n                with open(fp, \"rb\") as fh:\n                    raw = fh.read()\n                h = hashlib.sha256(raw).hexdigest()\n            except Exception:\n                h = \"\"\n            self._file_hash[fp] = h\n\n","source_hash":"27d2c9fbe4b62cf66c684b76a8ffba2ba3dad061314037a111259361fe252990","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.codegraph_core.__init__","uri":"program://TOLBERT/function/scripts.codegraph_core.__init__#L36-L44","kind":"function","name":"__init__","path":"scripts/codegraph_core.py","language":"python","start_line":36,"end_line":44,"context_start_line":16,"context_end_line":64,"code":"\n@dataclass\nclass CGEntity:\n    id: str             # stable id (e.g., fqn)\n    kind: str           # module|function|class|test\n    name: str\n    file: str           # absolute path\n    owner: Optional[str]\n    start_line: int\n    end_line: int\n\n\n@dataclass\nclass CGEdge:\n    src: str            # CGEntity.id\n    dst: str            # CGEntity.id\n    type: str           # imports|calls|owns|tests\n\n\nclass CodeGraph:\n    def __init__(self, repo_root: str, ignore: Optional[List[str]] = None):\n        self.root = os.path.abspath(repo_root)\n        self.ignore_rules = [s for s in (ignore or []) if s]\n        self.entities_by_id: Dict[str, CGEntity] = {}\n        self.edges_list: List[CGEdge] = []\n        self._file_hash: Dict[str, str] = {}\n        self._id_by_module: Dict[str, str] = {}\n        self._ids_by_file: Dict[str, List[str]] = {}\n        self._index_identifiers: Dict[str, List[str]] = {}\n\n    # Build\n    def build(self) -> \"CodeGraph\":\n        py_files = self._discover_py_files(self.root, self.ignore_rules)\n        for abs_fp in py_files:\n            mod = self._module_name_for(abs_fp)\n            mid = f\"py:{mod}\"\n            self._id_by_module[mod] = mid\n            ent = CGEntity(\n                id=mid, kind=\"module\", name=mod, file=abs_fp, owner=None,\n                start_line=1, end_line=self._safe_count_lines(abs_fp),\n            )\n            self.entities_by_id[mid] = ent\n            self._ids_by_file.setdefault(abs_fp, []).append(mid)\n            self._index_identifiers.setdefault(mod.lower(), []).append(mid)\n            # Parse AST for defs/imports/calls\n            try:\n                with open(abs_fp, \"r\", encoding=\"utf-8\", errors=\"ignore\") as fh:\n                    src = fh.read()\n                tree = ast.parse(src)","source_hash":"27d2c9fbe4b62cf66c684b76a8ffba2ba3dad061314037a111259361fe252990","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.codegraph_core.build","uri":"program://TOLBERT/function/scripts.codegraph_core.build#L47-L137","kind":"function","name":"build","path":"scripts/codegraph_core.py","language":"python","start_line":47,"end_line":137,"context_start_line":27,"context_end_line":157,"code":"\n@dataclass\nclass CGEdge:\n    src: str            # CGEntity.id\n    dst: str            # CGEntity.id\n    type: str           # imports|calls|owns|tests\n\n\nclass CodeGraph:\n    def __init__(self, repo_root: str, ignore: Optional[List[str]] = None):\n        self.root = os.path.abspath(repo_root)\n        self.ignore_rules = [s for s in (ignore or []) if s]\n        self.entities_by_id: Dict[str, CGEntity] = {}\n        self.edges_list: List[CGEdge] = []\n        self._file_hash: Dict[str, str] = {}\n        self._id_by_module: Dict[str, str] = {}\n        self._ids_by_file: Dict[str, List[str]] = {}\n        self._index_identifiers: Dict[str, List[str]] = {}\n\n    # Build\n    def build(self) -> \"CodeGraph\":\n        py_files = self._discover_py_files(self.root, self.ignore_rules)\n        for abs_fp in py_files:\n            mod = self._module_name_for(abs_fp)\n            mid = f\"py:{mod}\"\n            self._id_by_module[mod] = mid\n            ent = CGEntity(\n                id=mid, kind=\"module\", name=mod, file=abs_fp, owner=None,\n                start_line=1, end_line=self._safe_count_lines(abs_fp),\n            )\n            self.entities_by_id[mid] = ent\n            self._ids_by_file.setdefault(abs_fp, []).append(mid)\n            self._index_identifiers.setdefault(mod.lower(), []).append(mid)\n            # Parse AST for defs/imports/calls\n            try:\n                with open(abs_fp, \"r\", encoding=\"utf-8\", errors=\"ignore\") as fh:\n                    src = fh.read()\n                tree = ast.parse(src)\n            except Exception:\n                tree = None\n            if tree is None:\n                continue\n            # functions/classes\n            for node in ast.walk(tree):\n                if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):\n                    name = getattr(node, \"name\", \"\")\n                    a = int(getattr(node, \"lineno\", 1))\n                    b = int(getattr(node, \"end_lineno\", a))\n                    fid = f\"py:{mod}.{name}\"\n                    self.entities_by_id[fid] = CGEntity(\n                        id=fid, kind=\"function\", name=name, file=abs_fp, owner=mid,\n                        start_line=a, end_line=b,\n                    )\n                    self._ids_by_file.setdefault(abs_fp, []).append(fid)\n                    self.edges_list.append(CGEdge(src=mid, dst=fid, type=\"owns\"))\n                    self._index_identifiers.setdefault(name.lower(), []).append(fid)\n                elif isinstance(node, ast.ClassDef):\n                    name = getattr(node, \"name\", \"\")\n                    a = int(getattr(node, \"lineno\", 1))\n                    b = int(getattr(node, \"end_lineno\", a))\n                    cid = f\"py:{mod}.{name}\"\n                    self.entities_by_id[cid] = CGEntity(\n                        id=cid, kind=\"class\", name=name, file=abs_fp, owner=mid,\n                        start_line=a, end_line=b,\n                    )\n                    self._ids_by_file.setdefault(abs_fp, []).append(cid)\n                    self.edges_list.append(CGEdge(src=mid, dst=cid, type=\"owns\"))\n                    self._index_identifiers.setdefault(name.lower(), []).append(cid)\n            # imports (module-level)\n            try:\n                for node in ast.walk(tree):\n                    if isinstance(node, ast.Import):\n                        for alias in node.names:\n                            im = alias.name\n                            if not im:\n                                continue\n                            tgt_mod = im\n                            tid = f\"py:{tgt_mod}\"\n                            self.edges_list.append(CGEdge(src=mid, dst=tid, type=\"imports\"))\n                    elif isinstance(node, ast.ImportFrom):\n                        im = node.module or \"\"\n                        if not im:\n                            continue\n                        tgt_mod = im\n                        tid = f\"py:{tgt_mod}\"\n                        self.edges_list.append(CGEdge(src=mid, dst=tid, type=\"imports\"))\n            except Exception:\n                pass\n            # calls (best-effort): record identifiers used in Call nodes\n            try:\n                for node in ast.walk(tree):\n                    if isinstance(node, ast.Call):\n                        fn = getattr(node, \"func\", None)\n                        name = None\n                        if isinstance(fn, ast.Attribute):\n                            name = getattr(fn, \"attr\", None)\n                        elif isinstance(fn, ast.Name):\n                            name = fn.id\n                        if name:\n                            lid = str(name).lower()\n                            for cand in self._index_identifiers.get(lid, []):\n                                self.edges_list.append(CGEdge(src=mid, dst=cand, type=\"calls\"))\n            except Exception:\n                pass\n            # tests tag\n            base = os.path.basename(abs_fp)\n            if base.startswith(\"test_\") or base.endswith(\"_test.py\"):\n                self.entities_by_id[mid].kind = \"test_module\"\n        # finalize file hashes\n        self._precompute_hashes(py_files)\n        return self\n\n    # Public accessors\n    def entities(self) -> Iterable[CGEntity]:\n        return self.entities_by_id.values()\n\n    def edges(self) -> Iterable[CGEdge]:\n        # Filter edges whose endpoints are known (post totality)\n        known = set(self.entities_by_id.keys())\n        for e in self.edges_list:\n            if (e.src in known) and (e.dst in known):\n                yield e\n\n    def file_hash(self, abs_path: str) -> str:\n        return self._file_hash.get(abs_path) or \"\"\n\n    def ids_for_file(self, abs_path: str) -> List[str]:\n        return list(self._ids_by_file.get(abs_path, []))\n\n    def find_identifier_ids(self, token: str) -> List[str]:\n        return list(self._index_identifiers.get(token.lower(), []))","source_hash":"27d2c9fbe4b62cf66c684b76a8ffba2ba3dad061314037a111259361fe252990","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.codegraph_core.entities","uri":"program://TOLBERT/function/scripts.codegraph_core.entities#L140-L141","kind":"function","name":"entities","path":"scripts/codegraph_core.py","language":"python","start_line":140,"end_line":141,"context_start_line":120,"context_end_line":161,"code":"                        name = None\n                        if isinstance(fn, ast.Attribute):\n                            name = getattr(fn, \"attr\", None)\n                        elif isinstance(fn, ast.Name):\n                            name = fn.id\n                        if name:\n                            lid = str(name).lower()\n                            for cand in self._index_identifiers.get(lid, []):\n                                self.edges_list.append(CGEdge(src=mid, dst=cand, type=\"calls\"))\n            except Exception:\n                pass\n            # tests tag\n            base = os.path.basename(abs_fp)\n            if base.startswith(\"test_\") or base.endswith(\"_test.py\"):\n                self.entities_by_id[mid].kind = \"test_module\"\n        # finalize file hashes\n        self._precompute_hashes(py_files)\n        return self\n\n    # Public accessors\n    def entities(self) -> Iterable[CGEntity]:\n        return self.entities_by_id.values()\n\n    def edges(self) -> Iterable[CGEdge]:\n        # Filter edges whose endpoints are known (post totality)\n        known = set(self.entities_by_id.keys())\n        for e in self.edges_list:\n            if (e.src in known) and (e.dst in known):\n                yield e\n\n    def file_hash(self, abs_path: str) -> str:\n        return self._file_hash.get(abs_path) or \"\"\n\n    def ids_for_file(self, abs_path: str) -> List[str]:\n        return list(self._ids_by_file.get(abs_path, []))\n\n    def find_identifier_ids(self, token: str) -> List[str]:\n        return list(self._index_identifiers.get(token.lower(), []))\n\n    # Helpers\n    def _discover_py_files(self, root: str, ignore: List[str]) -> List[str]:\n        out: List[str] = []","source_hash":"27d2c9fbe4b62cf66c684b76a8ffba2ba3dad061314037a111259361fe252990","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.codegraph_core.edges","uri":"program://TOLBERT/function/scripts.codegraph_core.edges#L143-L148","kind":"function","name":"edges","path":"scripts/codegraph_core.py","language":"python","start_line":143,"end_line":148,"context_start_line":123,"context_end_line":168,"code":"                        elif isinstance(fn, ast.Name):\n                            name = fn.id\n                        if name:\n                            lid = str(name).lower()\n                            for cand in self._index_identifiers.get(lid, []):\n                                self.edges_list.append(CGEdge(src=mid, dst=cand, type=\"calls\"))\n            except Exception:\n                pass\n            # tests tag\n            base = os.path.basename(abs_fp)\n            if base.startswith(\"test_\") or base.endswith(\"_test.py\"):\n                self.entities_by_id[mid].kind = \"test_module\"\n        # finalize file hashes\n        self._precompute_hashes(py_files)\n        return self\n\n    # Public accessors\n    def entities(self) -> Iterable[CGEntity]:\n        return self.entities_by_id.values()\n\n    def edges(self) -> Iterable[CGEdge]:\n        # Filter edges whose endpoints are known (post totality)\n        known = set(self.entities_by_id.keys())\n        for e in self.edges_list:\n            if (e.src in known) and (e.dst in known):\n                yield e\n\n    def file_hash(self, abs_path: str) -> str:\n        return self._file_hash.get(abs_path) or \"\"\n\n    def ids_for_file(self, abs_path: str) -> List[str]:\n        return list(self._ids_by_file.get(abs_path, []))\n\n    def find_identifier_ids(self, token: str) -> List[str]:\n        return list(self._index_identifiers.get(token.lower(), []))\n\n    # Helpers\n    def _discover_py_files(self, root: str, ignore: List[str]) -> List[str]:\n        out: List[str] = []\n        for dirpath, dirnames, filenames in os.walk(root):\n            # naive ignore: drop segments that contain any ignore pattern\n            if any(ig in dirpath for ig in ignore):\n                continue\n            for fn in filenames:\n                if not fn.endswith(\".py\"):\n                    continue","source_hash":"27d2c9fbe4b62cf66c684b76a8ffba2ba3dad061314037a111259361fe252990","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.codegraph_core.file_hash","uri":"program://TOLBERT/function/scripts.codegraph_core.file_hash#L150-L151","kind":"function","name":"file_hash","path":"scripts/codegraph_core.py","language":"python","start_line":150,"end_line":151,"context_start_line":130,"context_end_line":171,"code":"                pass\n            # tests tag\n            base = os.path.basename(abs_fp)\n            if base.startswith(\"test_\") or base.endswith(\"_test.py\"):\n                self.entities_by_id[mid].kind = \"test_module\"\n        # finalize file hashes\n        self._precompute_hashes(py_files)\n        return self\n\n    # Public accessors\n    def entities(self) -> Iterable[CGEntity]:\n        return self.entities_by_id.values()\n\n    def edges(self) -> Iterable[CGEdge]:\n        # Filter edges whose endpoints are known (post totality)\n        known = set(self.entities_by_id.keys())\n        for e in self.edges_list:\n            if (e.src in known) and (e.dst in known):\n                yield e\n\n    def file_hash(self, abs_path: str) -> str:\n        return self._file_hash.get(abs_path) or \"\"\n\n    def ids_for_file(self, abs_path: str) -> List[str]:\n        return list(self._ids_by_file.get(abs_path, []))\n\n    def find_identifier_ids(self, token: str) -> List[str]:\n        return list(self._index_identifiers.get(token.lower(), []))\n\n    # Helpers\n    def _discover_py_files(self, root: str, ignore: List[str]) -> List[str]:\n        out: List[str] = []\n        for dirpath, dirnames, filenames in os.walk(root):\n            # naive ignore: drop segments that contain any ignore pattern\n            if any(ig in dirpath for ig in ignore):\n                continue\n            for fn in filenames:\n                if not fn.endswith(\".py\"):\n                    continue\n                ap = os.path.abspath(os.path.join(dirpath, fn))\n                out.append(ap)\n        return out","source_hash":"27d2c9fbe4b62cf66c684b76a8ffba2ba3dad061314037a111259361fe252990","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.codegraph_core.ids_for_file","uri":"program://TOLBERT/function/scripts.codegraph_core.ids_for_file#L153-L154","kind":"function","name":"ids_for_file","path":"scripts/codegraph_core.py","language":"python","start_line":153,"end_line":154,"context_start_line":133,"context_end_line":174,"code":"            if base.startswith(\"test_\") or base.endswith(\"_test.py\"):\n                self.entities_by_id[mid].kind = \"test_module\"\n        # finalize file hashes\n        self._precompute_hashes(py_files)\n        return self\n\n    # Public accessors\n    def entities(self) -> Iterable[CGEntity]:\n        return self.entities_by_id.values()\n\n    def edges(self) -> Iterable[CGEdge]:\n        # Filter edges whose endpoints are known (post totality)\n        known = set(self.entities_by_id.keys())\n        for e in self.edges_list:\n            if (e.src in known) and (e.dst in known):\n                yield e\n\n    def file_hash(self, abs_path: str) -> str:\n        return self._file_hash.get(abs_path) or \"\"\n\n    def ids_for_file(self, abs_path: str) -> List[str]:\n        return list(self._ids_by_file.get(abs_path, []))\n\n    def find_identifier_ids(self, token: str) -> List[str]:\n        return list(self._index_identifiers.get(token.lower(), []))\n\n    # Helpers\n    def _discover_py_files(self, root: str, ignore: List[str]) -> List[str]:\n        out: List[str] = []\n        for dirpath, dirnames, filenames in os.walk(root):\n            # naive ignore: drop segments that contain any ignore pattern\n            if any(ig in dirpath for ig in ignore):\n                continue\n            for fn in filenames:\n                if not fn.endswith(\".py\"):\n                    continue\n                ap = os.path.abspath(os.path.join(dirpath, fn))\n                out.append(ap)\n        return out\n\n    def _module_name_for(self, abs_file: str) -> str:\n        # repo-relative without extension, path with dots","source_hash":"27d2c9fbe4b62cf66c684b76a8ffba2ba3dad061314037a111259361fe252990","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.codegraph_core.find_identifier_ids","uri":"program://TOLBERT/function/scripts.codegraph_core.find_identifier_ids#L156-L157","kind":"function","name":"find_identifier_ids","path":"scripts/codegraph_core.py","language":"python","start_line":156,"end_line":157,"context_start_line":136,"context_end_line":177,"code":"        self._precompute_hashes(py_files)\n        return self\n\n    # Public accessors\n    def entities(self) -> Iterable[CGEntity]:\n        return self.entities_by_id.values()\n\n    def edges(self) -> Iterable[CGEdge]:\n        # Filter edges whose endpoints are known (post totality)\n        known = set(self.entities_by_id.keys())\n        for e in self.edges_list:\n            if (e.src in known) and (e.dst in known):\n                yield e\n\n    def file_hash(self, abs_path: str) -> str:\n        return self._file_hash.get(abs_path) or \"\"\n\n    def ids_for_file(self, abs_path: str) -> List[str]:\n        return list(self._ids_by_file.get(abs_path, []))\n\n    def find_identifier_ids(self, token: str) -> List[str]:\n        return list(self._index_identifiers.get(token.lower(), []))\n\n    # Helpers\n    def _discover_py_files(self, root: str, ignore: List[str]) -> List[str]:\n        out: List[str] = []\n        for dirpath, dirnames, filenames in os.walk(root):\n            # naive ignore: drop segments that contain any ignore pattern\n            if any(ig in dirpath for ig in ignore):\n                continue\n            for fn in filenames:\n                if not fn.endswith(\".py\"):\n                    continue\n                ap = os.path.abspath(os.path.join(dirpath, fn))\n                out.append(ap)\n        return out\n\n    def _module_name_for(self, abs_file: str) -> str:\n        # repo-relative without extension, path with dots\n        rel = os.path.relpath(abs_file, self.root).replace(\"\\\\\", \"/\")\n        if rel.endswith(\".py\"):\n            rel = rel[:-3]","source_hash":"27d2c9fbe4b62cf66c684b76a8ffba2ba3dad061314037a111259361fe252990","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.codegraph_core._discover_py_files","uri":"program://TOLBERT/function/scripts.codegraph_core._discover_py_files#L160-L171","kind":"function","name":"_discover_py_files","path":"scripts/codegraph_core.py","language":"python","start_line":160,"end_line":171,"context_start_line":140,"context_end_line":191,"code":"    def entities(self) -> Iterable[CGEntity]:\n        return self.entities_by_id.values()\n\n    def edges(self) -> Iterable[CGEdge]:\n        # Filter edges whose endpoints are known (post totality)\n        known = set(self.entities_by_id.keys())\n        for e in self.edges_list:\n            if (e.src in known) and (e.dst in known):\n                yield e\n\n    def file_hash(self, abs_path: str) -> str:\n        return self._file_hash.get(abs_path) or \"\"\n\n    def ids_for_file(self, abs_path: str) -> List[str]:\n        return list(self._ids_by_file.get(abs_path, []))\n\n    def find_identifier_ids(self, token: str) -> List[str]:\n        return list(self._index_identifiers.get(token.lower(), []))\n\n    # Helpers\n    def _discover_py_files(self, root: str, ignore: List[str]) -> List[str]:\n        out: List[str] = []\n        for dirpath, dirnames, filenames in os.walk(root):\n            # naive ignore: drop segments that contain any ignore pattern\n            if any(ig in dirpath for ig in ignore):\n                continue\n            for fn in filenames:\n                if not fn.endswith(\".py\"):\n                    continue\n                ap = os.path.abspath(os.path.join(dirpath, fn))\n                out.append(ap)\n        return out\n\n    def _module_name_for(self, abs_file: str) -> str:\n        # repo-relative without extension, path with dots\n        rel = os.path.relpath(abs_file, self.root).replace(\"\\\\\", \"/\")\n        if rel.endswith(\".py\"):\n            rel = rel[:-3]\n        parts = [p for p in rel.split(\"/\") if p and p != \"__init__\"]\n        return \".\".join(parts) or os.path.splitext(os.path.basename(abs_file))[0]\n\n    def _safe_count_lines(self, abs_file: str) -> int:\n        try:\n            with open(abs_file, \"r\", encoding=\"utf-8\", errors=\"ignore\") as fh:\n                return sum(1 for _ in fh)\n        except Exception:\n            return 1\n\n    def _precompute_hashes(self, files: List[str]) -> None:\n        for fp in files:\n            try:\n                with open(fp, \"rb\") as fh:","source_hash":"27d2c9fbe4b62cf66c684b76a8ffba2ba3dad061314037a111259361fe252990","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.codegraph_core._module_name_for","uri":"program://TOLBERT/function/scripts.codegraph_core._module_name_for#L173-L179","kind":"function","name":"_module_name_for","path":"scripts/codegraph_core.py","language":"python","start_line":173,"end_line":179,"context_start_line":153,"context_end_line":198,"code":"    def ids_for_file(self, abs_path: str) -> List[str]:\n        return list(self._ids_by_file.get(abs_path, []))\n\n    def find_identifier_ids(self, token: str) -> List[str]:\n        return list(self._index_identifiers.get(token.lower(), []))\n\n    # Helpers\n    def _discover_py_files(self, root: str, ignore: List[str]) -> List[str]:\n        out: List[str] = []\n        for dirpath, dirnames, filenames in os.walk(root):\n            # naive ignore: drop segments that contain any ignore pattern\n            if any(ig in dirpath for ig in ignore):\n                continue\n            for fn in filenames:\n                if not fn.endswith(\".py\"):\n                    continue\n                ap = os.path.abspath(os.path.join(dirpath, fn))\n                out.append(ap)\n        return out\n\n    def _module_name_for(self, abs_file: str) -> str:\n        # repo-relative without extension, path with dots\n        rel = os.path.relpath(abs_file, self.root).replace(\"\\\\\", \"/\")\n        if rel.endswith(\".py\"):\n            rel = rel[:-3]\n        parts = [p for p in rel.split(\"/\") if p and p != \"__init__\"]\n        return \".\".join(parts) or os.path.splitext(os.path.basename(abs_file))[0]\n\n    def _safe_count_lines(self, abs_file: str) -> int:\n        try:\n            with open(abs_file, \"r\", encoding=\"utf-8\", errors=\"ignore\") as fh:\n                return sum(1 for _ in fh)\n        except Exception:\n            return 1\n\n    def _precompute_hashes(self, files: List[str]) -> None:\n        for fp in files:\n            try:\n                with open(fp, \"rb\") as fh:\n                    raw = fh.read()\n                h = hashlib.sha256(raw).hexdigest()\n            except Exception:\n                h = \"\"\n            self._file_hash[fp] = h\n\n","source_hash":"27d2c9fbe4b62cf66c684b76a8ffba2ba3dad061314037a111259361fe252990","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.codegraph_core._safe_count_lines","uri":"program://TOLBERT/function/scripts.codegraph_core._safe_count_lines#L181-L186","kind":"function","name":"_safe_count_lines","path":"scripts/codegraph_core.py","language":"python","start_line":181,"end_line":186,"context_start_line":161,"context_end_line":198,"code":"        out: List[str] = []\n        for dirpath, dirnames, filenames in os.walk(root):\n            # naive ignore: drop segments that contain any ignore pattern\n            if any(ig in dirpath for ig in ignore):\n                continue\n            for fn in filenames:\n                if not fn.endswith(\".py\"):\n                    continue\n                ap = os.path.abspath(os.path.join(dirpath, fn))\n                out.append(ap)\n        return out\n\n    def _module_name_for(self, abs_file: str) -> str:\n        # repo-relative without extension, path with dots\n        rel = os.path.relpath(abs_file, self.root).replace(\"\\\\\", \"/\")\n        if rel.endswith(\".py\"):\n            rel = rel[:-3]\n        parts = [p for p in rel.split(\"/\") if p and p != \"__init__\"]\n        return \".\".join(parts) or os.path.splitext(os.path.basename(abs_file))[0]\n\n    def _safe_count_lines(self, abs_file: str) -> int:\n        try:\n            with open(abs_file, \"r\", encoding=\"utf-8\", errors=\"ignore\") as fh:\n                return sum(1 for _ in fh)\n        except Exception:\n            return 1\n\n    def _precompute_hashes(self, files: List[str]) -> None:\n        for fp in files:\n            try:\n                with open(fp, \"rb\") as fh:\n                    raw = fh.read()\n                h = hashlib.sha256(raw).hexdigest()\n            except Exception:\n                h = \"\"\n            self._file_hash[fp] = h\n\n","source_hash":"27d2c9fbe4b62cf66c684b76a8ffba2ba3dad061314037a111259361fe252990","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.codegraph_core._precompute_hashes","uri":"program://TOLBERT/function/scripts.codegraph_core._precompute_hashes#L188-L196","kind":"function","name":"_precompute_hashes","path":"scripts/codegraph_core.py","language":"python","start_line":188,"end_line":196,"context_start_line":168,"context_end_line":198,"code":"                    continue\n                ap = os.path.abspath(os.path.join(dirpath, fn))\n                out.append(ap)\n        return out\n\n    def _module_name_for(self, abs_file: str) -> str:\n        # repo-relative without extension, path with dots\n        rel = os.path.relpath(abs_file, self.root).replace(\"\\\\\", \"/\")\n        if rel.endswith(\".py\"):\n            rel = rel[:-3]\n        parts = [p for p in rel.split(\"/\") if p and p != \"__init__\"]\n        return \".\".join(parts) or os.path.splitext(os.path.basename(abs_file))[0]\n\n    def _safe_count_lines(self, abs_file: str) -> int:\n        try:\n            with open(abs_file, \"r\", encoding=\"utf-8\", errors=\"ignore\") as fh:\n                return sum(1 for _ in fh)\n        except Exception:\n            return 1\n\n    def _precompute_hashes(self, files: List[str]) -> None:\n        for fp in files:\n            try:\n                with open(fp, \"rb\") as fh:\n                    raw = fh.read()\n                h = hashlib.sha256(raw).hexdigest()\n            except Exception:\n                h = \"\"\n            self._file_hash[fp] = h\n\n","source_hash":"27d2c9fbe4b62cf66c684b76a8ffba2ba3dad061314037a111259361fe252990","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.build_researchhierarchy_spans","uri":"program://TOLBERT/module/scripts.build_researchhierarchy_spans#L1-L474","kind":"module","name":"scripts.build_researchhierarchy_spans","path":"scripts/build_researchhierarchy_spans.py","language":"python","start_line":1,"end_line":474,"context_start_line":1,"context_end_line":474,"code":"\"\"\"\nBuild ResearchHierarchy-style JSONL spans and simple ontology metadata for WOS / arXiv papers.\n\nThis is a reference implementation of the dataset construction described for the\nResearchHierarchy benchmark in the TOLBERT paper. It expects you to provide a local\nmetadata file that assigns each paper to a 3-level research taxonomy and (optionally)\nits backing PDF path.\n\nThe script is intentionally lightweight and mirrors the structure of\n`build_codehierarchy_spans.py`:\n\nInput\n=====\n- --metadata_file:\n    A CSV or JSONL file with, at minimum, the columns:\n      doc_id, field, subfield, discipline, text\n\n    Optionally it may also include:\n      pdf_path: absolute or repo-relative path to the PDF for this paper\n      source:  short tag like \"wos\" or \"arxiv\" identifying the corpus\n\n    You can override these column names with CLI flags.\n\nOutputs\n=======\n- --spans_out:\n    JSONL file with one record per paper of the form:\n      {\n        \"span_id\": \"WOS-12345\",\n        \"text\": \"... title + abstract or full text ...\",\n        \"source_id\": \"/papers/pdfs/2019/WOS-12345.pdf\",\n        \"node_path\": [root_id, field_id, subfield_id, discipline_id],\n        \"meta\": {\n          \"field\": \"...\",\n          \"subfield\": \"...\",\n          \"discipline\": \"...\",\n          \"doc_id\": \"...\",\n          \"pdf_path\": \"...\",        # if available\n          \"source\": \"wos\" | \"arxiv\" # if available\n        }\n      }\n\n- --nodes_out (optional):\n    JSONL file describing ontology nodes with fields:\n      node_id, level, type, parent_id, name, attributes\n\n- --level_sizes_out (optional):\n    Small JSON file with:\n      {\"level_sizes\": [num_level0, num_level1, num_level2, num_level3]}\n    which you can copy into your training config as `level_sizes`.\n\nThe intended use is:\n  1) Prepare a single metadata file that combines your WOS and arXiv papers,\n     mapped into a 3-level taxonomy (field → subfield → discipline).\n  2) Point this script at it to obtain spans and ontology metadata compatible\n     with the rest of the TOLBERT pipeline.\n\"\"\"\n\nfrom __future__ import annotations\n\nimport argparse\nimport csv\nimport json\nfrom dataclasses import dataclass\nfrom pathlib import Path\nfrom typing import Dict, List, Optional, Tuple\n\n\n@dataclass\nclass PaperMeta:\n    doc_id: str\n    field: str\n    subfield: str\n    discipline: str\n    text: str\n    pdf_path: Optional[str] = None\n    source: Optional[str] = None\n\n\ndef load_metadata(\n    path: Path,\n    *,\n    id_col: str,\n    field_col: str,\n    subfield_col: str,\n    discipline_col: str,\n    text_col: str,\n    pdf_path_col: Optional[str],\n    source_col: Optional[str],\n) -> List[PaperMeta]:\n    \"\"\"\n    Load WOS / arXiv-style paper metadata from CSV or JSON(L).\n\n    The loader is column-name agnostic: you can override the column names via CLI.\n    \"\"\"\n    metas: List[PaperMeta] = []\n\n    def _row_to_meta(row: Dict[str, object]) -> Optional[PaperMeta]:\n        try:\n            doc_id = str(row[id_col])\n            field = str(row[field_col])\n            subfield = str(row[subfield_col])\n            discipline = str(row[discipline_col])\n            text = str(row[text_col])\n        except KeyError as exc:\n            raise KeyError(f\"Missing required column {exc!s} in metadata record: {row}\") from exc\n\n        if not text.strip():\n            # Skip empty-text entries; they are not useful training instances.\n            return None\n\n        pdf_path_val: Optional[str] = None\n        if pdf_path_col and pdf_path_col in row and row[pdf_path_col] is not None:\n            pdf_path_val = str(row[pdf_path_col])\n\n        source_val: Optional[str] = None\n        if source_col and source_col in row and row[source_col] is not None:\n            source_val = str(row[source_col])\n\n        return PaperMeta(\n            doc_id=doc_id,\n            field=field,\n            subfield=subfield,\n            discipline=discipline,\n            text=text,\n            pdf_path=pdf_path_val,\n            source=source_val,\n        )\n\n    suffix = path.suffix.lower()\n    if suffix in {\".jsonl\", \".json\"}:\n        with path.open(\"r\", encoding=\"utf-8\") as f:\n            for line in f:\n                line = line.strip()\n                if not line:\n                    continue\n                obj = json.loads(line)\n                # Accept either a flat object or nested under \"data\"\n                if isinstance(obj, dict) and \"data\" in obj and isinstance(obj[\"data\"], dict):\n                    obj = obj[\"data\"]\n                if not isinstance(obj, dict):\n                    continue\n                meta = _row_to_meta(obj)\n                if meta is not None:\n                    metas.append(meta)\n        return metas\n\n    # Default: CSV with header.\n    with path.open(\"r\", encoding=\"utf-8\") as f:\n        reader = csv.DictReader(f)\n        for row in reader:\n            meta = _row_to_meta(row)\n            if meta is not None:\n                metas.append(meta)\n    return metas\n\n\ndef build_ontology(\n    metas: List[PaperMeta],\n) -> Tuple[Dict[str, int], Dict[str, int], Dict[str, int]]:\n    \"\"\"\n    Build simple integer ID mappings:\n      - field -> field_node_id\n      - (field, subfield) -> subfield_node_id\n      - (field, subfield, discipline) -> discipline_node_id\n\n    Level conventions:\n      level 0: root (id 0)\n      level 1: field nodes\n      level 2: subfield nodes\n      level 3: discipline nodes\n    \"\"\"\n    next_id = 0\n    root_id = next_id\n    next_id += 1\n\n    field_ids: Dict[str, int] = {}\n    subfield_ids: Dict[str, int] = {}\n    discipline_ids: Dict[str, int] = {}\n\n    for m in metas:\n        if m.field not in field_ids:\n            field_ids[m.field] = next_id\n            next_id += 1\n\n        sub_key = f\"{m.field}::{m.subfield}\"\n        if sub_key not in subfield_ids:\n            subfield_ids[sub_key] = next_id\n            next_id += 1\n\n        disc_key = f\"{m.field}::{m.subfield}::{m.discipline}\"\n        if disc_key not in discipline_ids:\n            discipline_ids[disc_key] = next_id\n            next_id += 1\n\n    # Sanity check: at least one node at each level if any metas were provided.\n    if metas and (not field_ids or not subfield_ids or not discipline_ids):\n        raise RuntimeError(\"Failed to build a non-empty 3-level ontology from metadata.\")\n\n    # root_id is currently unused in the returned dicts but kept for documentation.\n    _ = root_id\n    return field_ids, subfield_ids, discipline_ids\n\n\ndef write_nodes_jsonl(\n    out_path: Path,\n    field_ids: Dict[str, int],\n    subfield_ids: Dict[str, int],\n    discipline_ids: Dict[str, int],\n) -> None:\n    \"\"\"\n    Emit a minimal nodes.jsonl compatible with docs/tree_of_life.md.\n    \"\"\"\n    with out_path.open(\"w\", encoding=\"utf-8\") as f:\n        # Root (level 0)\n        f.write(\n            json.dumps(\n                {\n                    \"node_id\": 0,\n                    \"level\": 0,\n                    \"type\": \"root\",\n                    \"parent_id\": None,\n                    \"name\": \"Root\",\n                    \"attributes\": {},\n                }\n            )\n            + \"\\n\"\n        )\n\n        # Fields (level 1)\n        for field_name, nid in field_ids.items():\n            f.write(\n                json.dumps(\n                    {\n                        \"node_id\": nid,\n                        \"level\": 1,\n                        \"type\": \"field\",\n                        \"parent_id\": 0,\n                        \"name\": field_name,\n                        \"attributes\": {},\n                    }\n                )\n                + \"\\n\"\n            )\n\n        # Subfields (level 2)\n        for key, nid in subfield_ids.items():\n            field_name, subfield_name = key.split(\"::\", 1)\n            parent_id = field_ids[field_name]\n            f.write(\n                json.dumps(\n                    {\n                        \"node_id\": nid,\n                        \"level\": 2,\n                        \"type\": \"subfield\",\n                        \"parent_id\": parent_id,\n                        \"name\": subfield_name,\n                        \"attributes\": {\"field\": field_name},\n                    }\n                )\n                + \"\\n\"\n            )\n\n        # Disciplines (level 3)\n        for key, nid in discipline_ids.items():\n            field_name, subfield_name, discipline_name = key.split(\"::\", 2)\n            sub_key = f\"{field_name}::{subfield_name}\"\n            parent_id = subfield_ids[sub_key]\n            f.write(\n                json.dumps(\n                    {\n                        \"node_id\": nid,\n                        \"level\": 3,\n                        \"type\": \"discipline\",\n                        \"parent_id\": parent_id,\n                        \"name\": discipline_name,\n                        \"attributes\": {\n                            \"field\": field_name,\n                            \"subfield\": subfield_name,\n                        },\n                    }\n                )\n                + \"\\n\"\n            )\n\n\ndef build_span_records(\n    metas: List[PaperMeta],\n    field_ids: Dict[str, int],\n    subfield_ids: Dict[str, int],\n    discipline_ids: Dict[str, int],\n) -> List[Dict[str, object]]:\n    \"\"\"\n    Iterate over papers and generate one span per paper.\n    \"\"\"\n    root_id = 0\n    spans: List[Dict[str, object]] = []\n\n    for m in metas:\n        field_id = field_ids[m.field]\n        sub_key = f\"{m.field}::{m.subfield}\"\n        sub_id = subfield_ids[sub_key]\n        disc_key = f\"{m.field}::{m.subfield}::{m.discipline}\"\n        disc_id = discipline_ids[disc_key]\n\n        node_path = [root_id, field_id, sub_id, disc_id]\n\n        span_id = m.doc_id\n        source_id = m.pdf_path if m.pdf_path is not None else m.doc_id\n\n        meta: Dict[str, object] = {\n            \"doc_id\": m.doc_id,\n            \"field\": m.field,\n            \"subfield\": m.subfield,\n            \"discipline\": m.discipline,\n        }\n        if m.pdf_path is not None:\n            meta[\"pdf_path\"] = m.pdf_path\n        if m.source is not None:\n            meta[\"source\"] = m.source\n\n        spans.append(\n            {\n                \"span_id\": span_id,\n                \"text\": m.text,\n                \"source_id\": source_id,\n                \"node_path\": node_path,\n                \"meta\": meta,\n            }\n        )\n\n    return spans\n\n\ndef write_spans_jsonl(spans: List[Dict[str, object]], out_path: Path) -> None:\n    with out_path.open(\"w\", encoding=\"utf-8\") as f:\n        for rec in spans:\n            f.write(json.dumps(rec) + \"\\n\")\n\n\ndef write_level_sizes(\n    field_ids: Dict[str, int],\n    subfield_ids: Dict[str, int],\n    discipline_ids: Dict[str, int],\n    out_path: Path,\n) -> None:\n    # We always have exactly one root.\n    level_sizes = [\n        1,  # root\n        len(field_ids),\n        len(subfield_ids),\n        len(discipline_ids),\n    ]\n    out = {\"level_sizes\": level_sizes}\n    with out_path.open(\"w\", encoding=\"utf-8\") as f:\n        json.dump(out, f, indent=2)\n\n\ndef parse_args() -> argparse.Namespace:\n    ap = argparse.ArgumentParser(\n        description=(\n            \"Build ResearchHierarchy spans JSONL and ontology metadata from WOS / arXiv metadata.\"\n        )\n    )\n    ap.add_argument(\n        \"--metadata_file\",\n        type=str,\n        required=True,\n        help=\"CSV or JSONL file with at least: doc_id, field, subfield, discipline, text.\",\n    )\n    ap.add_argument(\n        \"--spans_out\",\n        type=str,\n        required=True,\n        help=\"Output path for spans JSONL file.\",\n    )\n    ap.add_argument(\n        \"--nodes_out\",\n        type=str,\n        default=\"\",\n        help=\"Optional output path for nodes JSONL (ontology nodes).\",\n    )\n    ap.add_argument(\n        \"--level_sizes_out\",\n        type=str,\n        default=\"\",\n        help=\"Optional output path for level_sizes JSON file.\",\n    )\n\n    # Column name overrides for flexibility.\n    ap.add_argument(\"--id_col\", type=str, default=\"doc_id\", help=\"Column name for document ID.\")\n    ap.add_argument(\"--field_col\", type=str, default=\"field\", help=\"Column name for level-1 field.\")\n    ap.add_argument(\n        \"--subfield_col\",\n        type=str,\n        default=\"subfield\",\n        help=\"Column name for level-2 subfield.\",\n    )\n    ap.add_argument(\n        \"--discipline_col\",\n        type=str,\n        default=\"discipline\",\n        help=\"Column name for level-3 discipline.\",\n    )\n    ap.add_argument(\n        \"--text_col\",\n        type=str,\n        default=\"text\",\n        help=\"Column name containing the paper text (e.g., title + abstract).\",\n    )\n    ap.add_argument(\n        \"--pdf_path_col\",\n        type=str,\n        default=\"pdf_path\",\n        help=\"Optional column name for the PDF path; if missing, source_id falls back to doc_id.\",\n    )\n    ap.add_argument(\n        \"--source_col\",\n        type=str,\n        default=\"source\",\n        help=\"Optional column name for corpus tag (e.g., 'wos', 'arxiv').\",\n    )\n\n    return ap.parse_args()\n\n\ndef main() -> None:\n    args = parse_args()\n\n    meta_path = Path(args.metadata_file)\n    if not meta_path.is_file():\n        raise FileNotFoundError(f\"metadata_file does not exist or is not a file: {meta_path}\")\n\n    metas = load_metadata(\n        meta_path,\n        id_col=args.id_col,\n        field_col=args.field_col,\n        subfield_col=args.subfield_col,\n        discipline_col=args.discipline_col,\n        text_col=args.text_col,\n        pdf_path_col=args.pdf_path_col or None,\n        source_col=args.source_col or None,\n    )\n    if not metas:\n        raise RuntimeError(f\"No valid paper records were loaded from metadata file: {meta_path}\")\n\n    field_ids, subfield_ids, discipline_ids = build_ontology(metas)\n\n    spans = build_span_records(\n        metas=metas,\n        field_ids=field_ids,\n        subfield_ids=subfield_ids,\n        discipline_ids=discipline_ids,\n    )\n\n    spans_out = Path(args.spans_out)\n    spans_out.parent.mkdir(parents=True, exist_ok=True)\n    write_spans_jsonl(spans, spans_out)\n\n    if args.nodes_out:\n        nodes_out = Path(args.nodes_out)\n        nodes_out.parent.mkdir(parents=True, exist_ok=True)\n        write_nodes_jsonl(nodes_out, field_ids, subfield_ids, discipline_ids)\n\n    if args.level_sizes_out:\n        ls_out = Path(args.level_sizes_out)\n        ls_out.parent.mkdir(parents=True, exist_ok=True)\n        write_level_sizes(field_ids, subfield_ids, discipline_ids, ls_out)\n\n\nif __name__ == \"__main__\":\n    main()\n\n","source_hash":"9ba1f42b48662e1a4b26b9554e0b2f038c6dc115b440b175902ef3386791150a","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.build_researchhierarchy_spans.PaperMeta","uri":"program://TOLBERT/class/scripts.build_researchhierarchy_spans.PaperMeta#L70-L77","kind":"class","name":"PaperMeta","path":"scripts/build_researchhierarchy_spans.py","language":"python","start_line":70,"end_line":77,"context_start_line":50,"context_end_line":97,"code":"    which you can copy into your training config as `level_sizes`.\n\nThe intended use is:\n  1) Prepare a single metadata file that combines your WOS and arXiv papers,\n     mapped into a 3-level taxonomy (field → subfield → discipline).\n  2) Point this script at it to obtain spans and ontology metadata compatible\n     with the rest of the TOLBERT pipeline.\n\"\"\"\n\nfrom __future__ import annotations\n\nimport argparse\nimport csv\nimport json\nfrom dataclasses import dataclass\nfrom pathlib import Path\nfrom typing import Dict, List, Optional, Tuple\n\n\n@dataclass\nclass PaperMeta:\n    doc_id: str\n    field: str\n    subfield: str\n    discipline: str\n    text: str\n    pdf_path: Optional[str] = None\n    source: Optional[str] = None\n\n\ndef load_metadata(\n    path: Path,\n    *,\n    id_col: str,\n    field_col: str,\n    subfield_col: str,\n    discipline_col: str,\n    text_col: str,\n    pdf_path_col: Optional[str],\n    source_col: Optional[str],\n) -> List[PaperMeta]:\n    \"\"\"\n    Load WOS / arXiv-style paper metadata from CSV or JSON(L).\n\n    The loader is column-name agnostic: you can override the column names via CLI.\n    \"\"\"\n    metas: List[PaperMeta] = []\n","source_hash":"9ba1f42b48662e1a4b26b9554e0b2f038c6dc115b440b175902ef3386791150a","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.build_researchhierarchy_spans.load_metadata","uri":"program://TOLBERT/function/scripts.build_researchhierarchy_spans.load_metadata#L80-L155","kind":"function","name":"load_metadata","path":"scripts/build_researchhierarchy_spans.py","language":"python","start_line":80,"end_line":155,"context_start_line":60,"context_end_line":175,"code":"\nimport argparse\nimport csv\nimport json\nfrom dataclasses import dataclass\nfrom pathlib import Path\nfrom typing import Dict, List, Optional, Tuple\n\n\n@dataclass\nclass PaperMeta:\n    doc_id: str\n    field: str\n    subfield: str\n    discipline: str\n    text: str\n    pdf_path: Optional[str] = None\n    source: Optional[str] = None\n\n\ndef load_metadata(\n    path: Path,\n    *,\n    id_col: str,\n    field_col: str,\n    subfield_col: str,\n    discipline_col: str,\n    text_col: str,\n    pdf_path_col: Optional[str],\n    source_col: Optional[str],\n) -> List[PaperMeta]:\n    \"\"\"\n    Load WOS / arXiv-style paper metadata from CSV or JSON(L).\n\n    The loader is column-name agnostic: you can override the column names via CLI.\n    \"\"\"\n    metas: List[PaperMeta] = []\n\n    def _row_to_meta(row: Dict[str, object]) -> Optional[PaperMeta]:\n        try:\n            doc_id = str(row[id_col])\n            field = str(row[field_col])\n            subfield = str(row[subfield_col])\n            discipline = str(row[discipline_col])\n            text = str(row[text_col])\n        except KeyError as exc:\n            raise KeyError(f\"Missing required column {exc!s} in metadata record: {row}\") from exc\n\n        if not text.strip():\n            # Skip empty-text entries; they are not useful training instances.\n            return None\n\n        pdf_path_val: Optional[str] = None\n        if pdf_path_col and pdf_path_col in row and row[pdf_path_col] is not None:\n            pdf_path_val = str(row[pdf_path_col])\n\n        source_val: Optional[str] = None\n        if source_col and source_col in row and row[source_col] is not None:\n            source_val = str(row[source_col])\n\n        return PaperMeta(\n            doc_id=doc_id,\n            field=field,\n            subfield=subfield,\n            discipline=discipline,\n            text=text,\n            pdf_path=pdf_path_val,\n            source=source_val,\n        )\n\n    suffix = path.suffix.lower()\n    if suffix in {\".jsonl\", \".json\"}:\n        with path.open(\"r\", encoding=\"utf-8\") as f:\n            for line in f:\n                line = line.strip()\n                if not line:\n                    continue\n                obj = json.loads(line)\n                # Accept either a flat object or nested under \"data\"\n                if isinstance(obj, dict) and \"data\" in obj and isinstance(obj[\"data\"], dict):\n                    obj = obj[\"data\"]\n                if not isinstance(obj, dict):\n                    continue\n                meta = _row_to_meta(obj)\n                if meta is not None:\n                    metas.append(meta)\n        return metas\n\n    # Default: CSV with header.\n    with path.open(\"r\", encoding=\"utf-8\") as f:\n        reader = csv.DictReader(f)\n        for row in reader:\n            meta = _row_to_meta(row)\n            if meta is not None:\n                metas.append(meta)\n    return metas\n\n\ndef build_ontology(\n    metas: List[PaperMeta],\n) -> Tuple[Dict[str, int], Dict[str, int], Dict[str, int]]:\n    \"\"\"\n    Build simple integer ID mappings:\n      - field -> field_node_id\n      - (field, subfield) -> subfield_node_id\n      - (field, subfield, discipline) -> discipline_node_id\n\n    Level conventions:\n      level 0: root (id 0)\n      level 1: field nodes\n      level 2: subfield nodes\n      level 3: discipline nodes\n    \"\"\"\n    next_id = 0\n    root_id = next_id\n    next_id += 1","source_hash":"9ba1f42b48662e1a4b26b9554e0b2f038c6dc115b440b175902ef3386791150a","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.build_researchhierarchy_spans.build_ontology","uri":"program://TOLBERT/function/scripts.build_researchhierarchy_spans.build_ontology#L158-L202","kind":"function","name":"build_ontology","path":"scripts/build_researchhierarchy_spans.py","language":"python","start_line":158,"end_line":202,"context_start_line":138,"context_end_line":222,"code":"                # Accept either a flat object or nested under \"data\"\n                if isinstance(obj, dict) and \"data\" in obj and isinstance(obj[\"data\"], dict):\n                    obj = obj[\"data\"]\n                if not isinstance(obj, dict):\n                    continue\n                meta = _row_to_meta(obj)\n                if meta is not None:\n                    metas.append(meta)\n        return metas\n\n    # Default: CSV with header.\n    with path.open(\"r\", encoding=\"utf-8\") as f:\n        reader = csv.DictReader(f)\n        for row in reader:\n            meta = _row_to_meta(row)\n            if meta is not None:\n                metas.append(meta)\n    return metas\n\n\ndef build_ontology(\n    metas: List[PaperMeta],\n) -> Tuple[Dict[str, int], Dict[str, int], Dict[str, int]]:\n    \"\"\"\n    Build simple integer ID mappings:\n      - field -> field_node_id\n      - (field, subfield) -> subfield_node_id\n      - (field, subfield, discipline) -> discipline_node_id\n\n    Level conventions:\n      level 0: root (id 0)\n      level 1: field nodes\n      level 2: subfield nodes\n      level 3: discipline nodes\n    \"\"\"\n    next_id = 0\n    root_id = next_id\n    next_id += 1\n\n    field_ids: Dict[str, int] = {}\n    subfield_ids: Dict[str, int] = {}\n    discipline_ids: Dict[str, int] = {}\n\n    for m in metas:\n        if m.field not in field_ids:\n            field_ids[m.field] = next_id\n            next_id += 1\n\n        sub_key = f\"{m.field}::{m.subfield}\"\n        if sub_key not in subfield_ids:\n            subfield_ids[sub_key] = next_id\n            next_id += 1\n\n        disc_key = f\"{m.field}::{m.subfield}::{m.discipline}\"\n        if disc_key not in discipline_ids:\n            discipline_ids[disc_key] = next_id\n            next_id += 1\n\n    # Sanity check: at least one node at each level if any metas were provided.\n    if metas and (not field_ids or not subfield_ids or not discipline_ids):\n        raise RuntimeError(\"Failed to build a non-empty 3-level ontology from metadata.\")\n\n    # root_id is currently unused in the returned dicts but kept for documentation.\n    _ = root_id\n    return field_ids, subfield_ids, discipline_ids\n\n\ndef write_nodes_jsonl(\n    out_path: Path,\n    field_ids: Dict[str, int],\n    subfield_ids: Dict[str, int],\n    discipline_ids: Dict[str, int],\n) -> None:\n    \"\"\"\n    Emit a minimal nodes.jsonl compatible with docs/tree_of_life.md.\n    \"\"\"\n    with out_path.open(\"w\", encoding=\"utf-8\") as f:\n        # Root (level 0)\n        f.write(\n            json.dumps(\n                {\n                    \"node_id\": 0,\n                    \"level\": 0,\n                    \"type\": \"root\",\n                    \"parent_id\": None,","source_hash":"9ba1f42b48662e1a4b26b9554e0b2f038c6dc115b440b175902ef3386791150a","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.build_researchhierarchy_spans.write_nodes_jsonl","uri":"program://TOLBERT/function/scripts.build_researchhierarchy_spans.write_nodes_jsonl#L205-L284","kind":"function","name":"write_nodes_jsonl","path":"scripts/build_researchhierarchy_spans.py","language":"python","start_line":205,"end_line":284,"context_start_line":185,"context_end_line":304,"code":"\n        sub_key = f\"{m.field}::{m.subfield}\"\n        if sub_key not in subfield_ids:\n            subfield_ids[sub_key] = next_id\n            next_id += 1\n\n        disc_key = f\"{m.field}::{m.subfield}::{m.discipline}\"\n        if disc_key not in discipline_ids:\n            discipline_ids[disc_key] = next_id\n            next_id += 1\n\n    # Sanity check: at least one node at each level if any metas were provided.\n    if metas and (not field_ids or not subfield_ids or not discipline_ids):\n        raise RuntimeError(\"Failed to build a non-empty 3-level ontology from metadata.\")\n\n    # root_id is currently unused in the returned dicts but kept for documentation.\n    _ = root_id\n    return field_ids, subfield_ids, discipline_ids\n\n\ndef write_nodes_jsonl(\n    out_path: Path,\n    field_ids: Dict[str, int],\n    subfield_ids: Dict[str, int],\n    discipline_ids: Dict[str, int],\n) -> None:\n    \"\"\"\n    Emit a minimal nodes.jsonl compatible with docs/tree_of_life.md.\n    \"\"\"\n    with out_path.open(\"w\", encoding=\"utf-8\") as f:\n        # Root (level 0)\n        f.write(\n            json.dumps(\n                {\n                    \"node_id\": 0,\n                    \"level\": 0,\n                    \"type\": \"root\",\n                    \"parent_id\": None,\n                    \"name\": \"Root\",\n                    \"attributes\": {},\n                }\n            )\n            + \"\\n\"\n        )\n\n        # Fields (level 1)\n        for field_name, nid in field_ids.items():\n            f.write(\n                json.dumps(\n                    {\n                        \"node_id\": nid,\n                        \"level\": 1,\n                        \"type\": \"field\",\n                        \"parent_id\": 0,\n                        \"name\": field_name,\n                        \"attributes\": {},\n                    }\n                )\n                + \"\\n\"\n            )\n\n        # Subfields (level 2)\n        for key, nid in subfield_ids.items():\n            field_name, subfield_name = key.split(\"::\", 1)\n            parent_id = field_ids[field_name]\n            f.write(\n                json.dumps(\n                    {\n                        \"node_id\": nid,\n                        \"level\": 2,\n                        \"type\": \"subfield\",\n                        \"parent_id\": parent_id,\n                        \"name\": subfield_name,\n                        \"attributes\": {\"field\": field_name},\n                    }\n                )\n                + \"\\n\"\n            )\n\n        # Disciplines (level 3)\n        for key, nid in discipline_ids.items():\n            field_name, subfield_name, discipline_name = key.split(\"::\", 2)\n            sub_key = f\"{field_name}::{subfield_name}\"\n            parent_id = subfield_ids[sub_key]\n            f.write(\n                json.dumps(\n                    {\n                        \"node_id\": nid,\n                        \"level\": 3,\n                        \"type\": \"discipline\",\n                        \"parent_id\": parent_id,\n                        \"name\": discipline_name,\n                        \"attributes\": {\n                            \"field\": field_name,\n                            \"subfield\": subfield_name,\n                        },\n                    }\n                )\n                + \"\\n\"\n            )\n\n\ndef build_span_records(\n    metas: List[PaperMeta],\n    field_ids: Dict[str, int],\n    subfield_ids: Dict[str, int],\n    discipline_ids: Dict[str, int],\n) -> List[Dict[str, object]]:\n    \"\"\"\n    Iterate over papers and generate one span per paper.\n    \"\"\"\n    root_id = 0\n    spans: List[Dict[str, object]] = []\n\n    for m in metas:\n        field_id = field_ids[m.field]\n        sub_key = f\"{m.field}::{m.subfield}\"\n        sub_id = subfield_ids[sub_key]\n        disc_key = f\"{m.field}::{m.subfield}::{m.discipline}\"\n        disc_id = discipline_ids[disc_key]","source_hash":"9ba1f42b48662e1a4b26b9554e0b2f038c6dc115b440b175902ef3386791150a","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.build_researchhierarchy_spans.build_span_records","uri":"program://TOLBERT/function/scripts.build_researchhierarchy_spans.build_span_records#L287-L332","kind":"function","name":"build_span_records","path":"scripts/build_researchhierarchy_spans.py","language":"python","start_line":287,"end_line":332,"context_start_line":267,"context_end_line":352,"code":"            sub_key = f\"{field_name}::{subfield_name}\"\n            parent_id = subfield_ids[sub_key]\n            f.write(\n                json.dumps(\n                    {\n                        \"node_id\": nid,\n                        \"level\": 3,\n                        \"type\": \"discipline\",\n                        \"parent_id\": parent_id,\n                        \"name\": discipline_name,\n                        \"attributes\": {\n                            \"field\": field_name,\n                            \"subfield\": subfield_name,\n                        },\n                    }\n                )\n                + \"\\n\"\n            )\n\n\ndef build_span_records(\n    metas: List[PaperMeta],\n    field_ids: Dict[str, int],\n    subfield_ids: Dict[str, int],\n    discipline_ids: Dict[str, int],\n) -> List[Dict[str, object]]:\n    \"\"\"\n    Iterate over papers and generate one span per paper.\n    \"\"\"\n    root_id = 0\n    spans: List[Dict[str, object]] = []\n\n    for m in metas:\n        field_id = field_ids[m.field]\n        sub_key = f\"{m.field}::{m.subfield}\"\n        sub_id = subfield_ids[sub_key]\n        disc_key = f\"{m.field}::{m.subfield}::{m.discipline}\"\n        disc_id = discipline_ids[disc_key]\n\n        node_path = [root_id, field_id, sub_id, disc_id]\n\n        span_id = m.doc_id\n        source_id = m.pdf_path if m.pdf_path is not None else m.doc_id\n\n        meta: Dict[str, object] = {\n            \"doc_id\": m.doc_id,\n            \"field\": m.field,\n            \"subfield\": m.subfield,\n            \"discipline\": m.discipline,\n        }\n        if m.pdf_path is not None:\n            meta[\"pdf_path\"] = m.pdf_path\n        if m.source is not None:\n            meta[\"source\"] = m.source\n\n        spans.append(\n            {\n                \"span_id\": span_id,\n                \"text\": m.text,\n                \"source_id\": source_id,\n                \"node_path\": node_path,\n                \"meta\": meta,\n            }\n        )\n\n    return spans\n\n\ndef write_spans_jsonl(spans: List[Dict[str, object]], out_path: Path) -> None:\n    with out_path.open(\"w\", encoding=\"utf-8\") as f:\n        for rec in spans:\n            f.write(json.dumps(rec) + \"\\n\")\n\n\ndef write_level_sizes(\n    field_ids: Dict[str, int],\n    subfield_ids: Dict[str, int],\n    discipline_ids: Dict[str, int],\n    out_path: Path,\n) -> None:\n    # We always have exactly one root.\n    level_sizes = [\n        1,  # root\n        len(field_ids),\n        len(subfield_ids),\n        len(discipline_ids),","source_hash":"9ba1f42b48662e1a4b26b9554e0b2f038c6dc115b440b175902ef3386791150a","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.build_researchhierarchy_spans.write_spans_jsonl","uri":"program://TOLBERT/function/scripts.build_researchhierarchy_spans.write_spans_jsonl#L335-L338","kind":"function","name":"write_spans_jsonl","path":"scripts/build_researchhierarchy_spans.py","language":"python","start_line":335,"end_line":338,"context_start_line":315,"context_end_line":358,"code":"            \"discipline\": m.discipline,\n        }\n        if m.pdf_path is not None:\n            meta[\"pdf_path\"] = m.pdf_path\n        if m.source is not None:\n            meta[\"source\"] = m.source\n\n        spans.append(\n            {\n                \"span_id\": span_id,\n                \"text\": m.text,\n                \"source_id\": source_id,\n                \"node_path\": node_path,\n                \"meta\": meta,\n            }\n        )\n\n    return spans\n\n\ndef write_spans_jsonl(spans: List[Dict[str, object]], out_path: Path) -> None:\n    with out_path.open(\"w\", encoding=\"utf-8\") as f:\n        for rec in spans:\n            f.write(json.dumps(rec) + \"\\n\")\n\n\ndef write_level_sizes(\n    field_ids: Dict[str, int],\n    subfield_ids: Dict[str, int],\n    discipline_ids: Dict[str, int],\n    out_path: Path,\n) -> None:\n    # We always have exactly one root.\n    level_sizes = [\n        1,  # root\n        len(field_ids),\n        len(subfield_ids),\n        len(discipline_ids),\n    ]\n    out = {\"level_sizes\": level_sizes}\n    with out_path.open(\"w\", encoding=\"utf-8\") as f:\n        json.dump(out, f, indent=2)\n\n","source_hash":"9ba1f42b48662e1a4b26b9554e0b2f038c6dc115b440b175902ef3386791150a","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.build_researchhierarchy_spans.write_level_sizes","uri":"program://TOLBERT/function/scripts.build_researchhierarchy_spans.write_level_sizes#L341-L356","kind":"function","name":"write_level_sizes","path":"scripts/build_researchhierarchy_spans.py","language":"python","start_line":341,"end_line":356,"context_start_line":321,"context_end_line":376,"code":"\n        spans.append(\n            {\n                \"span_id\": span_id,\n                \"text\": m.text,\n                \"source_id\": source_id,\n                \"node_path\": node_path,\n                \"meta\": meta,\n            }\n        )\n\n    return spans\n\n\ndef write_spans_jsonl(spans: List[Dict[str, object]], out_path: Path) -> None:\n    with out_path.open(\"w\", encoding=\"utf-8\") as f:\n        for rec in spans:\n            f.write(json.dumps(rec) + \"\\n\")\n\n\ndef write_level_sizes(\n    field_ids: Dict[str, int],\n    subfield_ids: Dict[str, int],\n    discipline_ids: Dict[str, int],\n    out_path: Path,\n) -> None:\n    # We always have exactly one root.\n    level_sizes = [\n        1,  # root\n        len(field_ids),\n        len(subfield_ids),\n        len(discipline_ids),\n    ]\n    out = {\"level_sizes\": level_sizes}\n    with out_path.open(\"w\", encoding=\"utf-8\") as f:\n        json.dump(out, f, indent=2)\n\n\ndef parse_args() -> argparse.Namespace:\n    ap = argparse.ArgumentParser(\n        description=(\n            \"Build ResearchHierarchy spans JSONL and ontology metadata from WOS / arXiv metadata.\"\n        )\n    )\n    ap.add_argument(\n        \"--metadata_file\",\n        type=str,\n        required=True,\n        help=\"CSV or JSONL file with at least: doc_id, field, subfield, discipline, text.\",\n    )\n    ap.add_argument(\n        \"--spans_out\",\n        type=str,\n        required=True,\n        help=\"Output path for spans JSONL file.\",\n    )","source_hash":"9ba1f42b48662e1a4b26b9554e0b2f038c6dc115b440b175902ef3386791150a","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.build_researchhierarchy_spans.parse_args","uri":"program://TOLBERT/function/scripts.build_researchhierarchy_spans.parse_args#L359-L424","kind":"function","name":"parse_args","path":"scripts/build_researchhierarchy_spans.py","language":"python","start_line":359,"end_line":424,"context_start_line":339,"context_end_line":444,"code":"\n\ndef write_level_sizes(\n    field_ids: Dict[str, int],\n    subfield_ids: Dict[str, int],\n    discipline_ids: Dict[str, int],\n    out_path: Path,\n) -> None:\n    # We always have exactly one root.\n    level_sizes = [\n        1,  # root\n        len(field_ids),\n        len(subfield_ids),\n        len(discipline_ids),\n    ]\n    out = {\"level_sizes\": level_sizes}\n    with out_path.open(\"w\", encoding=\"utf-8\") as f:\n        json.dump(out, f, indent=2)\n\n\ndef parse_args() -> argparse.Namespace:\n    ap = argparse.ArgumentParser(\n        description=(\n            \"Build ResearchHierarchy spans JSONL and ontology metadata from WOS / arXiv metadata.\"\n        )\n    )\n    ap.add_argument(\n        \"--metadata_file\",\n        type=str,\n        required=True,\n        help=\"CSV or JSONL file with at least: doc_id, field, subfield, discipline, text.\",\n    )\n    ap.add_argument(\n        \"--spans_out\",\n        type=str,\n        required=True,\n        help=\"Output path for spans JSONL file.\",\n    )\n    ap.add_argument(\n        \"--nodes_out\",\n        type=str,\n        default=\"\",\n        help=\"Optional output path for nodes JSONL (ontology nodes).\",\n    )\n    ap.add_argument(\n        \"--level_sizes_out\",\n        type=str,\n        default=\"\",\n        help=\"Optional output path for level_sizes JSON file.\",\n    )\n\n    # Column name overrides for flexibility.\n    ap.add_argument(\"--id_col\", type=str, default=\"doc_id\", help=\"Column name for document ID.\")\n    ap.add_argument(\"--field_col\", type=str, default=\"field\", help=\"Column name for level-1 field.\")\n    ap.add_argument(\n        \"--subfield_col\",\n        type=str,\n        default=\"subfield\",\n        help=\"Column name for level-2 subfield.\",\n    )\n    ap.add_argument(\n        \"--discipline_col\",\n        type=str,\n        default=\"discipline\",\n        help=\"Column name for level-3 discipline.\",\n    )\n    ap.add_argument(\n        \"--text_col\",\n        type=str,\n        default=\"text\",\n        help=\"Column name containing the paper text (e.g., title + abstract).\",\n    )\n    ap.add_argument(\n        \"--pdf_path_col\",\n        type=str,\n        default=\"pdf_path\",\n        help=\"Optional column name for the PDF path; if missing, source_id falls back to doc_id.\",\n    )\n    ap.add_argument(\n        \"--source_col\",\n        type=str,\n        default=\"source\",\n        help=\"Optional column name for corpus tag (e.g., 'wos', 'arxiv').\",\n    )\n\n    return ap.parse_args()\n\n\ndef main() -> None:\n    args = parse_args()\n\n    meta_path = Path(args.metadata_file)\n    if not meta_path.is_file():\n        raise FileNotFoundError(f\"metadata_file does not exist or is not a file: {meta_path}\")\n\n    metas = load_metadata(\n        meta_path,\n        id_col=args.id_col,\n        field_col=args.field_col,\n        subfield_col=args.subfield_col,\n        discipline_col=args.discipline_col,\n        text_col=args.text_col,\n        pdf_path_col=args.pdf_path_col or None,\n        source_col=args.source_col or None,\n    )\n    if not metas:","source_hash":"9ba1f42b48662e1a4b26b9554e0b2f038c6dc115b440b175902ef3386791150a","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.build_researchhierarchy_spans.main","uri":"program://TOLBERT/function/scripts.build_researchhierarchy_spans.main#L427-L468","kind":"function","name":"main","path":"scripts/build_researchhierarchy_spans.py","language":"python","start_line":427,"end_line":468,"context_start_line":407,"context_end_line":474,"code":"        type=str,\n        default=\"text\",\n        help=\"Column name containing the paper text (e.g., title + abstract).\",\n    )\n    ap.add_argument(\n        \"--pdf_path_col\",\n        type=str,\n        default=\"pdf_path\",\n        help=\"Optional column name for the PDF path; if missing, source_id falls back to doc_id.\",\n    )\n    ap.add_argument(\n        \"--source_col\",\n        type=str,\n        default=\"source\",\n        help=\"Optional column name for corpus tag (e.g., 'wos', 'arxiv').\",\n    )\n\n    return ap.parse_args()\n\n\ndef main() -> None:\n    args = parse_args()\n\n    meta_path = Path(args.metadata_file)\n    if not meta_path.is_file():\n        raise FileNotFoundError(f\"metadata_file does not exist or is not a file: {meta_path}\")\n\n    metas = load_metadata(\n        meta_path,\n        id_col=args.id_col,\n        field_col=args.field_col,\n        subfield_col=args.subfield_col,\n        discipline_col=args.discipline_col,\n        text_col=args.text_col,\n        pdf_path_col=args.pdf_path_col or None,\n        source_col=args.source_col or None,\n    )\n    if not metas:\n        raise RuntimeError(f\"No valid paper records were loaded from metadata file: {meta_path}\")\n\n    field_ids, subfield_ids, discipline_ids = build_ontology(metas)\n\n    spans = build_span_records(\n        metas=metas,\n        field_ids=field_ids,\n        subfield_ids=subfield_ids,\n        discipline_ids=discipline_ids,\n    )\n\n    spans_out = Path(args.spans_out)\n    spans_out.parent.mkdir(parents=True, exist_ok=True)\n    write_spans_jsonl(spans, spans_out)\n\n    if args.nodes_out:\n        nodes_out = Path(args.nodes_out)\n        nodes_out.parent.mkdir(parents=True, exist_ok=True)\n        write_nodes_jsonl(nodes_out, field_ids, subfield_ids, discipline_ids)\n\n    if args.level_sizes_out:\n        ls_out = Path(args.level_sizes_out)\n        ls_out.parent.mkdir(parents=True, exist_ok=True)\n        write_level_sizes(field_ids, subfield_ids, discipline_ids, ls_out)\n\n\nif __name__ == \"__main__\":\n    main()\n\n","source_hash":"9ba1f42b48662e1a4b26b9554e0b2f038c6dc115b440b175902ef3386791150a","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.build_researchhierarchy_spans._row_to_meta","uri":"program://TOLBERT/function/scripts.build_researchhierarchy_spans._row_to_meta#L98-L128","kind":"function","name":"_row_to_meta","path":"scripts/build_researchhierarchy_spans.py","language":"python","start_line":98,"end_line":128,"context_start_line":78,"context_end_line":148,"code":"\n\ndef load_metadata(\n    path: Path,\n    *,\n    id_col: str,\n    field_col: str,\n    subfield_col: str,\n    discipline_col: str,\n    text_col: str,\n    pdf_path_col: Optional[str],\n    source_col: Optional[str],\n) -> List[PaperMeta]:\n    \"\"\"\n    Load WOS / arXiv-style paper metadata from CSV or JSON(L).\n\n    The loader is column-name agnostic: you can override the column names via CLI.\n    \"\"\"\n    metas: List[PaperMeta] = []\n\n    def _row_to_meta(row: Dict[str, object]) -> Optional[PaperMeta]:\n        try:\n            doc_id = str(row[id_col])\n            field = str(row[field_col])\n            subfield = str(row[subfield_col])\n            discipline = str(row[discipline_col])\n            text = str(row[text_col])\n        except KeyError as exc:\n            raise KeyError(f\"Missing required column {exc!s} in metadata record: {row}\") from exc\n\n        if not text.strip():\n            # Skip empty-text entries; they are not useful training instances.\n            return None\n\n        pdf_path_val: Optional[str] = None\n        if pdf_path_col and pdf_path_col in row and row[pdf_path_col] is not None:\n            pdf_path_val = str(row[pdf_path_col])\n\n        source_val: Optional[str] = None\n        if source_col and source_col in row and row[source_col] is not None:\n            source_val = str(row[source_col])\n\n        return PaperMeta(\n            doc_id=doc_id,\n            field=field,\n            subfield=subfield,\n            discipline=discipline,\n            text=text,\n            pdf_path=pdf_path_val,\n            source=source_val,\n        )\n\n    suffix = path.suffix.lower()\n    if suffix in {\".jsonl\", \".json\"}:\n        with path.open(\"r\", encoding=\"utf-8\") as f:\n            for line in f:\n                line = line.strip()\n                if not line:\n                    continue\n                obj = json.loads(line)\n                # Accept either a flat object or nested under \"data\"\n                if isinstance(obj, dict) and \"data\" in obj and isinstance(obj[\"data\"], dict):\n                    obj = obj[\"data\"]\n                if not isinstance(obj, dict):\n                    continue\n                meta = _row_to_meta(obj)\n                if meta is not None:\n                    metas.append(meta)\n        return metas\n\n    # Default: CSV with header.","source_hash":"9ba1f42b48662e1a4b26b9554e0b2f038c6dc115b440b175902ef3386791150a","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.agent_pr_paper_recommender","uri":"program://TOLBERT/module/scripts.agent_pr_paper_recommender#L1-L299","kind":"module","name":"scripts.agent_pr_paper_recommender","path":"scripts/agent_pr_paper_recommender.py","language":"python","start_line":1,"end_line":299,"context_start_line":1,"context_end_line":299,"code":"\"\"\"\nAgent / LLM stack skeleton: PR -> paper recommendations via TOLBERT.\n\nThis script is a high-level wiring of the \"worked scenario\" from `docs/usage.md`:\n  1. Ingest a pull request (PR) as text spans.\n  2. Encode spans with TOLBERT.\n  3. Locate the PR within the Tree-of-Life (domain/subdomain).\n  4. Retrieve relevant paper spans from a pre-built index.\n  5. Use an LLM to summarize / explain the recommendations.\n\nYou are expected to plug in:\n  - real PR ingestion,\n  - a proper paper-span index (vector DB, search service, etc.),\n  - and your own LLM backend in `call_llm`.\n\"\"\"\n\nimport argparse\nfrom pathlib import Path\nfrom typing import Any, Dict, List, Tuple\n\nimport torch\nfrom torch.nn import functional as F\nfrom transformers import AutoTokenizer\nimport os\n\nfrom tolbert.config import load_tolbert_config\nfrom tolbert.modeling import TOLBERT, TOLBERTConfig\n\n\ndef call_llm(prompt: str) -> str:\n    \"\"\"\n    Placeholder for your LLM call.\n\n    Replace this with your own LLM client (OpenAI, local model, etc.).\n    \"\"\"\n    raise NotImplementedError(\"Integrate your LLM client here.\")\n\n\ndef build_model(cfg: Dict[str, Any], checkpoint: str, device: torch.device) -> TOLBERT:\n    model_cfg = TOLBERTConfig(\n        base_model_name=cfg[\"base_model_name\"],\n        level_sizes=cfg[\"level_sizes\"],\n        proj_dim=cfg.get(\"proj_dim\", 256),\n    )\n    model = TOLBERT(model_cfg)\n    state = torch.load(checkpoint, map_location=\"cpu\")\n    model.load_state_dict(state)\n    model.to(device)\n    model.eval()\n    return model\n\n\ndef simple_pr_spans(pr_text: str) -> List[str]:\n    \"\"\"\n    Very simple PR spanizer:\n      - splits on double newlines,\n      - keeps reasonably sized chunks as candidate spans.\n\n    You likely want to replace this with something that understands diffs\n    and function boundaries.\n    \"\"\"\n    parts = [p.strip() for p in pr_text.split(\"\\n\\n\") if p.strip()]\n    return parts\n\n\ndef encode_spans(\n    model: TOLBERT,\n    tokenizer,\n    spans: List[str],\n    max_length: int,\n    device: torch.device,\n) -> Tuple[torch.Tensor, List[Dict[str, Any]]]:\n    embs: List[torch.Tensor] = []\n    metas: List[Dict[str, Any]] = []\n    for i, text in enumerate(spans):\n        tokens = tokenizer(\n            text,\n            return_tensors=\"pt\",\n            truncation=True,\n            padding=\"max_length\",\n            max_length=max_length,\n        )\n        with torch.no_grad():\n            out = model(\n                input_ids=tokens[\"input_ids\"].to(device),\n                attention_mask=tokens[\"attention_mask\"].to(device),\n            )\n        embs.append(out[\"proj\"].squeeze(0).cpu())\n\n        # Record predicted hierarchy information for analysis.\n        level_logits = out[\"level_logits\"]\n        level_preds = {\n            int(level): logits.argmax(dim=-1).item()\n            for level, logits in level_logits.items()\n        }\n\n        metas.append(\n            {\n                \"span_index\": i,\n                \"text\": text,\n                \"level_predictions\": level_preds,\n            }\n        )\n\n    if not embs:\n        return torch.empty(0), metas\n    return torch.stack(embs, dim=0), metas\n\n\ndef load_paper_index(index_path: str) -> Tuple[torch.Tensor, List[Dict[str, Any]]]:\n    \"\"\"\n    Load a pre-built paper-span index.\n\n    This function is intentionally schematic. You might, for example, store:\n      - embeddings as a `.pt` tensor,\n      - metadata as a JSON/JSONL file with the same length.\n    \"\"\"\n    index_dir = Path(index_path)\n    emb_path = index_dir / \"embeddings.pt\"\n    meta_path = index_dir / \"metadata.jsonl\"\n\n    if not emb_path.exists() or not meta_path.exists():\n        raise FileNotFoundError(\n            f\"Expected embeddings at {emb_path} and metadata at {meta_path}.\"\n        )\n\n    embs = torch.load(emb_path, map_location=\"cpu\")\n    metas: List[Dict[str, Any]] = []\n    with meta_path.open(\"r\", encoding=\"utf-8\") as f:\n        import json\n\n        for line in f:\n            line = line.strip()\n            if not line:\n                continue\n            metas.append(json.loads(line))\n\n    if embs.size(0) != len(metas):\n        raise ValueError(\"Mismatch between number of embeddings and metadata entries.\")\n\n    return embs, metas\n\n\ndef retrieve_top_papers(\n    pr_embs: torch.Tensor,\n    paper_embs: torch.Tensor,\n    paper_metas: List[Dict[str, Any]],\n    top_k_per_span: int = 5,\n    top_k_papers: int = 10,\n) -> List[Dict[str, Any]]:\n    \"\"\"\n    Simple multi-span retrieval:\n      - for each PR span embedding, retrieve top_k_per_span paper spans,\n      - aggregate scores per paper id,\n      - return top_k_papers papers with aggregated scores.\n    \"\"\"\n    if pr_embs.numel() == 0 or paper_embs.numel() == 0:\n        return []\n\n    scores: Dict[str, float] = {}\n    for i in range(pr_embs.size(0)):\n        q = pr_embs[i : i + 1]\n        sims = F.cosine_similarity(q, paper_embs, dim=1)\n        topk = torch.topk(sims, k=min(top_k_per_span, sims.numel()))\n        for idx, score in zip(topk.indices.tolist(), topk.values.tolist()):\n            meta = paper_metas[idx]\n            paper_id = str(meta.get(\"paper_id\", idx))\n            scores[paper_id] = scores.get(paper_id, 0.0) + float(score)\n\n    ranked = sorted(scores.items(), key=lambda kv: kv[1], reverse=True)[:top_k_papers]\n    results: List[Dict[str, Any]] = []\n    for paper_id, score in ranked:\n        # find first meta entry with this paper_id\n        meta = next((m for m in paper_metas if str(m.get(\"paper_id\")) == paper_id), None)\n        if meta is None:\n            continue\n        results.append(\n            {\n                \"paper_id\": paper_id,\n                \"score\": score,\n                \"title\": meta.get(\"title\"),\n                \"abstract\": meta.get(\"abstract\"),\n            }\n        )\n    return results\n\n\ndef build_prompt(pr_text: str, recommendations: List[Dict[str, Any]]) -> str:\n    \"\"\"\n    Construct a prompt for the LLM given:\n      - the PR text,\n      - a set of candidate papers with scores and metadata.\n    \"\"\"\n    lines = [\n        \"You are an expert AI code reviewer and research assistant.\",\n        \"Given the following pull request and a set of candidate research papers,\",\n        \"explain which papers are most relevant and why.\",\n        \"\",\n        \"PULL REQUEST:\",\n        pr_text,\n        \"\",\n        \"CANDIDATE PAPERS:\",\n    ]\n    for i, rec in enumerate(recommendations, start=1):\n        lines.append(\n            f\"{i}. [paper_id={rec['paper_id']}] title={rec.get('title')!r} \"\n            f\"(score={rec['score']:.3f})\"\n        )\n        if rec.get(\"abstract\"):\n            lines.append(f\"   abstract={rec['abstract']!r}\")\n    lines.append(\"\")\n    lines.append(\n        \"For each paper above, give a short explanation (2-4 sentences) \"\n        \"of how it relates to the PR, and suggest how the PR could benefit \"\n        \"from ideas in these papers.\"\n    )\n    return \"\\n\".join(lines)\n\n\ndef parse_args() -> argparse.Namespace:\n    ap = argparse.ArgumentParser(description=\"PR -> paper recommendation agent (skeleton).\")\n    ap.add_argument(\"--config\", type=str, required=True, help=\"Path to TOLBERT config.\")\n    ap.add_argument(\"--checkpoint\", type=str, required=True, help=\"Path to model checkpoint (.pt).\")\n    ap.add_argument(\n        \"--paper_index\",\n        type=str,\n        required=True,\n        help=\"Path to directory with paper-span embeddings and metadata.\",\n    )\n    ap.add_argument(\n        \"--pr_file\",\n        type=str,\n        required=True,\n        help=\"Path to a text file with PR description / diff.\",\n    )\n    ap.add_argument(\n        \"--device\",\n        type=str,\n        default=\"cuda\" if torch.cuda.is_available() else \"cpu\",\n        help=\"Device to use.\",\n    )\n    return ap.parse_args()\n\n\ndef main() -> None:\n    args = parse_args()\n    cfg = load_tolbert_config(args.config)\n    device = torch.device(args.device)\n\n    checkpoint_path = Path(args.checkpoint)\n    if not checkpoint_path.exists():\n        raise FileNotFoundError(f\"Checkpoint not found: {checkpoint_path}\")\n\n    tokenizer = AutoTokenizer.from_pretrained(\n        cfg[\"base_model_name\"],\n        cache_dir=\"/data/checkpoints/\",  # noqa: E501\n    )\n    model = build_model(cfg, str(checkpoint_path), device=device)\n\n    # Load and span-ize the PR\n    pr_text = Path(args.pr_file).read_text(encoding=\"utf-8\")\n    pr_spans = simple_pr_spans(pr_text)\n\n    pr_embs, span_metas = encode_spans(\n        model=model,\n        tokenizer=tokenizer,\n        spans=pr_spans,\n        max_length=cfg.get(\"max_length\", 256),\n        device=device,\n    )\n\n    # Load paper index and retrieve recommendations\n    paper_embs, paper_metas = load_paper_index(args.paper_index)\n    recommendations = retrieve_top_papers(\n        pr_embs=pr_embs,\n        paper_embs=paper_embs,\n        paper_metas=paper_metas,\n        top_k_per_span=cfg.get(\"top_k_per_span\", 5),\n        top_k_papers=cfg.get(\"top_k_papers\", 10),\n    )\n\n    if not recommendations:\n        print(\"No paper recommendations found (empty embeddings or index).\")\n        return\n\n    prompt = build_prompt(pr_text, recommendations)\n\n    # Hand off to LLM (you implement this)\n    print(\"=== LLM PROMPT BEGIN ===\")\n    print(prompt)\n    print(\"=== LLM PROMPT END ===\")\n    print()\n    print(\"Now call your LLM client with the prompt above (see `call_llm`).\")\n\n\nif __name__ == \"__main__\":\n    main()\n\n","source_hash":"24db8874e1fff25f28fb857720c13e8c262d8c4f888ea8c39fabeae3aba6ef3f","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.agent_pr_paper_recommender.call_llm","uri":"program://TOLBERT/function/scripts.agent_pr_paper_recommender.call_llm#L30-L36","kind":"function","name":"call_llm","path":"scripts/agent_pr_paper_recommender.py","language":"python","start_line":30,"end_line":36,"context_start_line":10,"context_end_line":56,"code":"\nYou are expected to plug in:\n  - real PR ingestion,\n  - a proper paper-span index (vector DB, search service, etc.),\n  - and your own LLM backend in `call_llm`.\n\"\"\"\n\nimport argparse\nfrom pathlib import Path\nfrom typing import Any, Dict, List, Tuple\n\nimport torch\nfrom torch.nn import functional as F\nfrom transformers import AutoTokenizer\nimport os\n\nfrom tolbert.config import load_tolbert_config\nfrom tolbert.modeling import TOLBERT, TOLBERTConfig\n\n\ndef call_llm(prompt: str) -> str:\n    \"\"\"\n    Placeholder for your LLM call.\n\n    Replace this with your own LLM client (OpenAI, local model, etc.).\n    \"\"\"\n    raise NotImplementedError(\"Integrate your LLM client here.\")\n\n\ndef build_model(cfg: Dict[str, Any], checkpoint: str, device: torch.device) -> TOLBERT:\n    model_cfg = TOLBERTConfig(\n        base_model_name=cfg[\"base_model_name\"],\n        level_sizes=cfg[\"level_sizes\"],\n        proj_dim=cfg.get(\"proj_dim\", 256),\n    )\n    model = TOLBERT(model_cfg)\n    state = torch.load(checkpoint, map_location=\"cpu\")\n    model.load_state_dict(state)\n    model.to(device)\n    model.eval()\n    return model\n\n\ndef simple_pr_spans(pr_text: str) -> List[str]:\n    \"\"\"\n    Very simple PR spanizer:\n      - splits on double newlines,","source_hash":"24db8874e1fff25f28fb857720c13e8c262d8c4f888ea8c39fabeae3aba6ef3f","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.agent_pr_paper_recommender.build_model","uri":"program://TOLBERT/function/scripts.agent_pr_paper_recommender.build_model#L39-L50","kind":"function","name":"build_model","path":"scripts/agent_pr_paper_recommender.py","language":"python","start_line":39,"end_line":50,"context_start_line":19,"context_end_line":70,"code":"from typing import Any, Dict, List, Tuple\n\nimport torch\nfrom torch.nn import functional as F\nfrom transformers import AutoTokenizer\nimport os\n\nfrom tolbert.config import load_tolbert_config\nfrom tolbert.modeling import TOLBERT, TOLBERTConfig\n\n\ndef call_llm(prompt: str) -> str:\n    \"\"\"\n    Placeholder for your LLM call.\n\n    Replace this with your own LLM client (OpenAI, local model, etc.).\n    \"\"\"\n    raise NotImplementedError(\"Integrate your LLM client here.\")\n\n\ndef build_model(cfg: Dict[str, Any], checkpoint: str, device: torch.device) -> TOLBERT:\n    model_cfg = TOLBERTConfig(\n        base_model_name=cfg[\"base_model_name\"],\n        level_sizes=cfg[\"level_sizes\"],\n        proj_dim=cfg.get(\"proj_dim\", 256),\n    )\n    model = TOLBERT(model_cfg)\n    state = torch.load(checkpoint, map_location=\"cpu\")\n    model.load_state_dict(state)\n    model.to(device)\n    model.eval()\n    return model\n\n\ndef simple_pr_spans(pr_text: str) -> List[str]:\n    \"\"\"\n    Very simple PR spanizer:\n      - splits on double newlines,\n      - keeps reasonably sized chunks as candidate spans.\n\n    You likely want to replace this with something that understands diffs\n    and function boundaries.\n    \"\"\"\n    parts = [p.strip() for p in pr_text.split(\"\\n\\n\") if p.strip()]\n    return parts\n\n\ndef encode_spans(\n    model: TOLBERT,\n    tokenizer,\n    spans: List[str],\n    max_length: int,","source_hash":"24db8874e1fff25f28fb857720c13e8c262d8c4f888ea8c39fabeae3aba6ef3f","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.agent_pr_paper_recommender.simple_pr_spans","uri":"program://TOLBERT/function/scripts.agent_pr_paper_recommender.simple_pr_spans#L53-L63","kind":"function","name":"simple_pr_spans","path":"scripts/agent_pr_paper_recommender.py","language":"python","start_line":53,"end_line":63,"context_start_line":33,"context_end_line":83,"code":"\n    Replace this with your own LLM client (OpenAI, local model, etc.).\n    \"\"\"\n    raise NotImplementedError(\"Integrate your LLM client here.\")\n\n\ndef build_model(cfg: Dict[str, Any], checkpoint: str, device: torch.device) -> TOLBERT:\n    model_cfg = TOLBERTConfig(\n        base_model_name=cfg[\"base_model_name\"],\n        level_sizes=cfg[\"level_sizes\"],\n        proj_dim=cfg.get(\"proj_dim\", 256),\n    )\n    model = TOLBERT(model_cfg)\n    state = torch.load(checkpoint, map_location=\"cpu\")\n    model.load_state_dict(state)\n    model.to(device)\n    model.eval()\n    return model\n\n\ndef simple_pr_spans(pr_text: str) -> List[str]:\n    \"\"\"\n    Very simple PR spanizer:\n      - splits on double newlines,\n      - keeps reasonably sized chunks as candidate spans.\n\n    You likely want to replace this with something that understands diffs\n    and function boundaries.\n    \"\"\"\n    parts = [p.strip() for p in pr_text.split(\"\\n\\n\") if p.strip()]\n    return parts\n\n\ndef encode_spans(\n    model: TOLBERT,\n    tokenizer,\n    spans: List[str],\n    max_length: int,\n    device: torch.device,\n) -> Tuple[torch.Tensor, List[Dict[str, Any]]]:\n    embs: List[torch.Tensor] = []\n    metas: List[Dict[str, Any]] = []\n    for i, text in enumerate(spans):\n        tokens = tokenizer(\n            text,\n            return_tensors=\"pt\",\n            truncation=True,\n            padding=\"max_length\",\n            max_length=max_length,\n        )\n        with torch.no_grad():","source_hash":"24db8874e1fff25f28fb857720c13e8c262d8c4f888ea8c39fabeae3aba6ef3f","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.agent_pr_paper_recommender.encode_spans","uri":"program://TOLBERT/function/scripts.agent_pr_paper_recommender.encode_spans#L66-L107","kind":"function","name":"encode_spans","path":"scripts/agent_pr_paper_recommender.py","language":"python","start_line":66,"end_line":107,"context_start_line":46,"context_end_line":127,"code":"    state = torch.load(checkpoint, map_location=\"cpu\")\n    model.load_state_dict(state)\n    model.to(device)\n    model.eval()\n    return model\n\n\ndef simple_pr_spans(pr_text: str) -> List[str]:\n    \"\"\"\n    Very simple PR spanizer:\n      - splits on double newlines,\n      - keeps reasonably sized chunks as candidate spans.\n\n    You likely want to replace this with something that understands diffs\n    and function boundaries.\n    \"\"\"\n    parts = [p.strip() for p in pr_text.split(\"\\n\\n\") if p.strip()]\n    return parts\n\n\ndef encode_spans(\n    model: TOLBERT,\n    tokenizer,\n    spans: List[str],\n    max_length: int,\n    device: torch.device,\n) -> Tuple[torch.Tensor, List[Dict[str, Any]]]:\n    embs: List[torch.Tensor] = []\n    metas: List[Dict[str, Any]] = []\n    for i, text in enumerate(spans):\n        tokens = tokenizer(\n            text,\n            return_tensors=\"pt\",\n            truncation=True,\n            padding=\"max_length\",\n            max_length=max_length,\n        )\n        with torch.no_grad():\n            out = model(\n                input_ids=tokens[\"input_ids\"].to(device),\n                attention_mask=tokens[\"attention_mask\"].to(device),\n            )\n        embs.append(out[\"proj\"].squeeze(0).cpu())\n\n        # Record predicted hierarchy information for analysis.\n        level_logits = out[\"level_logits\"]\n        level_preds = {\n            int(level): logits.argmax(dim=-1).item()\n            for level, logits in level_logits.items()\n        }\n\n        metas.append(\n            {\n                \"span_index\": i,\n                \"text\": text,\n                \"level_predictions\": level_preds,\n            }\n        )\n\n    if not embs:\n        return torch.empty(0), metas\n    return torch.stack(embs, dim=0), metas\n\n\ndef load_paper_index(index_path: str) -> Tuple[torch.Tensor, List[Dict[str, Any]]]:\n    \"\"\"\n    Load a pre-built paper-span index.\n\n    This function is intentionally schematic. You might, for example, store:\n      - embeddings as a `.pt` tensor,\n      - metadata as a JSON/JSONL file with the same length.\n    \"\"\"\n    index_dir = Path(index_path)\n    emb_path = index_dir / \"embeddings.pt\"\n    meta_path = index_dir / \"metadata.jsonl\"\n\n    if not emb_path.exists() or not meta_path.exists():\n        raise FileNotFoundError(\n            f\"Expected embeddings at {emb_path} and metadata at {meta_path}.\"\n        )\n\n    embs = torch.load(emb_path, map_location=\"cpu\")","source_hash":"24db8874e1fff25f28fb857720c13e8c262d8c4f888ea8c39fabeae3aba6ef3f","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.agent_pr_paper_recommender.load_paper_index","uri":"program://TOLBERT/function/scripts.agent_pr_paper_recommender.load_paper_index#L110-L141","kind":"function","name":"load_paper_index","path":"scripts/agent_pr_paper_recommender.py","language":"python","start_line":110,"end_line":141,"context_start_line":90,"context_end_line":161,"code":"        # Record predicted hierarchy information for analysis.\n        level_logits = out[\"level_logits\"]\n        level_preds = {\n            int(level): logits.argmax(dim=-1).item()\n            for level, logits in level_logits.items()\n        }\n\n        metas.append(\n            {\n                \"span_index\": i,\n                \"text\": text,\n                \"level_predictions\": level_preds,\n            }\n        )\n\n    if not embs:\n        return torch.empty(0), metas\n    return torch.stack(embs, dim=0), metas\n\n\ndef load_paper_index(index_path: str) -> Tuple[torch.Tensor, List[Dict[str, Any]]]:\n    \"\"\"\n    Load a pre-built paper-span index.\n\n    This function is intentionally schematic. You might, for example, store:\n      - embeddings as a `.pt` tensor,\n      - metadata as a JSON/JSONL file with the same length.\n    \"\"\"\n    index_dir = Path(index_path)\n    emb_path = index_dir / \"embeddings.pt\"\n    meta_path = index_dir / \"metadata.jsonl\"\n\n    if not emb_path.exists() or not meta_path.exists():\n        raise FileNotFoundError(\n            f\"Expected embeddings at {emb_path} and metadata at {meta_path}.\"\n        )\n\n    embs = torch.load(emb_path, map_location=\"cpu\")\n    metas: List[Dict[str, Any]] = []\n    with meta_path.open(\"r\", encoding=\"utf-8\") as f:\n        import json\n\n        for line in f:\n            line = line.strip()\n            if not line:\n                continue\n            metas.append(json.loads(line))\n\n    if embs.size(0) != len(metas):\n        raise ValueError(\"Mismatch between number of embeddings and metadata entries.\")\n\n    return embs, metas\n\n\ndef retrieve_top_papers(\n    pr_embs: torch.Tensor,\n    paper_embs: torch.Tensor,\n    paper_metas: List[Dict[str, Any]],\n    top_k_per_span: int = 5,\n    top_k_papers: int = 10,\n) -> List[Dict[str, Any]]:\n    \"\"\"\n    Simple multi-span retrieval:\n      - for each PR span embedding, retrieve top_k_per_span paper spans,\n      - aggregate scores per paper id,\n      - return top_k_papers papers with aggregated scores.\n    \"\"\"\n    if pr_embs.numel() == 0 or paper_embs.numel() == 0:\n        return []\n\n    scores: Dict[str, float] = {}\n    for i in range(pr_embs.size(0)):","source_hash":"24db8874e1fff25f28fb857720c13e8c262d8c4f888ea8c39fabeae3aba6ef3f","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.agent_pr_paper_recommender.retrieve_top_papers","uri":"program://TOLBERT/function/scripts.agent_pr_paper_recommender.retrieve_top_papers#L144-L185","kind":"function","name":"retrieve_top_papers","path":"scripts/agent_pr_paper_recommender.py","language":"python","start_line":144,"end_line":185,"context_start_line":124,"context_end_line":205,"code":"            f\"Expected embeddings at {emb_path} and metadata at {meta_path}.\"\n        )\n\n    embs = torch.load(emb_path, map_location=\"cpu\")\n    metas: List[Dict[str, Any]] = []\n    with meta_path.open(\"r\", encoding=\"utf-8\") as f:\n        import json\n\n        for line in f:\n            line = line.strip()\n            if not line:\n                continue\n            metas.append(json.loads(line))\n\n    if embs.size(0) != len(metas):\n        raise ValueError(\"Mismatch between number of embeddings and metadata entries.\")\n\n    return embs, metas\n\n\ndef retrieve_top_papers(\n    pr_embs: torch.Tensor,\n    paper_embs: torch.Tensor,\n    paper_metas: List[Dict[str, Any]],\n    top_k_per_span: int = 5,\n    top_k_papers: int = 10,\n) -> List[Dict[str, Any]]:\n    \"\"\"\n    Simple multi-span retrieval:\n      - for each PR span embedding, retrieve top_k_per_span paper spans,\n      - aggregate scores per paper id,\n      - return top_k_papers papers with aggregated scores.\n    \"\"\"\n    if pr_embs.numel() == 0 or paper_embs.numel() == 0:\n        return []\n\n    scores: Dict[str, float] = {}\n    for i in range(pr_embs.size(0)):\n        q = pr_embs[i : i + 1]\n        sims = F.cosine_similarity(q, paper_embs, dim=1)\n        topk = torch.topk(sims, k=min(top_k_per_span, sims.numel()))\n        for idx, score in zip(topk.indices.tolist(), topk.values.tolist()):\n            meta = paper_metas[idx]\n            paper_id = str(meta.get(\"paper_id\", idx))\n            scores[paper_id] = scores.get(paper_id, 0.0) + float(score)\n\n    ranked = sorted(scores.items(), key=lambda kv: kv[1], reverse=True)[:top_k_papers]\n    results: List[Dict[str, Any]] = []\n    for paper_id, score in ranked:\n        # find first meta entry with this paper_id\n        meta = next((m for m in paper_metas if str(m.get(\"paper_id\")) == paper_id), None)\n        if meta is None:\n            continue\n        results.append(\n            {\n                \"paper_id\": paper_id,\n                \"score\": score,\n                \"title\": meta.get(\"title\"),\n                \"abstract\": meta.get(\"abstract\"),\n            }\n        )\n    return results\n\n\ndef build_prompt(pr_text: str, recommendations: List[Dict[str, Any]]) -> str:\n    \"\"\"\n    Construct a prompt for the LLM given:\n      - the PR text,\n      - a set of candidate papers with scores and metadata.\n    \"\"\"\n    lines = [\n        \"You are an expert AI code reviewer and research assistant.\",\n        \"Given the following pull request and a set of candidate research papers,\",\n        \"explain which papers are most relevant and why.\",\n        \"\",\n        \"PULL REQUEST:\",\n        pr_text,\n        \"\",\n        \"CANDIDATE PAPERS:\",\n    ]\n    for i, rec in enumerate(recommendations, start=1):\n        lines.append(","source_hash":"24db8874e1fff25f28fb857720c13e8c262d8c4f888ea8c39fabeae3aba6ef3f","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.agent_pr_paper_recommender.build_prompt","uri":"program://TOLBERT/function/scripts.agent_pr_paper_recommender.build_prompt#L188-L217","kind":"function","name":"build_prompt","path":"scripts/agent_pr_paper_recommender.py","language":"python","start_line":188,"end_line":217,"context_start_line":168,"context_end_line":237,"code":"            scores[paper_id] = scores.get(paper_id, 0.0) + float(score)\n\n    ranked = sorted(scores.items(), key=lambda kv: kv[1], reverse=True)[:top_k_papers]\n    results: List[Dict[str, Any]] = []\n    for paper_id, score in ranked:\n        # find first meta entry with this paper_id\n        meta = next((m for m in paper_metas if str(m.get(\"paper_id\")) == paper_id), None)\n        if meta is None:\n            continue\n        results.append(\n            {\n                \"paper_id\": paper_id,\n                \"score\": score,\n                \"title\": meta.get(\"title\"),\n                \"abstract\": meta.get(\"abstract\"),\n            }\n        )\n    return results\n\n\ndef build_prompt(pr_text: str, recommendations: List[Dict[str, Any]]) -> str:\n    \"\"\"\n    Construct a prompt for the LLM given:\n      - the PR text,\n      - a set of candidate papers with scores and metadata.\n    \"\"\"\n    lines = [\n        \"You are an expert AI code reviewer and research assistant.\",\n        \"Given the following pull request and a set of candidate research papers,\",\n        \"explain which papers are most relevant and why.\",\n        \"\",\n        \"PULL REQUEST:\",\n        pr_text,\n        \"\",\n        \"CANDIDATE PAPERS:\",\n    ]\n    for i, rec in enumerate(recommendations, start=1):\n        lines.append(\n            f\"{i}. [paper_id={rec['paper_id']}] title={rec.get('title')!r} \"\n            f\"(score={rec['score']:.3f})\"\n        )\n        if rec.get(\"abstract\"):\n            lines.append(f\"   abstract={rec['abstract']!r}\")\n    lines.append(\"\")\n    lines.append(\n        \"For each paper above, give a short explanation (2-4 sentences) \"\n        \"of how it relates to the PR, and suggest how the PR could benefit \"\n        \"from ideas in these papers.\"\n    )\n    return \"\\n\".join(lines)\n\n\ndef parse_args() -> argparse.Namespace:\n    ap = argparse.ArgumentParser(description=\"PR -> paper recommendation agent (skeleton).\")\n    ap.add_argument(\"--config\", type=str, required=True, help=\"Path to TOLBERT config.\")\n    ap.add_argument(\"--checkpoint\", type=str, required=True, help=\"Path to model checkpoint (.pt).\")\n    ap.add_argument(\n        \"--paper_index\",\n        type=str,\n        required=True,\n        help=\"Path to directory with paper-span embeddings and metadata.\",\n    )\n    ap.add_argument(\n        \"--pr_file\",\n        type=str,\n        required=True,\n        help=\"Path to a text file with PR description / diff.\",\n    )\n    ap.add_argument(\n        \"--device\",","source_hash":"24db8874e1fff25f28fb857720c13e8c262d8c4f888ea8c39fabeae3aba6ef3f","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.agent_pr_paper_recommender.parse_args","uri":"program://TOLBERT/function/scripts.agent_pr_paper_recommender.parse_args#L220-L242","kind":"function","name":"parse_args","path":"scripts/agent_pr_paper_recommender.py","language":"python","start_line":220,"end_line":242,"context_start_line":200,"context_end_line":262,"code":"        pr_text,\n        \"\",\n        \"CANDIDATE PAPERS:\",\n    ]\n    for i, rec in enumerate(recommendations, start=1):\n        lines.append(\n            f\"{i}. [paper_id={rec['paper_id']}] title={rec.get('title')!r} \"\n            f\"(score={rec['score']:.3f})\"\n        )\n        if rec.get(\"abstract\"):\n            lines.append(f\"   abstract={rec['abstract']!r}\")\n    lines.append(\"\")\n    lines.append(\n        \"For each paper above, give a short explanation (2-4 sentences) \"\n        \"of how it relates to the PR, and suggest how the PR could benefit \"\n        \"from ideas in these papers.\"\n    )\n    return \"\\n\".join(lines)\n\n\ndef parse_args() -> argparse.Namespace:\n    ap = argparse.ArgumentParser(description=\"PR -> paper recommendation agent (skeleton).\")\n    ap.add_argument(\"--config\", type=str, required=True, help=\"Path to TOLBERT config.\")\n    ap.add_argument(\"--checkpoint\", type=str, required=True, help=\"Path to model checkpoint (.pt).\")\n    ap.add_argument(\n        \"--paper_index\",\n        type=str,\n        required=True,\n        help=\"Path to directory with paper-span embeddings and metadata.\",\n    )\n    ap.add_argument(\n        \"--pr_file\",\n        type=str,\n        required=True,\n        help=\"Path to a text file with PR description / diff.\",\n    )\n    ap.add_argument(\n        \"--device\",\n        type=str,\n        default=\"cuda\" if torch.cuda.is_available() else \"cpu\",\n        help=\"Device to use.\",\n    )\n    return ap.parse_args()\n\n\ndef main() -> None:\n    args = parse_args()\n    cfg = load_tolbert_config(args.config)\n    device = torch.device(args.device)\n\n    checkpoint_path = Path(args.checkpoint)\n    if not checkpoint_path.exists():\n        raise FileNotFoundError(f\"Checkpoint not found: {checkpoint_path}\")\n\n    tokenizer = AutoTokenizer.from_pretrained(\n        cfg[\"base_model_name\"],\n        cache_dir=\"/data/checkpoints/\",  # noqa: E501\n    )\n    model = build_model(cfg, str(checkpoint_path), device=device)\n\n    # Load and span-ize the PR\n    pr_text = Path(args.pr_file).read_text(encoding=\"utf-8\")\n    pr_spans = simple_pr_spans(pr_text)","source_hash":"24db8874e1fff25f28fb857720c13e8c262d8c4f888ea8c39fabeae3aba6ef3f","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.agent_pr_paper_recommender.main","uri":"program://TOLBERT/function/scripts.agent_pr_paper_recommender.main#L245-L293","kind":"function","name":"main","path":"scripts/agent_pr_paper_recommender.py","language":"python","start_line":245,"end_line":293,"context_start_line":225,"context_end_line":299,"code":"        \"--paper_index\",\n        type=str,\n        required=True,\n        help=\"Path to directory with paper-span embeddings and metadata.\",\n    )\n    ap.add_argument(\n        \"--pr_file\",\n        type=str,\n        required=True,\n        help=\"Path to a text file with PR description / diff.\",\n    )\n    ap.add_argument(\n        \"--device\",\n        type=str,\n        default=\"cuda\" if torch.cuda.is_available() else \"cpu\",\n        help=\"Device to use.\",\n    )\n    return ap.parse_args()\n\n\ndef main() -> None:\n    args = parse_args()\n    cfg = load_tolbert_config(args.config)\n    device = torch.device(args.device)\n\n    checkpoint_path = Path(args.checkpoint)\n    if not checkpoint_path.exists():\n        raise FileNotFoundError(f\"Checkpoint not found: {checkpoint_path}\")\n\n    tokenizer = AutoTokenizer.from_pretrained(\n        cfg[\"base_model_name\"],\n        cache_dir=\"/data/checkpoints/\",  # noqa: E501\n    )\n    model = build_model(cfg, str(checkpoint_path), device=device)\n\n    # Load and span-ize the PR\n    pr_text = Path(args.pr_file).read_text(encoding=\"utf-8\")\n    pr_spans = simple_pr_spans(pr_text)\n\n    pr_embs, span_metas = encode_spans(\n        model=model,\n        tokenizer=tokenizer,\n        spans=pr_spans,\n        max_length=cfg.get(\"max_length\", 256),\n        device=device,\n    )\n\n    # Load paper index and retrieve recommendations\n    paper_embs, paper_metas = load_paper_index(args.paper_index)\n    recommendations = retrieve_top_papers(\n        pr_embs=pr_embs,\n        paper_embs=paper_embs,\n        paper_metas=paper_metas,\n        top_k_per_span=cfg.get(\"top_k_per_span\", 5),\n        top_k_papers=cfg.get(\"top_k_papers\", 10),\n    )\n\n    if not recommendations:\n        print(\"No paper recommendations found (empty embeddings or index).\")\n        return\n\n    prompt = build_prompt(pr_text, recommendations)\n\n    # Hand off to LLM (you implement this)\n    print(\"=== LLM PROMPT BEGIN ===\")\n    print(prompt)\n    print(\"=== LLM PROMPT END ===\")\n    print()\n    print(\"Now call your LLM client with the prompt above (see `call_llm`).\")\n\n\nif __name__ == \"__main__\":\n    main()\n\n","source_hash":"24db8874e1fff25f28fb857720c13e8c262d8c4f888ea8c39fabeae3aba6ef3f","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.build_joint_code_paper_tol","uri":"program://TOLBERT/module/scripts.build_joint_code_paper_tol#L1-L481","kind":"module","name":"scripts.build_joint_code_paper_tol","path":"scripts/build_joint_code_paper_tol.py","language":"python","start_line":1,"end_line":481,"context_start_line":1,"context_end_line":481,"code":"\"\"\"\nBuild a joint code+paper Tree-of-Life (ToL) from existing per-domain spans.\n\nThis script is the missing glue described in the paper/docs: it takes\nseparate code and paper span files (each with its own local ontology and\n`node_path` ids) and produces:\n\n- A single, unified `nodes.jsonl` Tree-of-Life with:\n    level 0: root\n    level 1: domain nodes (e.g., \"Code\", \"Papers\")\n    level 2+: remapped nodes from the original per-domain ontologies\n- Rewritten span files for code and papers where `node_path` has been\n  updated to refer to the *joint* node ID space.\n- A `level_sizes` JSON helper compatible with `TOLBERTConfig.level_sizes`.\n\nDesign notes\n============\n\nThis script deliberately **does not attempt to infer a semantic mapping**\nbetween code categories (e.g., \"Web\", \"ML\", \"Systems\") and paper fields\n(\"Computer Science\", \"Physics\", ...). Doing that well would require\ndomain-specific heuristics or manual curation.\n\nInstead, it:\n\n- Adds explicit top-level domain nodes (by default: `\"Code\"` and `\"Papers\"`)\n  at level 1 under a single shared root.\n- Shifts each original ontology **one level deeper** in the tree:\n    - Original root (id 0) is discarded; we introduce a fresh shared root.\n    - Original level-1 nodes become level-2 under their domain node.\n    - Original level-2 nodes become level-3, and so on.\n- Remaps all node IDs into a **single global ID space** while preserving\n  parent/child relations within each domain.\n\nThis gives you:\n\n- A concrete, unified Tree-of-Life suitable for pretraining a single\n  TOLBERT model across both domains.\n- A starting point for more sophisticated, semantics-aware unification\n  (e.g., manually or automatically clustering level-2 nodes across domains).\n\nInputs\n======\n\n- --code_spans:\n    Spans JSONL for the code side (e.g., from `build_codehierarchy_spans.py`),\n    with records of the form:\n        {\"span_id\": \"...\", \"text\": \"...\", \"source_id\": \"...\", \"node_path\": [...], ...}\n\n- --code_nodes:\n    Ontology `nodes.jsonl` corresponding to `code_spans`. Expected fields:\n        node_id, level, type, parent_id, name, attributes\n\n- --paper_spans:\n    Spans JSONL for the paper side (e.g., from `build_wos_spans.py` or\n    `build_researchhierarchy_spans.py`).\n\n- --paper_nodes:\n    Ontology `nodes.jsonl` corresponding to `paper_spans`.\n\nOutputs\n=======\n\n- --out_code_spans:\n    Code spans JSONL with updated, joint `node_path`.\n\n- --out_paper_spans:\n    Paper spans JSONL with updated, joint `node_path`.\n\n- --out_nodes:\n    Joint ontology `nodes.jsonl` with a single root and shared ID space.\n\n- --out_level_sizes:\n    Small JSON file with:\n        {\"level_sizes\": {1: num_level1, 2: num_level2, ...}}\n    which you can plug into your TOLBERT training config.\n\nUsage (example)\n===============\n\n1) Build per-domain datasets:\n\n    python scripts/build_codehierarchy_spans.py \\\n        --repos_root /path/to/repos \\\n        --metadata_file /path/to/code_meta.csv \\\n        --spans_out data/code/spans_train.jsonl \\\n        --nodes_out data/code/nodes.jsonl\n\n    python scripts/build_wos_spans.py \\\n        --input-csv /path/to/wos_train.csv \\\n        --spans-out data/wos/spans_train.jsonl \\\n        --nodes-out data/wos/nodes.jsonl\n\n2) Join into a single Tree-of-Life:\n\n    python scripts/build_joint_code_paper_tol.py \\\n        --code_spans data/code/spans_train.jsonl \\\n        --code_nodes data/code/nodes.jsonl \\\n        --paper_spans data/wos/spans_train.jsonl \\\n        --paper_nodes data/wos/nodes.jsonl \\\n        --out_code_spans data/joint/code_spans_train.jsonl \\\n        --out_paper_spans data/joint/paper_spans_train.jsonl \\\n        --out_nodes data/joint/nodes.jsonl \\\n        --out_level_sizes data/joint/level_sizes.json\n\nYou can then train TOLBERT on the union of `out_code_spans` and\n`out_paper_spans` (e.g., via the `spans_files` list in your config) with\n`level_sizes` taken from `out_level_sizes`.\n\"\"\"\n\nfrom __future__ import annotations\n\nimport argparse\nimport json\nfrom dataclasses import dataclass\nfrom pathlib import Path\nfrom typing import Dict, Iterable, List, Tuple\n\n\n@dataclass\nclass NodeRecord:\n    node_id: int\n    level: int\n    type: str\n    parent_id: int | None\n    name: str\n    attributes: Dict[str, object]\n\n\ndef _load_nodes(path: Path) -> Dict[int, NodeRecord]:\n    nodes: Dict[int, NodeRecord] = {}\n    with path.open(\"r\", encoding=\"utf-8\") as f:\n        for line in f:\n            line = line.strip()\n            if not line:\n                continue\n            obj = json.loads(line)\n            nid = int(obj[\"node_id\"])\n            level = int(obj.get(\"level\", 0))\n            node_type = str(obj.get(\"type\", \"node\"))\n            parent_id = obj.get(\"parent_id\")\n            if parent_id is not None:\n                parent_id = int(parent_id)\n            name = str(obj.get(\"name\", f\"node_{nid}\"))\n            attributes = obj.get(\"attributes\") or {}\n            nodes[nid] = NodeRecord(\n                node_id=nid,\n                level=level,\n                type=node_type,\n                parent_id=parent_id,\n                name=name,\n                attributes=attributes,\n            )\n    return nodes\n\n\ndef _iter_spans(path: Path) -> Iterable[Dict[str, object]]:\n    with path.open(\"r\", encoding=\"utf-8\") as f:\n        for line in f:\n            line = line.strip()\n            if not line:\n                continue\n            yield json.loads(line)\n\n\ndef _write_spans(path: Path, records: Iterable[Dict[str, object]]) -> None:\n    with path.open(\"w\", encoding=\"utf-8\") as f:\n        for rec in records:\n            f.write(json.dumps(rec) + \"\\n\")\n\n\ndef _build_joint_ontology(\n    *,\n    code_nodes: Dict[int, NodeRecord],\n    paper_nodes: Dict[int, NodeRecord],\n    code_domain_name: str = \"Code\",\n    paper_domain_name: str = \"Papers\",\n) -> Tuple[\n    Dict[int, NodeRecord],\n    Dict[int, int],\n    Dict[int, int],\n    Dict[int, int],\n]:\n    \"\"\"\n    Construct a joint ontology and return:\n\n    - joint_nodes: dict[new_id -> NodeRecord]\n    - code_id_map: mapping old_code_node_id -> new_global_node_id\n    - paper_id_map: mapping old_paper_node_id -> new_global_node_id\n    - level_counts: mapping level -> number of nodes at that level (excluding root)\n\n    Strategy:\n      - Create a fresh root (id 0).\n      - Create two domain nodes at level 1: Code, Papers.\n      - For each original ontology:\n          * Drop its root node (level 0).\n          * Shift all other nodes one level deeper (level' = level + 1).\n          * Rewire parents so that:\n              - old parent == 0  → new parent = corresponding domain node id\n              - otherwise        → new parent = mapped parent id\n    \"\"\"\n    joint_nodes: Dict[int, NodeRecord] = {}\n    level_counts: Dict[int, int] = {}\n\n    # Root (level 0)\n    root_id = 0\n    joint_nodes[root_id] = NodeRecord(\n        node_id=root_id,\n        level=0,\n        type=\"root\",\n        parent_id=None,\n        name=\"Root\",\n        attributes={},\n    )\n\n    next_id = 1\n\n    # Domain nodes at level 1\n    code_domain_id = next_id\n    next_id += 1\n    paper_domain_id = next_id\n    next_id += 1\n\n    joint_nodes[code_domain_id] = NodeRecord(\n        node_id=code_domain_id,\n        level=1,\n        type=\"domain\",\n        parent_id=root_id,\n        name=code_domain_name,\n        attributes={\"source\": \"code\"},\n    )\n    joint_nodes[paper_domain_id] = NodeRecord(\n        node_id=paper_domain_id,\n        level=1,\n        type=\"domain\",\n        parent_id=root_id,\n        name=paper_domain_name,\n        attributes={\"source\": \"paper\"},\n    )\n    level_counts[1] = 2\n\n    code_id_map: Dict[int, int] = {}\n    paper_id_map: Dict[int, int] = {}\n\n    def _remap_domain(\n        *,\n        src_nodes: Dict[int, NodeRecord],\n        domain_node_id: int,\n        is_code: bool,\n    ) -> Dict[int, int]:\n        nonlocal next_id\n        id_map: Dict[int, int] = {}\n\n        # Sort by (level, node_id) for stable assignment.\n        for old_id, rec in sorted(src_nodes.items(), key=lambda kv: (kv[1].level, kv[0])):\n            if rec.level == 0:\n                # Skip local root; we replace it with shared root + domain nodes.\n                continue\n\n            new_level = rec.level + 1  # shift deeper by one level\n            new_id = next_id\n            next_id += 1\n\n            # Determine parent in joint space.\n            if rec.parent_id is None or rec.parent_id == 0:\n                new_parent = domain_node_id\n            else:\n                if rec.parent_id not in id_map:\n                    raise ValueError(\n                        f\"Parent node_id {rec.parent_id} for node {old_id} has not been remapped yet.\"\n                    )\n                new_parent = id_map[rec.parent_id]\n\n            # Merge attributes and tag source.\n            attrs = dict(rec.attributes or {})\n            attrs.setdefault(\"source\", \"code\" if is_code else \"paper\")\n\n            joint_nodes[new_id] = NodeRecord(\n                node_id=new_id,\n                level=new_level,\n                type=rec.type,\n                parent_id=new_parent,\n                name=rec.name,\n                attributes=attrs,\n            )\n\n            id_map[old_id] = new_id\n            level_counts[new_level] = level_counts.get(new_level, 0) + 1\n\n        return id_map\n\n    code_id_map = _remap_domain(src_nodes=code_nodes, domain_node_id=code_domain_id, is_code=True)\n    paper_id_map = _remap_domain(\n        src_nodes=paper_nodes, domain_node_id=paper_domain_id, is_code=False\n    )\n\n    return joint_nodes, code_id_map, paper_id_map, level_counts\n\n\ndef _rewrite_spans(\n    spans_path: Path,\n    *,\n    domain_node_id: int,\n    id_map: Dict[int, int],\n) -> List[Dict[str, object]]:\n    \"\"\"\n    Rewrite node_path for spans from a single domain into the joint ID space.\n    \"\"\"\n    out: List[Dict[str, object]] = []\n    root_id = 0\n\n    for rec in _iter_spans(spans_path):\n        old_path = rec.get(\"node_path\")\n        if not isinstance(old_path, list) or not old_path:\n            # Leave record untouched if it lacks a path.\n            out.append(rec)\n            continue\n\n        # Old paths are expected to be [root_id, ... local node ids ...].\n        # We drop the old root and map each remaining id via id_map.\n        new_path: List[int] = [root_id, domain_node_id]\n        for old_id in old_path[1:]:\n            new_id = id_map.get(int(old_id))\n            if new_id is None:\n                # If we don't know this node, skip it; better a shorter path\n                # than a broken one.\n                continue\n            new_path.append(new_id)\n\n        # Ensure at least [root, domain] is present.\n        if len(new_path) < 2:\n            new_path = [root_id, domain_node_id]\n\n        rec = dict(rec)\n        rec[\"node_path\"] = new_path\n        out.append(rec)\n\n    return out\n\n\ndef _write_nodes_jsonl(nodes: Dict[int, NodeRecord], out_path: Path) -> None:\n    with out_path.open(\"w\", encoding=\"utf-8\") as f:\n        for nid, rec in sorted(nodes.items(), key=lambda kv: kv[0]):\n            f.write(\n                json.dumps(\n                    {\n                        \"node_id\": rec.node_id,\n                        \"level\": rec.level,\n                        \"type\": rec.type,\n                        \"parent_id\": rec.parent_id,\n                        \"name\": rec.name,\n                        \"attributes\": rec.attributes,\n                    }\n                )\n                + \"\\n\"\n            )\n\n\ndef _write_level_sizes(level_counts: Dict[int, int], out_path: Path) -> None:\n    # Exclude root (level 0) from level_sizes; TOLBERT heads start at level 1.\n    level_sizes = {level: count for level, count in level_counts.items() if level > 0}\n    with out_path.open(\"w\", encoding=\"utf-8\") as f:\n        json.dump({\"level_sizes\": level_sizes}, f, indent=2)\n\n\ndef parse_args() -> argparse.Namespace:\n    ap = argparse.ArgumentParser(\n        description=\"Build a joint code+paper Tree-of-Life from per-domain spans and nodes.\",\n    )\n    ap.add_argument(\"--code_spans\", type=str, required=True, help=\"Code spans JSONL file.\")\n    ap.add_argument(\"--code_nodes\", type=str, required=True, help=\"Code nodes JSONL file.\")\n    ap.add_argument(\"--paper_spans\", type=str, required=True, help=\"Paper spans JSONL file.\")\n    ap.add_argument(\"--paper_nodes\", type=str, required=True, help=\"Paper nodes JSONL file.\")\n\n    ap.add_argument(\n        \"--out_code_spans\",\n        type=str,\n        required=True,\n        help=\"Output path for code spans JSONL with joint node_path.\",\n    )\n    ap.add_argument(\n        \"--out_paper_spans\",\n        type=str,\n        required=True,\n        help=\"Output path for paper spans JSONL with joint node_path.\",\n    )\n    ap.add_argument(\n        \"--out_nodes\",\n        type=str,\n        required=True,\n        help=\"Output path for joint nodes JSONL.\",\n    )\n    ap.add_argument(\n        \"--out_level_sizes\",\n        type=str,\n        required=True,\n        help=\"Output path for joint level_sizes JSON helper JSON.\",\n    )\n\n    ap.add_argument(\n        \"--code_domain_name\",\n        type=str,\n        default=\"Code\",\n        help=\"Name for the code domain node at level 1.\",\n    )\n    ap.add_argument(\n        \"--paper_domain_name\",\n        type=str,\n        default=\"Papers\",\n        help=\"Name for the paper domain node at level 1.\",\n    )\n\n    return ap.parse_args()\n\n\ndef main() -> None:\n    args = parse_args()\n\n    code_nodes_path = Path(args.code_nodes)\n    paper_nodes_path = Path(args.paper_nodes)\n    code_spans_path = Path(args.code_spans)\n    paper_spans_path = Path(args.paper_spans)\n\n    if not code_nodes_path.is_file():\n        raise FileNotFoundError(f\"code_nodes does not exist or is not a file: {code_nodes_path}\")\n    if not paper_nodes_path.is_file():\n        raise FileNotFoundError(\n            f\"paper_nodes does not exist or is not a file: {paper_nodes_path}\"\n        )\n    if not code_spans_path.is_file():\n        raise FileNotFoundError(f\"code_spans does not exist or is not a file: {code_spans_path}\")\n    if not paper_spans_path.is_file():\n        raise FileNotFoundError(\n            f\"paper_spans does not exist or is not a file: {paper_spans_path}\"\n        )\n\n    code_nodes = _load_nodes(code_nodes_path)\n    paper_nodes = _load_nodes(paper_nodes_path)\n\n    joint_nodes, code_id_map, paper_id_map, level_counts = _build_joint_ontology(\n        code_nodes=code_nodes,\n        paper_nodes=paper_nodes,\n        code_domain_name=args.code_domain_name,\n        paper_domain_name=args.paper_domain_name,\n    )\n\n    # Rewrite spans into the joint ID space.\n    # Domain node IDs are always 1 (code) and 2 (paper) per _build_joint_ontology.\n    code_domain_id = 1\n    paper_domain_id = 2\n    code_spans_joint = _rewrite_spans(\n        code_spans_path,\n        domain_node_id=code_domain_id,\n        id_map=code_id_map,\n    )\n    paper_spans_joint = _rewrite_spans(\n        paper_spans_path,\n        domain_node_id=paper_domain_id,\n        id_map=paper_id_map,\n    )\n\n    out_code_spans_path = Path(args.out_code_spans)\n    out_paper_spans_path = Path(args.out_paper_spans)\n    out_nodes_path = Path(args.out_nodes)\n    out_level_sizes_path = Path(args.out_level_sizes)\n\n    out_code_spans_path.parent.mkdir(parents=True, exist_ok=True)\n    out_paper_spans_path.parent.mkdir(parents=True, exist_ok=True)\n    out_nodes_path.parent.mkdir(parents=True, exist_ok=True)\n    out_level_sizes_path.parent.mkdir(parents=True, exist_ok=True)\n\n    _write_spans(out_code_spans_path, code_spans_joint)\n    _write_spans(out_paper_spans_path, paper_spans_joint)\n    _write_nodes_jsonl(joint_nodes, out_nodes_path)\n    _write_level_sizes(level_counts, out_level_sizes_path)\n\n\nif __name__ == \"__main__\":\n    main()\n\n","source_hash":"6380e9c6adcc8b9f8253da0127930805dfd0f32ba8a4783de34a83eca5bfb7c1","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.build_joint_code_paper_tol.NodeRecord","uri":"program://TOLBERT/class/scripts.build_joint_code_paper_tol.NodeRecord#L121-L127","kind":"class","name":"NodeRecord","path":"scripts/build_joint_code_paper_tol.py","language":"python","start_line":121,"end_line":127,"context_start_line":101,"context_end_line":147,"code":"        --out_code_spans data/joint/code_spans_train.jsonl \\\n        --out_paper_spans data/joint/paper_spans_train.jsonl \\\n        --out_nodes data/joint/nodes.jsonl \\\n        --out_level_sizes data/joint/level_sizes.json\n\nYou can then train TOLBERT on the union of `out_code_spans` and\n`out_paper_spans` (e.g., via the `spans_files` list in your config) with\n`level_sizes` taken from `out_level_sizes`.\n\"\"\"\n\nfrom __future__ import annotations\n\nimport argparse\nimport json\nfrom dataclasses import dataclass\nfrom pathlib import Path\nfrom typing import Dict, Iterable, List, Tuple\n\n\n@dataclass\nclass NodeRecord:\n    node_id: int\n    level: int\n    type: str\n    parent_id: int | None\n    name: str\n    attributes: Dict[str, object]\n\n\ndef _load_nodes(path: Path) -> Dict[int, NodeRecord]:\n    nodes: Dict[int, NodeRecord] = {}\n    with path.open(\"r\", encoding=\"utf-8\") as f:\n        for line in f:\n            line = line.strip()\n            if not line:\n                continue\n            obj = json.loads(line)\n            nid = int(obj[\"node_id\"])\n            level = int(obj.get(\"level\", 0))\n            node_type = str(obj.get(\"type\", \"node\"))\n            parent_id = obj.get(\"parent_id\")\n            if parent_id is not None:\n                parent_id = int(parent_id)\n            name = str(obj.get(\"name\", f\"node_{nid}\"))\n            attributes = obj.get(\"attributes\") or {}\n            nodes[nid] = NodeRecord(\n                node_id=nid,","source_hash":"6380e9c6adcc8b9f8253da0127930805dfd0f32ba8a4783de34a83eca5bfb7c1","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.build_joint_code_paper_tol._load_nodes","uri":"program://TOLBERT/function/scripts.build_joint_code_paper_tol._load_nodes#L130-L154","kind":"function","name":"_load_nodes","path":"scripts/build_joint_code_paper_tol.py","language":"python","start_line":130,"end_line":154,"context_start_line":110,"context_end_line":174,"code":"\nfrom __future__ import annotations\n\nimport argparse\nimport json\nfrom dataclasses import dataclass\nfrom pathlib import Path\nfrom typing import Dict, Iterable, List, Tuple\n\n\n@dataclass\nclass NodeRecord:\n    node_id: int\n    level: int\n    type: str\n    parent_id: int | None\n    name: str\n    attributes: Dict[str, object]\n\n\ndef _load_nodes(path: Path) -> Dict[int, NodeRecord]:\n    nodes: Dict[int, NodeRecord] = {}\n    with path.open(\"r\", encoding=\"utf-8\") as f:\n        for line in f:\n            line = line.strip()\n            if not line:\n                continue\n            obj = json.loads(line)\n            nid = int(obj[\"node_id\"])\n            level = int(obj.get(\"level\", 0))\n            node_type = str(obj.get(\"type\", \"node\"))\n            parent_id = obj.get(\"parent_id\")\n            if parent_id is not None:\n                parent_id = int(parent_id)\n            name = str(obj.get(\"name\", f\"node_{nid}\"))\n            attributes = obj.get(\"attributes\") or {}\n            nodes[nid] = NodeRecord(\n                node_id=nid,\n                level=level,\n                type=node_type,\n                parent_id=parent_id,\n                name=name,\n                attributes=attributes,\n            )\n    return nodes\n\n\ndef _iter_spans(path: Path) -> Iterable[Dict[str, object]]:\n    with path.open(\"r\", encoding=\"utf-8\") as f:\n        for line in f:\n            line = line.strip()\n            if not line:\n                continue\n            yield json.loads(line)\n\n\ndef _write_spans(path: Path, records: Iterable[Dict[str, object]]) -> None:\n    with path.open(\"w\", encoding=\"utf-8\") as f:\n        for rec in records:\n            f.write(json.dumps(rec) + \"\\n\")\n\n\ndef _build_joint_ontology(\n    *,\n    code_nodes: Dict[int, NodeRecord],","source_hash":"6380e9c6adcc8b9f8253da0127930805dfd0f32ba8a4783de34a83eca5bfb7c1","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.build_joint_code_paper_tol._iter_spans","uri":"program://TOLBERT/function/scripts.build_joint_code_paper_tol._iter_spans#L157-L163","kind":"function","name":"_iter_spans","path":"scripts/build_joint_code_paper_tol.py","language":"python","start_line":157,"end_line":163,"context_start_line":137,"context_end_line":183,"code":"            obj = json.loads(line)\n            nid = int(obj[\"node_id\"])\n            level = int(obj.get(\"level\", 0))\n            node_type = str(obj.get(\"type\", \"node\"))\n            parent_id = obj.get(\"parent_id\")\n            if parent_id is not None:\n                parent_id = int(parent_id)\n            name = str(obj.get(\"name\", f\"node_{nid}\"))\n            attributes = obj.get(\"attributes\") or {}\n            nodes[nid] = NodeRecord(\n                node_id=nid,\n                level=level,\n                type=node_type,\n                parent_id=parent_id,\n                name=name,\n                attributes=attributes,\n            )\n    return nodes\n\n\ndef _iter_spans(path: Path) -> Iterable[Dict[str, object]]:\n    with path.open(\"r\", encoding=\"utf-8\") as f:\n        for line in f:\n            line = line.strip()\n            if not line:\n                continue\n            yield json.loads(line)\n\n\ndef _write_spans(path: Path, records: Iterable[Dict[str, object]]) -> None:\n    with path.open(\"w\", encoding=\"utf-8\") as f:\n        for rec in records:\n            f.write(json.dumps(rec) + \"\\n\")\n\n\ndef _build_joint_ontology(\n    *,\n    code_nodes: Dict[int, NodeRecord],\n    paper_nodes: Dict[int, NodeRecord],\n    code_domain_name: str = \"Code\",\n    paper_domain_name: str = \"Papers\",\n) -> Tuple[\n    Dict[int, NodeRecord],\n    Dict[int, int],\n    Dict[int, int],\n    Dict[int, int],\n]:","source_hash":"6380e9c6adcc8b9f8253da0127930805dfd0f32ba8a4783de34a83eca5bfb7c1","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.build_joint_code_paper_tol._write_spans","uri":"program://TOLBERT/function/scripts.build_joint_code_paper_tol._write_spans#L166-L169","kind":"function","name":"_write_spans","path":"scripts/build_joint_code_paper_tol.py","language":"python","start_line":166,"end_line":169,"context_start_line":146,"context_end_line":189,"code":"            nodes[nid] = NodeRecord(\n                node_id=nid,\n                level=level,\n                type=node_type,\n                parent_id=parent_id,\n                name=name,\n                attributes=attributes,\n            )\n    return nodes\n\n\ndef _iter_spans(path: Path) -> Iterable[Dict[str, object]]:\n    with path.open(\"r\", encoding=\"utf-8\") as f:\n        for line in f:\n            line = line.strip()\n            if not line:\n                continue\n            yield json.loads(line)\n\n\ndef _write_spans(path: Path, records: Iterable[Dict[str, object]]) -> None:\n    with path.open(\"w\", encoding=\"utf-8\") as f:\n        for rec in records:\n            f.write(json.dumps(rec) + \"\\n\")\n\n\ndef _build_joint_ontology(\n    *,\n    code_nodes: Dict[int, NodeRecord],\n    paper_nodes: Dict[int, NodeRecord],\n    code_domain_name: str = \"Code\",\n    paper_domain_name: str = \"Papers\",\n) -> Tuple[\n    Dict[int, NodeRecord],\n    Dict[int, int],\n    Dict[int, int],\n    Dict[int, int],\n]:\n    \"\"\"\n    Construct a joint ontology and return:\n\n    - joint_nodes: dict[new_id -> NodeRecord]\n    - code_id_map: mapping old_code_node_id -> new_global_node_id\n    - paper_id_map: mapping old_paper_node_id -> new_global_node_id","source_hash":"6380e9c6adcc8b9f8253da0127930805dfd0f32ba8a4783de34a83eca5bfb7c1","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.build_joint_code_paper_tol._build_joint_ontology","uri":"program://TOLBERT/function/scripts.build_joint_code_paper_tol._build_joint_ontology#L172-L297","kind":"function","name":"_build_joint_ontology","path":"scripts/build_joint_code_paper_tol.py","language":"python","start_line":172,"end_line":297,"context_start_line":152,"context_end_line":317,"code":"                attributes=attributes,\n            )\n    return nodes\n\n\ndef _iter_spans(path: Path) -> Iterable[Dict[str, object]]:\n    with path.open(\"r\", encoding=\"utf-8\") as f:\n        for line in f:\n            line = line.strip()\n            if not line:\n                continue\n            yield json.loads(line)\n\n\ndef _write_spans(path: Path, records: Iterable[Dict[str, object]]) -> None:\n    with path.open(\"w\", encoding=\"utf-8\") as f:\n        for rec in records:\n            f.write(json.dumps(rec) + \"\\n\")\n\n\ndef _build_joint_ontology(\n    *,\n    code_nodes: Dict[int, NodeRecord],\n    paper_nodes: Dict[int, NodeRecord],\n    code_domain_name: str = \"Code\",\n    paper_domain_name: str = \"Papers\",\n) -> Tuple[\n    Dict[int, NodeRecord],\n    Dict[int, int],\n    Dict[int, int],\n    Dict[int, int],\n]:\n    \"\"\"\n    Construct a joint ontology and return:\n\n    - joint_nodes: dict[new_id -> NodeRecord]\n    - code_id_map: mapping old_code_node_id -> new_global_node_id\n    - paper_id_map: mapping old_paper_node_id -> new_global_node_id\n    - level_counts: mapping level -> number of nodes at that level (excluding root)\n\n    Strategy:\n      - Create a fresh root (id 0).\n      - Create two domain nodes at level 1: Code, Papers.\n      - For each original ontology:\n          * Drop its root node (level 0).\n          * Shift all other nodes one level deeper (level' = level + 1).\n          * Rewire parents so that:\n              - old parent == 0  → new parent = corresponding domain node id\n              - otherwise        → new parent = mapped parent id\n    \"\"\"\n    joint_nodes: Dict[int, NodeRecord] = {}\n    level_counts: Dict[int, int] = {}\n\n    # Root (level 0)\n    root_id = 0\n    joint_nodes[root_id] = NodeRecord(\n        node_id=root_id,\n        level=0,\n        type=\"root\",\n        parent_id=None,\n        name=\"Root\",\n        attributes={},\n    )\n\n    next_id = 1\n\n    # Domain nodes at level 1\n    code_domain_id = next_id\n    next_id += 1\n    paper_domain_id = next_id\n    next_id += 1\n\n    joint_nodes[code_domain_id] = NodeRecord(\n        node_id=code_domain_id,\n        level=1,\n        type=\"domain\",\n        parent_id=root_id,\n        name=code_domain_name,\n        attributes={\"source\": \"code\"},\n    )\n    joint_nodes[paper_domain_id] = NodeRecord(\n        node_id=paper_domain_id,\n        level=1,\n        type=\"domain\",\n        parent_id=root_id,\n        name=paper_domain_name,\n        attributes={\"source\": \"paper\"},\n    )\n    level_counts[1] = 2\n\n    code_id_map: Dict[int, int] = {}\n    paper_id_map: Dict[int, int] = {}\n\n    def _remap_domain(\n        *,\n        src_nodes: Dict[int, NodeRecord],\n        domain_node_id: int,\n        is_code: bool,\n    ) -> Dict[int, int]:\n        nonlocal next_id\n        id_map: Dict[int, int] = {}\n\n        # Sort by (level, node_id) for stable assignment.\n        for old_id, rec in sorted(src_nodes.items(), key=lambda kv: (kv[1].level, kv[0])):\n            if rec.level == 0:\n                # Skip local root; we replace it with shared root + domain nodes.\n                continue\n\n            new_level = rec.level + 1  # shift deeper by one level\n            new_id = next_id\n            next_id += 1\n\n            # Determine parent in joint space.\n            if rec.parent_id is None or rec.parent_id == 0:\n                new_parent = domain_node_id\n            else:\n                if rec.parent_id not in id_map:\n                    raise ValueError(\n                        f\"Parent node_id {rec.parent_id} for node {old_id} has not been remapped yet.\"\n                    )\n                new_parent = id_map[rec.parent_id]\n\n            # Merge attributes and tag source.\n            attrs = dict(rec.attributes or {})\n            attrs.setdefault(\"source\", \"code\" if is_code else \"paper\")\n\n            joint_nodes[new_id] = NodeRecord(\n                node_id=new_id,\n                level=new_level,\n                type=rec.type,\n                parent_id=new_parent,\n                name=rec.name,\n                attributes=attrs,\n            )\n\n            id_map[old_id] = new_id\n            level_counts[new_level] = level_counts.get(new_level, 0) + 1\n\n        return id_map\n\n    code_id_map = _remap_domain(src_nodes=code_nodes, domain_node_id=code_domain_id, is_code=True)\n    paper_id_map = _remap_domain(\n        src_nodes=paper_nodes, domain_node_id=paper_domain_id, is_code=False\n    )\n\n    return joint_nodes, code_id_map, paper_id_map, level_counts\n\n\ndef _rewrite_spans(\n    spans_path: Path,\n    *,\n    domain_node_id: int,\n    id_map: Dict[int, int],\n) -> List[Dict[str, object]]:\n    \"\"\"\n    Rewrite node_path for spans from a single domain into the joint ID space.\n    \"\"\"\n    out: List[Dict[str, object]] = []\n    root_id = 0\n\n    for rec in _iter_spans(spans_path):\n        old_path = rec.get(\"node_path\")\n        if not isinstance(old_path, list) or not old_path:\n            # Leave record untouched if it lacks a path.\n            out.append(rec)\n            continue","source_hash":"6380e9c6adcc8b9f8253da0127930805dfd0f32ba8a4783de34a83eca5bfb7c1","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.build_joint_code_paper_tol._rewrite_spans","uri":"program://TOLBERT/function/scripts.build_joint_code_paper_tol._rewrite_spans#L300-L338","kind":"function","name":"_rewrite_spans","path":"scripts/build_joint_code_paper_tol.py","language":"python","start_line":300,"end_line":338,"context_start_line":280,"context_end_line":358,"code":"                level=new_level,\n                type=rec.type,\n                parent_id=new_parent,\n                name=rec.name,\n                attributes=attrs,\n            )\n\n            id_map[old_id] = new_id\n            level_counts[new_level] = level_counts.get(new_level, 0) + 1\n\n        return id_map\n\n    code_id_map = _remap_domain(src_nodes=code_nodes, domain_node_id=code_domain_id, is_code=True)\n    paper_id_map = _remap_domain(\n        src_nodes=paper_nodes, domain_node_id=paper_domain_id, is_code=False\n    )\n\n    return joint_nodes, code_id_map, paper_id_map, level_counts\n\n\ndef _rewrite_spans(\n    spans_path: Path,\n    *,\n    domain_node_id: int,\n    id_map: Dict[int, int],\n) -> List[Dict[str, object]]:\n    \"\"\"\n    Rewrite node_path for spans from a single domain into the joint ID space.\n    \"\"\"\n    out: List[Dict[str, object]] = []\n    root_id = 0\n\n    for rec in _iter_spans(spans_path):\n        old_path = rec.get(\"node_path\")\n        if not isinstance(old_path, list) or not old_path:\n            # Leave record untouched if it lacks a path.\n            out.append(rec)\n            continue\n\n        # Old paths are expected to be [root_id, ... local node ids ...].\n        # We drop the old root and map each remaining id via id_map.\n        new_path: List[int] = [root_id, domain_node_id]\n        for old_id in old_path[1:]:\n            new_id = id_map.get(int(old_id))\n            if new_id is None:\n                # If we don't know this node, skip it; better a shorter path\n                # than a broken one.\n                continue\n            new_path.append(new_id)\n\n        # Ensure at least [root, domain] is present.\n        if len(new_path) < 2:\n            new_path = [root_id, domain_node_id]\n\n        rec = dict(rec)\n        rec[\"node_path\"] = new_path\n        out.append(rec)\n\n    return out\n\n\ndef _write_nodes_jsonl(nodes: Dict[int, NodeRecord], out_path: Path) -> None:\n    with out_path.open(\"w\", encoding=\"utf-8\") as f:\n        for nid, rec in sorted(nodes.items(), key=lambda kv: kv[0]):\n            f.write(\n                json.dumps(\n                    {\n                        \"node_id\": rec.node_id,\n                        \"level\": rec.level,\n                        \"type\": rec.type,\n                        \"parent_id\": rec.parent_id,\n                        \"name\": rec.name,\n                        \"attributes\": rec.attributes,\n                    }\n                )\n                + \"\\n\"\n            )\n\n","source_hash":"6380e9c6adcc8b9f8253da0127930805dfd0f32ba8a4783de34a83eca5bfb7c1","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.build_joint_code_paper_tol._write_nodes_jsonl","uri":"program://TOLBERT/function/scripts.build_joint_code_paper_tol._write_nodes_jsonl#L341-L356","kind":"function","name":"_write_nodes_jsonl","path":"scripts/build_joint_code_paper_tol.py","language":"python","start_line":341,"end_line":356,"context_start_line":321,"context_end_line":376,"code":"        new_path: List[int] = [root_id, domain_node_id]\n        for old_id in old_path[1:]:\n            new_id = id_map.get(int(old_id))\n            if new_id is None:\n                # If we don't know this node, skip it; better a shorter path\n                # than a broken one.\n                continue\n            new_path.append(new_id)\n\n        # Ensure at least [root, domain] is present.\n        if len(new_path) < 2:\n            new_path = [root_id, domain_node_id]\n\n        rec = dict(rec)\n        rec[\"node_path\"] = new_path\n        out.append(rec)\n\n    return out\n\n\ndef _write_nodes_jsonl(nodes: Dict[int, NodeRecord], out_path: Path) -> None:\n    with out_path.open(\"w\", encoding=\"utf-8\") as f:\n        for nid, rec in sorted(nodes.items(), key=lambda kv: kv[0]):\n            f.write(\n                json.dumps(\n                    {\n                        \"node_id\": rec.node_id,\n                        \"level\": rec.level,\n                        \"type\": rec.type,\n                        \"parent_id\": rec.parent_id,\n                        \"name\": rec.name,\n                        \"attributes\": rec.attributes,\n                    }\n                )\n                + \"\\n\"\n            )\n\n\ndef _write_level_sizes(level_counts: Dict[int, int], out_path: Path) -> None:\n    # Exclude root (level 0) from level_sizes; TOLBERT heads start at level 1.\n    level_sizes = {level: count for level, count in level_counts.items() if level > 0}\n    with out_path.open(\"w\", encoding=\"utf-8\") as f:\n        json.dump({\"level_sizes\": level_sizes}, f, indent=2)\n\n\ndef parse_args() -> argparse.Namespace:\n    ap = argparse.ArgumentParser(\n        description=\"Build a joint code+paper Tree-of-Life from per-domain spans and nodes.\",\n    )\n    ap.add_argument(\"--code_spans\", type=str, required=True, help=\"Code spans JSONL file.\")\n    ap.add_argument(\"--code_nodes\", type=str, required=True, help=\"Code nodes JSONL file.\")\n    ap.add_argument(\"--paper_spans\", type=str, required=True, help=\"Paper spans JSONL file.\")\n    ap.add_argument(\"--paper_nodes\", type=str, required=True, help=\"Paper nodes JSONL file.\")\n\n    ap.add_argument(\n        \"--out_code_spans\",","source_hash":"6380e9c6adcc8b9f8253da0127930805dfd0f32ba8a4783de34a83eca5bfb7c1","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.build_joint_code_paper_tol._write_level_sizes","uri":"program://TOLBERT/function/scripts.build_joint_code_paper_tol._write_level_sizes#L359-L363","kind":"function","name":"_write_level_sizes","path":"scripts/build_joint_code_paper_tol.py","language":"python","start_line":359,"end_line":363,"context_start_line":339,"context_end_line":383,"code":"\n\ndef _write_nodes_jsonl(nodes: Dict[int, NodeRecord], out_path: Path) -> None:\n    with out_path.open(\"w\", encoding=\"utf-8\") as f:\n        for nid, rec in sorted(nodes.items(), key=lambda kv: kv[0]):\n            f.write(\n                json.dumps(\n                    {\n                        \"node_id\": rec.node_id,\n                        \"level\": rec.level,\n                        \"type\": rec.type,\n                        \"parent_id\": rec.parent_id,\n                        \"name\": rec.name,\n                        \"attributes\": rec.attributes,\n                    }\n                )\n                + \"\\n\"\n            )\n\n\ndef _write_level_sizes(level_counts: Dict[int, int], out_path: Path) -> None:\n    # Exclude root (level 0) from level_sizes; TOLBERT heads start at level 1.\n    level_sizes = {level: count for level, count in level_counts.items() if level > 0}\n    with out_path.open(\"w\", encoding=\"utf-8\") as f:\n        json.dump({\"level_sizes\": level_sizes}, f, indent=2)\n\n\ndef parse_args() -> argparse.Namespace:\n    ap = argparse.ArgumentParser(\n        description=\"Build a joint code+paper Tree-of-Life from per-domain spans and nodes.\",\n    )\n    ap.add_argument(\"--code_spans\", type=str, required=True, help=\"Code spans JSONL file.\")\n    ap.add_argument(\"--code_nodes\", type=str, required=True, help=\"Code nodes JSONL file.\")\n    ap.add_argument(\"--paper_spans\", type=str, required=True, help=\"Paper spans JSONL file.\")\n    ap.add_argument(\"--paper_nodes\", type=str, required=True, help=\"Paper nodes JSONL file.\")\n\n    ap.add_argument(\n        \"--out_code_spans\",\n        type=str,\n        required=True,\n        help=\"Output path for code spans JSONL with joint node_path.\",\n    )\n    ap.add_argument(\n        \"--out_paper_spans\",\n        type=str,","source_hash":"6380e9c6adcc8b9f8253da0127930805dfd0f32ba8a4783de34a83eca5bfb7c1","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.build_joint_code_paper_tol.parse_args","uri":"program://TOLBERT/function/scripts.build_joint_code_paper_tol.parse_args#L366-L413","kind":"function","name":"parse_args","path":"scripts/build_joint_code_paper_tol.py","language":"python","start_line":366,"end_line":413,"context_start_line":346,"context_end_line":433,"code":"                    {\n                        \"node_id\": rec.node_id,\n                        \"level\": rec.level,\n                        \"type\": rec.type,\n                        \"parent_id\": rec.parent_id,\n                        \"name\": rec.name,\n                        \"attributes\": rec.attributes,\n                    }\n                )\n                + \"\\n\"\n            )\n\n\ndef _write_level_sizes(level_counts: Dict[int, int], out_path: Path) -> None:\n    # Exclude root (level 0) from level_sizes; TOLBERT heads start at level 1.\n    level_sizes = {level: count for level, count in level_counts.items() if level > 0}\n    with out_path.open(\"w\", encoding=\"utf-8\") as f:\n        json.dump({\"level_sizes\": level_sizes}, f, indent=2)\n\n\ndef parse_args() -> argparse.Namespace:\n    ap = argparse.ArgumentParser(\n        description=\"Build a joint code+paper Tree-of-Life from per-domain spans and nodes.\",\n    )\n    ap.add_argument(\"--code_spans\", type=str, required=True, help=\"Code spans JSONL file.\")\n    ap.add_argument(\"--code_nodes\", type=str, required=True, help=\"Code nodes JSONL file.\")\n    ap.add_argument(\"--paper_spans\", type=str, required=True, help=\"Paper spans JSONL file.\")\n    ap.add_argument(\"--paper_nodes\", type=str, required=True, help=\"Paper nodes JSONL file.\")\n\n    ap.add_argument(\n        \"--out_code_spans\",\n        type=str,\n        required=True,\n        help=\"Output path for code spans JSONL with joint node_path.\",\n    )\n    ap.add_argument(\n        \"--out_paper_spans\",\n        type=str,\n        required=True,\n        help=\"Output path for paper spans JSONL with joint node_path.\",\n    )\n    ap.add_argument(\n        \"--out_nodes\",\n        type=str,\n        required=True,\n        help=\"Output path for joint nodes JSONL.\",\n    )\n    ap.add_argument(\n        \"--out_level_sizes\",\n        type=str,\n        required=True,\n        help=\"Output path for joint level_sizes JSON helper JSON.\",\n    )\n\n    ap.add_argument(\n        \"--code_domain_name\",\n        type=str,\n        default=\"Code\",\n        help=\"Name for the code domain node at level 1.\",\n    )\n    ap.add_argument(\n        \"--paper_domain_name\",\n        type=str,\n        default=\"Papers\",\n        help=\"Name for the paper domain node at level 1.\",\n    )\n\n    return ap.parse_args()\n\n\ndef main() -> None:\n    args = parse_args()\n\n    code_nodes_path = Path(args.code_nodes)\n    paper_nodes_path = Path(args.paper_nodes)\n    code_spans_path = Path(args.code_spans)\n    paper_spans_path = Path(args.paper_spans)\n\n    if not code_nodes_path.is_file():\n        raise FileNotFoundError(f\"code_nodes does not exist or is not a file: {code_nodes_path}\")\n    if not paper_nodes_path.is_file():\n        raise FileNotFoundError(\n            f\"paper_nodes does not exist or is not a file: {paper_nodes_path}\"\n        )\n    if not code_spans_path.is_file():\n        raise FileNotFoundError(f\"code_spans does not exist or is not a file: {code_spans_path}\")\n    if not paper_spans_path.is_file():\n        raise FileNotFoundError(","source_hash":"6380e9c6adcc8b9f8253da0127930805dfd0f32ba8a4783de34a83eca5bfb7c1","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.build_joint_code_paper_tol.main","uri":"program://TOLBERT/function/scripts.build_joint_code_paper_tol.main#L416-L475","kind":"function","name":"main","path":"scripts/build_joint_code_paper_tol.py","language":"python","start_line":416,"end_line":475,"context_start_line":396,"context_end_line":481,"code":"        required=True,\n        help=\"Output path for joint level_sizes JSON helper JSON.\",\n    )\n\n    ap.add_argument(\n        \"--code_domain_name\",\n        type=str,\n        default=\"Code\",\n        help=\"Name for the code domain node at level 1.\",\n    )\n    ap.add_argument(\n        \"--paper_domain_name\",\n        type=str,\n        default=\"Papers\",\n        help=\"Name for the paper domain node at level 1.\",\n    )\n\n    return ap.parse_args()\n\n\ndef main() -> None:\n    args = parse_args()\n\n    code_nodes_path = Path(args.code_nodes)\n    paper_nodes_path = Path(args.paper_nodes)\n    code_spans_path = Path(args.code_spans)\n    paper_spans_path = Path(args.paper_spans)\n\n    if not code_nodes_path.is_file():\n        raise FileNotFoundError(f\"code_nodes does not exist or is not a file: {code_nodes_path}\")\n    if not paper_nodes_path.is_file():\n        raise FileNotFoundError(\n            f\"paper_nodes does not exist or is not a file: {paper_nodes_path}\"\n        )\n    if not code_spans_path.is_file():\n        raise FileNotFoundError(f\"code_spans does not exist or is not a file: {code_spans_path}\")\n    if not paper_spans_path.is_file():\n        raise FileNotFoundError(\n            f\"paper_spans does not exist or is not a file: {paper_spans_path}\"\n        )\n\n    code_nodes = _load_nodes(code_nodes_path)\n    paper_nodes = _load_nodes(paper_nodes_path)\n\n    joint_nodes, code_id_map, paper_id_map, level_counts = _build_joint_ontology(\n        code_nodes=code_nodes,\n        paper_nodes=paper_nodes,\n        code_domain_name=args.code_domain_name,\n        paper_domain_name=args.paper_domain_name,\n    )\n\n    # Rewrite spans into the joint ID space.\n    # Domain node IDs are always 1 (code) and 2 (paper) per _build_joint_ontology.\n    code_domain_id = 1\n    paper_domain_id = 2\n    code_spans_joint = _rewrite_spans(\n        code_spans_path,\n        domain_node_id=code_domain_id,\n        id_map=code_id_map,\n    )\n    paper_spans_joint = _rewrite_spans(\n        paper_spans_path,\n        domain_node_id=paper_domain_id,\n        id_map=paper_id_map,\n    )\n\n    out_code_spans_path = Path(args.out_code_spans)\n    out_paper_spans_path = Path(args.out_paper_spans)\n    out_nodes_path = Path(args.out_nodes)\n    out_level_sizes_path = Path(args.out_level_sizes)\n\n    out_code_spans_path.parent.mkdir(parents=True, exist_ok=True)\n    out_paper_spans_path.parent.mkdir(parents=True, exist_ok=True)\n    out_nodes_path.parent.mkdir(parents=True, exist_ok=True)\n    out_level_sizes_path.parent.mkdir(parents=True, exist_ok=True)\n\n    _write_spans(out_code_spans_path, code_spans_joint)\n    _write_spans(out_paper_spans_path, paper_spans_joint)\n    _write_nodes_jsonl(joint_nodes, out_nodes_path)\n    _write_level_sizes(level_counts, out_level_sizes_path)\n\n\nif __name__ == \"__main__\":\n    main()\n\n","source_hash":"6380e9c6adcc8b9f8253da0127930805dfd0f32ba8a4783de34a83eca5bfb7c1","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.build_joint_code_paper_tol._remap_domain","uri":"program://TOLBERT/function/scripts.build_joint_code_paper_tol._remap_domain#L245-L290","kind":"function","name":"_remap_domain","path":"scripts/build_joint_code_paper_tol.py","language":"python","start_line":245,"end_line":290,"context_start_line":225,"context_end_line":310,"code":"        node_id=code_domain_id,\n        level=1,\n        type=\"domain\",\n        parent_id=root_id,\n        name=code_domain_name,\n        attributes={\"source\": \"code\"},\n    )\n    joint_nodes[paper_domain_id] = NodeRecord(\n        node_id=paper_domain_id,\n        level=1,\n        type=\"domain\",\n        parent_id=root_id,\n        name=paper_domain_name,\n        attributes={\"source\": \"paper\"},\n    )\n    level_counts[1] = 2\n\n    code_id_map: Dict[int, int] = {}\n    paper_id_map: Dict[int, int] = {}\n\n    def _remap_domain(\n        *,\n        src_nodes: Dict[int, NodeRecord],\n        domain_node_id: int,\n        is_code: bool,\n    ) -> Dict[int, int]:\n        nonlocal next_id\n        id_map: Dict[int, int] = {}\n\n        # Sort by (level, node_id) for stable assignment.\n        for old_id, rec in sorted(src_nodes.items(), key=lambda kv: (kv[1].level, kv[0])):\n            if rec.level == 0:\n                # Skip local root; we replace it with shared root + domain nodes.\n                continue\n\n            new_level = rec.level + 1  # shift deeper by one level\n            new_id = next_id\n            next_id += 1\n\n            # Determine parent in joint space.\n            if rec.parent_id is None or rec.parent_id == 0:\n                new_parent = domain_node_id\n            else:\n                if rec.parent_id not in id_map:\n                    raise ValueError(\n                        f\"Parent node_id {rec.parent_id} for node {old_id} has not been remapped yet.\"\n                    )\n                new_parent = id_map[rec.parent_id]\n\n            # Merge attributes and tag source.\n            attrs = dict(rec.attributes or {})\n            attrs.setdefault(\"source\", \"code\" if is_code else \"paper\")\n\n            joint_nodes[new_id] = NodeRecord(\n                node_id=new_id,\n                level=new_level,\n                type=rec.type,\n                parent_id=new_parent,\n                name=rec.name,\n                attributes=attrs,\n            )\n\n            id_map[old_id] = new_id\n            level_counts[new_level] = level_counts.get(new_level, 0) + 1\n\n        return id_map\n\n    code_id_map = _remap_domain(src_nodes=code_nodes, domain_node_id=code_domain_id, is_code=True)\n    paper_id_map = _remap_domain(\n        src_nodes=paper_nodes, domain_node_id=paper_domain_id, is_code=False\n    )\n\n    return joint_nodes, code_id_map, paper_id_map, level_counts\n\n\ndef _rewrite_spans(\n    spans_path: Path,\n    *,\n    domain_node_id: int,\n    id_map: Dict[int, int],\n) -> List[Dict[str, object]]:\n    \"\"\"\n    Rewrite node_path for spans from a single domain into the joint ID space.\n    \"\"\"\n    out: List[Dict[str, object]] = []\n    root_id = 0","source_hash":"6380e9c6adcc8b9f8253da0127930805dfd0f32ba8a4783de34a83eca5bfb7c1","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.eval_flat_baseline","uri":"program://TOLBERT/module/scripts.eval_flat_baseline#L1-L207","kind":"module","name":"scripts.eval_flat_baseline","path":"scripts/eval_flat_baseline.py","language":"python","start_line":1,"end_line":207,"context_start_line":1,"context_end_line":207,"code":"\"\"\"\nEvaluate a flat (leaf-level) baseline classifier on a labeled spans_file.\n\nThis computes standard leaf-level accuracy for the \"BERT-flat\" style baselines\ntrained with scripts/train_flat_baseline.py. It does NOT reconstruct full\nhierarchical paths; it simply evaluates how well the model predicts the leaf\nnode id (last element of node_path).\n\nExample:\n\n  python -m scripts.eval_flat_baseline \\\\\n      --config configs/codehierarchy_example.yaml \\\\\n      --checkpoint-dir checkpoints/codehierarchy_bert_flat \\\\\n      --spans-file /data/tolbert/data/codehierarchy/spans_test.jsonl\n\"\"\"\n\nfrom __future__ import annotations\n\nimport argparse\nimport json\nfrom pathlib import Path\nfrom typing import Any, Dict, List\n\nimport torch\nfrom torch.utils.data import DataLoader, Dataset\nfrom transformers import (\n    AutoModelForSequenceClassification,\n    AutoTokenizer,\n    PreTrainedTokenizerBase,\n)\nimport os\n\nfrom tolbert.config import load_tolbert_config\n\n\nclass FlatLeafEvalDataset(Dataset):\n    \"\"\"\n    Identical to FlatLeafDataset but without any training-specific behavior.\n    \"\"\"\n\n    def __init__(\n        self,\n        spans_file: str,\n        tokenizer: PreTrainedTokenizerBase,\n        max_length: int = 256,\n    ) -> None:\n        self.spans_file = spans_file\n        self.tokenizer = tokenizer\n        self.max_length = max_length\n\n        self._records: List[Dict[str, Any]] = []\n        with open(spans_file, \"r\", encoding=\"utf-8\") as f:\n            for line in f:\n                line = line.strip()\n                if not line:\n                    continue\n                obj = json.loads(line)\n                if \"text\" not in obj or \"node_path\" not in obj:\n                    continue\n                if not obj[\"node_path\"]:\n                    continue\n                self._records.append(obj)\n\n    def __len__(self) -> int:\n        return len(self._records)\n\n    def _tokenize(self, text: str) -> Dict[str, torch.Tensor]:\n        enc = self.tokenizer(\n            text,\n            return_tensors=\"pt\",\n            truncation=True,\n            padding=\"max_length\",\n            max_length=self.max_length,\n        )\n        return {k: v.squeeze(0) for k, v in enc.items()}\n\n    def __getitem__(self, idx: int) -> Dict[str, Any]:\n        rec = self._records[idx]\n        tokens = self._tokenize(rec[\"text\"])\n        input_ids = tokens[\"input_ids\"]\n        attention_mask = tokens.get(\"attention_mask\", torch.ones_like(input_ids))\n        node_path: List[int] = rec[\"node_path\"]\n        label = int(node_path[-1])\n        return {\n            \"input_ids\": input_ids,\n            \"attention_mask\": attention_mask,\n            \"labels\": torch.tensor(label, dtype=torch.long),\n        }\n\n\ndef collate_flat_eval_batch(batch: List[Dict[str, Any]]) -> Dict[str, Any]:\n    input_ids = torch.stack([b[\"input_ids\"] for b in batch], dim=0)\n    attention_mask = torch.stack([b[\"attention_mask\"] for b in batch], dim=0)\n    labels = torch.stack([b[\"labels\"] for b in batch], dim=0)\n    return {\n        \"input_ids\": input_ids,\n        \"attention_mask\": attention_mask,\n        \"labels\": labels,\n    }\n\n\ndef parse_args() -> argparse.Namespace:\n    ap = argparse.ArgumentParser(description=\"Evaluate flat (leaf-level) baseline classifier.\")\n    ap.add_argument(\n        \"--config\",\n        type=str,\n        required=True,\n        help=\"Config with max_length / batch_size; level_sizes is used to sanity-check num_labels.\",\n    )\n    ap.add_argument(\n        \"--checkpoint-dir\",\n        type=str,\n        required=True,\n        help=\"Directory containing the fine-tuned baseline model (save_pretrained output).\",\n    )\n    ap.add_argument(\n        \"--spans-file\",\n        type=str,\n        required=True,\n        help=\"Labeled spans JSONL file for evaluation (e.g., *_test.jsonl).\",\n    )\n    ap.add_argument(\n        \"--device\",\n        type=str,\n        default=\"cuda\" if torch.cuda.is_available() else \"cpu\",\n        help=\"Device to use.\",\n    )\n    return ap.parse_args()\n\n\ndef main() -> None:\n    args = parse_args()\n    cfg = load_tolbert_config(args.config)\n\n    device = torch.device(args.device)\n\n    spans_path = Path(args.spans_file)\n    if not spans_path.exists():\n        raise FileNotFoundError(f\"spans_file not found: {spans_path}\")\n\n    checkpoint_dir = Path(args.checkpoint_dir)\n    if not checkpoint_dir.exists():\n        raise FileNotFoundError(f\"checkpoint_dir not found: {checkpoint_dir}\")\n\n    # Leaf class count from config (for sanity checking).\n    level_sizes: Dict[int, int] = cfg[\"level_sizes\"]\n    leaf_level = max(level_sizes.keys())\n    num_labels_expected = level_sizes[leaf_level]\n\n    tokenizer = AutoTokenizer.from_pretrained(\n        checkpoint_dir,\n        cache_dir=\"/data/checkpoints/\",  # noqa: E501\n    )\n    model = AutoModelForSequenceClassification.from_pretrained(\n        checkpoint_dir,\n        cache_dir=\"/data/checkpoints/\",  # noqa: E501\n    )\n    if model.num_labels != num_labels_expected:\n        print(\n            f\"Warning: model.num_labels={model.num_labels} \"\n            f\"but config expects {num_labels_expected} leaf classes.\"\n        )\n\n    model.to(device)\n    model.eval()\n\n    dataset = FlatLeafEvalDataset(\n        spans_file=str(spans_path),\n        tokenizer=tokenizer,\n        max_length=cfg.get(\"max_length\", 256),\n    )\n    dataloader = DataLoader(\n        dataset,\n        batch_size=cfg.get(\"batch_size\", 64),\n        shuffle=False,\n        num_workers=cfg.get(\"num_workers\", 0),\n        collate_fn=collate_flat_eval_batch,\n    )\n\n    correct = 0\n    total = 0\n\n    with torch.no_grad():\n        for batch in dataloader:\n            input_ids = batch[\"input_ids\"].to(device)\n            attention_mask = batch[\"attention_mask\"].to(device)\n            labels = batch[\"labels\"].to(device)\n\n            outputs = model(\n                input_ids=input_ids,\n                attention_mask=attention_mask,\n            )\n            logits = outputs.logits\n            preds = logits.argmax(dim=-1)\n\n            correct += (preds == labels).sum().item()\n            total += labels.size(0)\n\n    acc = correct / max(1, total)\n    print(\"=== Flat Leaf-Level Classification Evaluation ===\")\n    print(f\"Accuracy (leaf node id): {acc:.4f} (n={total})\")\n\n\nif __name__ == \"__main__\":\n    main()\n\n","source_hash":"dc5374f19c16a413028a1321089704a4edd39c70fe6acf08a697c6dfcb7d9ffb","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.eval_flat_baseline.FlatLeafEvalDataset","uri":"program://TOLBERT/class/scripts.eval_flat_baseline.FlatLeafEvalDataset#L36-L88","kind":"class","name":"FlatLeafEvalDataset","path":"scripts/eval_flat_baseline.py","language":"python","start_line":36,"end_line":88,"context_start_line":16,"context_end_line":108,"code":"\nfrom __future__ import annotations\n\nimport argparse\nimport json\nfrom pathlib import Path\nfrom typing import Any, Dict, List\n\nimport torch\nfrom torch.utils.data import DataLoader, Dataset\nfrom transformers import (\n    AutoModelForSequenceClassification,\n    AutoTokenizer,\n    PreTrainedTokenizerBase,\n)\nimport os\n\nfrom tolbert.config import load_tolbert_config\n\n\nclass FlatLeafEvalDataset(Dataset):\n    \"\"\"\n    Identical to FlatLeafDataset but without any training-specific behavior.\n    \"\"\"\n\n    def __init__(\n        self,\n        spans_file: str,\n        tokenizer: PreTrainedTokenizerBase,\n        max_length: int = 256,\n    ) -> None:\n        self.spans_file = spans_file\n        self.tokenizer = tokenizer\n        self.max_length = max_length\n\n        self._records: List[Dict[str, Any]] = []\n        with open(spans_file, \"r\", encoding=\"utf-8\") as f:\n            for line in f:\n                line = line.strip()\n                if not line:\n                    continue\n                obj = json.loads(line)\n                if \"text\" not in obj or \"node_path\" not in obj:\n                    continue\n                if not obj[\"node_path\"]:\n                    continue\n                self._records.append(obj)\n\n    def __len__(self) -> int:\n        return len(self._records)\n\n    def _tokenize(self, text: str) -> Dict[str, torch.Tensor]:\n        enc = self.tokenizer(\n            text,\n            return_tensors=\"pt\",\n            truncation=True,\n            padding=\"max_length\",\n            max_length=self.max_length,\n        )\n        return {k: v.squeeze(0) for k, v in enc.items()}\n\n    def __getitem__(self, idx: int) -> Dict[str, Any]:\n        rec = self._records[idx]\n        tokens = self._tokenize(rec[\"text\"])\n        input_ids = tokens[\"input_ids\"]\n        attention_mask = tokens.get(\"attention_mask\", torch.ones_like(input_ids))\n        node_path: List[int] = rec[\"node_path\"]\n        label = int(node_path[-1])\n        return {\n            \"input_ids\": input_ids,\n            \"attention_mask\": attention_mask,\n            \"labels\": torch.tensor(label, dtype=torch.long),\n        }\n\n\ndef collate_flat_eval_batch(batch: List[Dict[str, Any]]) -> Dict[str, Any]:\n    input_ids = torch.stack([b[\"input_ids\"] for b in batch], dim=0)\n    attention_mask = torch.stack([b[\"attention_mask\"] for b in batch], dim=0)\n    labels = torch.stack([b[\"labels\"] for b in batch], dim=0)\n    return {\n        \"input_ids\": input_ids,\n        \"attention_mask\": attention_mask,\n        \"labels\": labels,\n    }\n\n\ndef parse_args() -> argparse.Namespace:\n    ap = argparse.ArgumentParser(description=\"Evaluate flat (leaf-level) baseline classifier.\")\n    ap.add_argument(\n        \"--config\",\n        type=str,\n        required=True,\n        help=\"Config with max_length / batch_size; level_sizes is used to sanity-check num_labels.\",","source_hash":"dc5374f19c16a413028a1321089704a4edd39c70fe6acf08a697c6dfcb7d9ffb","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.eval_flat_baseline.collate_flat_eval_batch","uri":"program://TOLBERT/function/scripts.eval_flat_baseline.collate_flat_eval_batch#L91-L99","kind":"function","name":"collate_flat_eval_batch","path":"scripts/eval_flat_baseline.py","language":"python","start_line":91,"end_line":99,"context_start_line":71,"context_end_line":119,"code":"            truncation=True,\n            padding=\"max_length\",\n            max_length=self.max_length,\n        )\n        return {k: v.squeeze(0) for k, v in enc.items()}\n\n    def __getitem__(self, idx: int) -> Dict[str, Any]:\n        rec = self._records[idx]\n        tokens = self._tokenize(rec[\"text\"])\n        input_ids = tokens[\"input_ids\"]\n        attention_mask = tokens.get(\"attention_mask\", torch.ones_like(input_ids))\n        node_path: List[int] = rec[\"node_path\"]\n        label = int(node_path[-1])\n        return {\n            \"input_ids\": input_ids,\n            \"attention_mask\": attention_mask,\n            \"labels\": torch.tensor(label, dtype=torch.long),\n        }\n\n\ndef collate_flat_eval_batch(batch: List[Dict[str, Any]]) -> Dict[str, Any]:\n    input_ids = torch.stack([b[\"input_ids\"] for b in batch], dim=0)\n    attention_mask = torch.stack([b[\"attention_mask\"] for b in batch], dim=0)\n    labels = torch.stack([b[\"labels\"] for b in batch], dim=0)\n    return {\n        \"input_ids\": input_ids,\n        \"attention_mask\": attention_mask,\n        \"labels\": labels,\n    }\n\n\ndef parse_args() -> argparse.Namespace:\n    ap = argparse.ArgumentParser(description=\"Evaluate flat (leaf-level) baseline classifier.\")\n    ap.add_argument(\n        \"--config\",\n        type=str,\n        required=True,\n        help=\"Config with max_length / batch_size; level_sizes is used to sanity-check num_labels.\",\n    )\n    ap.add_argument(\n        \"--checkpoint-dir\",\n        type=str,\n        required=True,\n        help=\"Directory containing the fine-tuned baseline model (save_pretrained output).\",\n    )\n    ap.add_argument(\n        \"--spans-file\",\n        type=str,\n        required=True,","source_hash":"dc5374f19c16a413028a1321089704a4edd39c70fe6acf08a697c6dfcb7d9ffb","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.eval_flat_baseline.parse_args","uri":"program://TOLBERT/function/scripts.eval_flat_baseline.parse_args#L102-L128","kind":"function","name":"parse_args","path":"scripts/eval_flat_baseline.py","language":"python","start_line":102,"end_line":128,"context_start_line":82,"context_end_line":148,"code":"        node_path: List[int] = rec[\"node_path\"]\n        label = int(node_path[-1])\n        return {\n            \"input_ids\": input_ids,\n            \"attention_mask\": attention_mask,\n            \"labels\": torch.tensor(label, dtype=torch.long),\n        }\n\n\ndef collate_flat_eval_batch(batch: List[Dict[str, Any]]) -> Dict[str, Any]:\n    input_ids = torch.stack([b[\"input_ids\"] for b in batch], dim=0)\n    attention_mask = torch.stack([b[\"attention_mask\"] for b in batch], dim=0)\n    labels = torch.stack([b[\"labels\"] for b in batch], dim=0)\n    return {\n        \"input_ids\": input_ids,\n        \"attention_mask\": attention_mask,\n        \"labels\": labels,\n    }\n\n\ndef parse_args() -> argparse.Namespace:\n    ap = argparse.ArgumentParser(description=\"Evaluate flat (leaf-level) baseline classifier.\")\n    ap.add_argument(\n        \"--config\",\n        type=str,\n        required=True,\n        help=\"Config with max_length / batch_size; level_sizes is used to sanity-check num_labels.\",\n    )\n    ap.add_argument(\n        \"--checkpoint-dir\",\n        type=str,\n        required=True,\n        help=\"Directory containing the fine-tuned baseline model (save_pretrained output).\",\n    )\n    ap.add_argument(\n        \"--spans-file\",\n        type=str,\n        required=True,\n        help=\"Labeled spans JSONL file for evaluation (e.g., *_test.jsonl).\",\n    )\n    ap.add_argument(\n        \"--device\",\n        type=str,\n        default=\"cuda\" if torch.cuda.is_available() else \"cpu\",\n        help=\"Device to use.\",\n    )\n    return ap.parse_args()\n\n\ndef main() -> None:\n    args = parse_args()\n    cfg = load_tolbert_config(args.config)\n\n    device = torch.device(args.device)\n\n    spans_path = Path(args.spans_file)\n    if not spans_path.exists():\n        raise FileNotFoundError(f\"spans_file not found: {spans_path}\")\n\n    checkpoint_dir = Path(args.checkpoint_dir)\n    if not checkpoint_dir.exists():\n        raise FileNotFoundError(f\"checkpoint_dir not found: {checkpoint_dir}\")\n\n    # Leaf class count from config (for sanity checking).\n    level_sizes: Dict[int, int] = cfg[\"level_sizes\"]\n    leaf_level = max(level_sizes.keys())\n    num_labels_expected = level_sizes[leaf_level]","source_hash":"dc5374f19c16a413028a1321089704a4edd39c70fe6acf08a697c6dfcb7d9ffb","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.eval_flat_baseline.main","uri":"program://TOLBERT/function/scripts.eval_flat_baseline.main#L131-L201","kind":"function","name":"main","path":"scripts/eval_flat_baseline.py","language":"python","start_line":131,"end_line":201,"context_start_line":111,"context_end_line":207,"code":"        \"--checkpoint-dir\",\n        type=str,\n        required=True,\n        help=\"Directory containing the fine-tuned baseline model (save_pretrained output).\",\n    )\n    ap.add_argument(\n        \"--spans-file\",\n        type=str,\n        required=True,\n        help=\"Labeled spans JSONL file for evaluation (e.g., *_test.jsonl).\",\n    )\n    ap.add_argument(\n        \"--device\",\n        type=str,\n        default=\"cuda\" if torch.cuda.is_available() else \"cpu\",\n        help=\"Device to use.\",\n    )\n    return ap.parse_args()\n\n\ndef main() -> None:\n    args = parse_args()\n    cfg = load_tolbert_config(args.config)\n\n    device = torch.device(args.device)\n\n    spans_path = Path(args.spans_file)\n    if not spans_path.exists():\n        raise FileNotFoundError(f\"spans_file not found: {spans_path}\")\n\n    checkpoint_dir = Path(args.checkpoint_dir)\n    if not checkpoint_dir.exists():\n        raise FileNotFoundError(f\"checkpoint_dir not found: {checkpoint_dir}\")\n\n    # Leaf class count from config (for sanity checking).\n    level_sizes: Dict[int, int] = cfg[\"level_sizes\"]\n    leaf_level = max(level_sizes.keys())\n    num_labels_expected = level_sizes[leaf_level]\n\n    tokenizer = AutoTokenizer.from_pretrained(\n        checkpoint_dir,\n        cache_dir=\"/data/checkpoints/\",  # noqa: E501\n    )\n    model = AutoModelForSequenceClassification.from_pretrained(\n        checkpoint_dir,\n        cache_dir=\"/data/checkpoints/\",  # noqa: E501\n    )\n    if model.num_labels != num_labels_expected:\n        print(\n            f\"Warning: model.num_labels={model.num_labels} \"\n            f\"but config expects {num_labels_expected} leaf classes.\"\n        )\n\n    model.to(device)\n    model.eval()\n\n    dataset = FlatLeafEvalDataset(\n        spans_file=str(spans_path),\n        tokenizer=tokenizer,\n        max_length=cfg.get(\"max_length\", 256),\n    )\n    dataloader = DataLoader(\n        dataset,\n        batch_size=cfg.get(\"batch_size\", 64),\n        shuffle=False,\n        num_workers=cfg.get(\"num_workers\", 0),\n        collate_fn=collate_flat_eval_batch,\n    )\n\n    correct = 0\n    total = 0\n\n    with torch.no_grad():\n        for batch in dataloader:\n            input_ids = batch[\"input_ids\"].to(device)\n            attention_mask = batch[\"attention_mask\"].to(device)\n            labels = batch[\"labels\"].to(device)\n\n            outputs = model(\n                input_ids=input_ids,\n                attention_mask=attention_mask,\n            )\n            logits = outputs.logits\n            preds = logits.argmax(dim=-1)\n\n            correct += (preds == labels).sum().item()\n            total += labels.size(0)\n\n    acc = correct / max(1, total)\n    print(\"=== Flat Leaf-Level Classification Evaluation ===\")\n    print(f\"Accuracy (leaf node id): {acc:.4f} (n={total})\")\n\n\nif __name__ == \"__main__\":\n    main()\n\n","source_hash":"dc5374f19c16a413028a1321089704a4edd39c70fe6acf08a697c6dfcb7d9ffb","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.eval_flat_baseline.__init__","uri":"program://TOLBERT/function/scripts.eval_flat_baseline.__init__#L41-L62","kind":"function","name":"__init__","path":"scripts/eval_flat_baseline.py","language":"python","start_line":41,"end_line":62,"context_start_line":21,"context_end_line":82,"code":"from pathlib import Path\nfrom typing import Any, Dict, List\n\nimport torch\nfrom torch.utils.data import DataLoader, Dataset\nfrom transformers import (\n    AutoModelForSequenceClassification,\n    AutoTokenizer,\n    PreTrainedTokenizerBase,\n)\nimport os\n\nfrom tolbert.config import load_tolbert_config\n\n\nclass FlatLeafEvalDataset(Dataset):\n    \"\"\"\n    Identical to FlatLeafDataset but without any training-specific behavior.\n    \"\"\"\n\n    def __init__(\n        self,\n        spans_file: str,\n        tokenizer: PreTrainedTokenizerBase,\n        max_length: int = 256,\n    ) -> None:\n        self.spans_file = spans_file\n        self.tokenizer = tokenizer\n        self.max_length = max_length\n\n        self._records: List[Dict[str, Any]] = []\n        with open(spans_file, \"r\", encoding=\"utf-8\") as f:\n            for line in f:\n                line = line.strip()\n                if not line:\n                    continue\n                obj = json.loads(line)\n                if \"text\" not in obj or \"node_path\" not in obj:\n                    continue\n                if not obj[\"node_path\"]:\n                    continue\n                self._records.append(obj)\n\n    def __len__(self) -> int:\n        return len(self._records)\n\n    def _tokenize(self, text: str) -> Dict[str, torch.Tensor]:\n        enc = self.tokenizer(\n            text,\n            return_tensors=\"pt\",\n            truncation=True,\n            padding=\"max_length\",\n            max_length=self.max_length,\n        )\n        return {k: v.squeeze(0) for k, v in enc.items()}\n\n    def __getitem__(self, idx: int) -> Dict[str, Any]:\n        rec = self._records[idx]\n        tokens = self._tokenize(rec[\"text\"])\n        input_ids = tokens[\"input_ids\"]\n        attention_mask = tokens.get(\"attention_mask\", torch.ones_like(input_ids))\n        node_path: List[int] = rec[\"node_path\"]","source_hash":"dc5374f19c16a413028a1321089704a4edd39c70fe6acf08a697c6dfcb7d9ffb","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.eval_flat_baseline.__len__","uri":"program://TOLBERT/function/scripts.eval_flat_baseline.__len__#L64-L65","kind":"function","name":"__len__","path":"scripts/eval_flat_baseline.py","language":"python","start_line":64,"end_line":65,"context_start_line":44,"context_end_line":85,"code":"        tokenizer: PreTrainedTokenizerBase,\n        max_length: int = 256,\n    ) -> None:\n        self.spans_file = spans_file\n        self.tokenizer = tokenizer\n        self.max_length = max_length\n\n        self._records: List[Dict[str, Any]] = []\n        with open(spans_file, \"r\", encoding=\"utf-8\") as f:\n            for line in f:\n                line = line.strip()\n                if not line:\n                    continue\n                obj = json.loads(line)\n                if \"text\" not in obj or \"node_path\" not in obj:\n                    continue\n                if not obj[\"node_path\"]:\n                    continue\n                self._records.append(obj)\n\n    def __len__(self) -> int:\n        return len(self._records)\n\n    def _tokenize(self, text: str) -> Dict[str, torch.Tensor]:\n        enc = self.tokenizer(\n            text,\n            return_tensors=\"pt\",\n            truncation=True,\n            padding=\"max_length\",\n            max_length=self.max_length,\n        )\n        return {k: v.squeeze(0) for k, v in enc.items()}\n\n    def __getitem__(self, idx: int) -> Dict[str, Any]:\n        rec = self._records[idx]\n        tokens = self._tokenize(rec[\"text\"])\n        input_ids = tokens[\"input_ids\"]\n        attention_mask = tokens.get(\"attention_mask\", torch.ones_like(input_ids))\n        node_path: List[int] = rec[\"node_path\"]\n        label = int(node_path[-1])\n        return {\n            \"input_ids\": input_ids,","source_hash":"dc5374f19c16a413028a1321089704a4edd39c70fe6acf08a697c6dfcb7d9ffb","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.eval_flat_baseline._tokenize","uri":"program://TOLBERT/function/scripts.eval_flat_baseline._tokenize#L67-L75","kind":"function","name":"_tokenize","path":"scripts/eval_flat_baseline.py","language":"python","start_line":67,"end_line":75,"context_start_line":47,"context_end_line":95,"code":"        self.spans_file = spans_file\n        self.tokenizer = tokenizer\n        self.max_length = max_length\n\n        self._records: List[Dict[str, Any]] = []\n        with open(spans_file, \"r\", encoding=\"utf-8\") as f:\n            for line in f:\n                line = line.strip()\n                if not line:\n                    continue\n                obj = json.loads(line)\n                if \"text\" not in obj or \"node_path\" not in obj:\n                    continue\n                if not obj[\"node_path\"]:\n                    continue\n                self._records.append(obj)\n\n    def __len__(self) -> int:\n        return len(self._records)\n\n    def _tokenize(self, text: str) -> Dict[str, torch.Tensor]:\n        enc = self.tokenizer(\n            text,\n            return_tensors=\"pt\",\n            truncation=True,\n            padding=\"max_length\",\n            max_length=self.max_length,\n        )\n        return {k: v.squeeze(0) for k, v in enc.items()}\n\n    def __getitem__(self, idx: int) -> Dict[str, Any]:\n        rec = self._records[idx]\n        tokens = self._tokenize(rec[\"text\"])\n        input_ids = tokens[\"input_ids\"]\n        attention_mask = tokens.get(\"attention_mask\", torch.ones_like(input_ids))\n        node_path: List[int] = rec[\"node_path\"]\n        label = int(node_path[-1])\n        return {\n            \"input_ids\": input_ids,\n            \"attention_mask\": attention_mask,\n            \"labels\": torch.tensor(label, dtype=torch.long),\n        }\n\n\ndef collate_flat_eval_batch(batch: List[Dict[str, Any]]) -> Dict[str, Any]:\n    input_ids = torch.stack([b[\"input_ids\"] for b in batch], dim=0)\n    attention_mask = torch.stack([b[\"attention_mask\"] for b in batch], dim=0)\n    labels = torch.stack([b[\"labels\"] for b in batch], dim=0)\n    return {","source_hash":"dc5374f19c16a413028a1321089704a4edd39c70fe6acf08a697c6dfcb7d9ffb","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.eval_flat_baseline.__getitem__","uri":"program://TOLBERT/function/scripts.eval_flat_baseline.__getitem__#L77-L88","kind":"function","name":"__getitem__","path":"scripts/eval_flat_baseline.py","language":"python","start_line":77,"end_line":88,"context_start_line":57,"context_end_line":108,"code":"                obj = json.loads(line)\n                if \"text\" not in obj or \"node_path\" not in obj:\n                    continue\n                if not obj[\"node_path\"]:\n                    continue\n                self._records.append(obj)\n\n    def __len__(self) -> int:\n        return len(self._records)\n\n    def _tokenize(self, text: str) -> Dict[str, torch.Tensor]:\n        enc = self.tokenizer(\n            text,\n            return_tensors=\"pt\",\n            truncation=True,\n            padding=\"max_length\",\n            max_length=self.max_length,\n        )\n        return {k: v.squeeze(0) for k, v in enc.items()}\n\n    def __getitem__(self, idx: int) -> Dict[str, Any]:\n        rec = self._records[idx]\n        tokens = self._tokenize(rec[\"text\"])\n        input_ids = tokens[\"input_ids\"]\n        attention_mask = tokens.get(\"attention_mask\", torch.ones_like(input_ids))\n        node_path: List[int] = rec[\"node_path\"]\n        label = int(node_path[-1])\n        return {\n            \"input_ids\": input_ids,\n            \"attention_mask\": attention_mask,\n            \"labels\": torch.tensor(label, dtype=torch.long),\n        }\n\n\ndef collate_flat_eval_batch(batch: List[Dict[str, Any]]) -> Dict[str, Any]:\n    input_ids = torch.stack([b[\"input_ids\"] for b in batch], dim=0)\n    attention_mask = torch.stack([b[\"attention_mask\"] for b in batch], dim=0)\n    labels = torch.stack([b[\"labels\"] for b in batch], dim=0)\n    return {\n        \"input_ids\": input_ids,\n        \"attention_mask\": attention_mask,\n        \"labels\": labels,\n    }\n\n\ndef parse_args() -> argparse.Namespace:\n    ap = argparse.ArgumentParser(description=\"Evaluate flat (leaf-level) baseline classifier.\")\n    ap.add_argument(\n        \"--config\",\n        type=str,\n        required=True,\n        help=\"Config with max_length / batch_size; level_sizes is used to sanity-check num_labels.\",","source_hash":"dc5374f19c16a413028a1321089704a4edd39c70fe6acf08a697c6dfcb7d9ffb","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.train_tolbert","uri":"program://TOLBERT/module/scripts.train_tolbert#L1-L315","kind":"module","name":"scripts.train_tolbert","path":"scripts/train_tolbert.py","language":"python","start_line":1,"end_line":315,"context_start_line":1,"context_end_line":315,"code":"\"\"\"\nMinimal training skeleton for TOLBERT **with curriculum and multi-domain support**.\n\nThis script wires together:\n  - config loading\n  - tokenizer + dataset(s)\n  - model + optimizer\n  - a training loop with optional curriculum over hierarchical / path / contrastive losses\n\nIt assumes you have prepared one or more `spans_file`(s) as described in `docs/tree_of_life.md`.\n\"\"\"\n\nimport argparse\nfrom pathlib import Path\nfrom typing import Any, Dict, Optional\n\nimport torch\nfrom torch.utils.data import DataLoader, ConcatDataset\nfrom transformers import AutoTokenizer\nimport os\n\nfrom tolbert.config import load_tolbert_config\nfrom tolbert.data import TreeOfLifeDataset, collate_tree_of_life_batch\nfrom tolbert.losses import tree_contrastive_loss\nfrom tolbert.modeling import TOLBERT, TOLBERTConfig\n\n\ndef build_model(cfg: Dict[str, Any]) -> TOLBERT:\n    \"\"\"\n    Build a TOLBERT model from config.\n\n    Notes:\n      - `lambda_hier` and `lambda_path` are used as *default* weights inside\n        the model when no curriculum is configured.\n      - When a curriculum is enabled, per-step weights are applied in the\n        training loop based on `loss_components`, and these config values act\n        only as fallbacks.\n    \"\"\"\n    model_cfg = TOLBERTConfig(\n        base_model_name=cfg[\"base_model_name\"],\n        level_sizes=cfg[\"level_sizes\"],\n        proj_dim=cfg.get(\"proj_dim\", 256),\n        lambda_hier=cfg.get(\"lambda_hier\", 1.0),\n        lambda_path=cfg.get(\"lambda_path\", 0.0),\n        lambda_contrast=cfg.get(\"lambda_contrast\", 0.0),\n    )\n    return TOLBERT(model_cfg)\n\n\ndef parse_args() -> argparse.Namespace:\n    ap = argparse.ArgumentParser(description=\"Train a TOLBERT model.\")\n    ap.add_argument(\n        \"--config\",\n        type=str,\n        required=True,\n        help=\"Path to YAML/JSON config file describing model and training params.\",\n    )\n    ap.add_argument(\n        \"--device\",\n        type=str,\n        default=\"cuda\" if torch.cuda.is_available() else \"cpu\",\n        help=\"Device to use (default: cuda if available, else cpu).\",\n    )\n    return ap.parse_args()\n\n\ndef _build_dataset(cfg: Dict[str, Any], tokenizer: Any) -> torch.utils.data.Dataset:\n    \"\"\"\n    Build a (possibly multi-domain) dataset from config.\n\n    Supported config patterns:\n      - `spans_file: /path/to/spans.jsonl`\n      - `spans_files: [ /path/to/code.jsonl, /path/to/papers.jsonl, ... ]`\n\n    In the multi-file case we simply concatenate datasets; mixed-domain\n    batches then come from the union of underlying corpora, as described\n    in the paper.\n    \"\"\"\n    max_length = cfg.get(\"max_length\", 256)\n    mask_probability = cfg.get(\"mask_probability\", 0.15)\n\n    if \"spans_files\" in cfg and cfg[\"spans_files\"] is not None:\n        spans_files_cfg = cfg[\"spans_files\"]\n        if isinstance(spans_files_cfg, str):\n            spans_files = [spans_files_cfg]\n        else:\n            spans_files = list(spans_files_cfg)\n\n        datasets = []\n        for spans_path in spans_files:\n            if not Path(spans_path).exists():\n                raise FileNotFoundError(f\"spans_file not found: {spans_path}\")\n            datasets.append(\n                TreeOfLifeDataset(\n                    spans_file=spans_path,\n                    tokenizer=tokenizer,\n                    max_length=max_length,\n                    mask_probability=mask_probability,\n                )\n            )\n\n        if len(datasets) == 1:\n            return datasets[0]\n        return ConcatDataset(datasets)\n\n    # Fallback: single-file setup (backwards-compatible).\n    spans_file = cfg[\"spans_file\"]\n    if not Path(spans_file).exists():\n        raise FileNotFoundError(f\"spans_file not found: {spans_file}\")\n\n    return TreeOfLifeDataset(\n        spans_file=spans_file,\n        tokenizer=tokenizer,\n        max_length=max_length,\n        mask_probability=mask_probability,\n    )\n\n\ndef _get_curriculum_stage(\n    curriculum_cfg: Optional[Dict[str, Any]],\n    global_step: int,\n) -> Optional[Dict[str, Any]]:\n    \"\"\"\n    Retrieve the active curriculum stage for the given step.\n\n    Expected config shape:\n      curriculum:\n        enabled: true\n        stages:\n          - name: warmup\n            start_step: 0\n            end_step: 10000\n            max_supervised_level: 2\n            lambda_hier: 1.0\n            lambda_path: 0.0\n            lambda_contrast: 0.0\n          - name: deep\n            start_step: 10000\n            end_step: 20000\n            max_supervised_level: 3\n            lambda_hier: 1.0\n            lambda_path: 0.0\n            lambda_contrast: 0.0\n          - name: contrastive\n            start_step: 20000\n            end_step: 30000\n            max_supervised_level: 3\n            lambda_hier: 1.0\n            lambda_path: 0.0\n            lambda_contrast: 0.05\n          - name: path\n            start_step: 30000\n            end_step: null    # or omit to mean \"until end\"\n            max_supervised_level: 3\n            lambda_hier: 1.0\n            lambda_path: 0.05\n            lambda_contrast: 0.05\n\n    If `curriculum.enabled` is false or missing, returns None.\n    \"\"\"\n    if not curriculum_cfg or not curriculum_cfg.get(\"enabled\", False):\n        return None\n\n    stages = curriculum_cfg.get(\"stages\") or []\n    if not stages:\n        return None\n\n    for stage in stages:\n        start = int(stage.get(\"start_step\", 0))\n        end_raw = stage.get(\"end_step\", None)\n        end: Optional[int] = None if end_raw is None else int(end_raw)\n\n        if global_step < start:\n            continue\n        if end is not None and global_step >= end:\n            continue\n        return stage\n\n    # If we fall past all defined ranges, use the last stage as a default.\n    return stages[-1]\n\n\ndef main() -> None:\n    args = parse_args()\n    cfg = load_tolbert_config(args.config)\n\n    device = torch.device(args.device)\n\n    # Tokenizer and dataset(s)\n    tokenizer = AutoTokenizer.from_pretrained(\n        cfg[\"base_model_name\"],\n        cache_dir=\"/data/checkpoints/\",  # noqa: E501\n    )\n    dataset = _build_dataset(cfg, tokenizer)\n\n    dataloader = DataLoader(\n        dataset,\n        batch_size=cfg.get(\"batch_size\", 64),\n        shuffle=True,\n        num_workers=cfg.get(\"num_workers\", 0),\n        collate_fn=collate_tree_of_life_batch,\n    )\n\n    # Model and optimizer\n    model = build_model(cfg).to(device)\n    model.train()\n\n    optimizer = torch.optim.AdamW(model.parameters(), lr=cfg.get(\"lr\", 1e-4))\n\n    num_epochs = cfg.get(\"num_epochs\", 1)\n    contrast_temp = cfg.get(\"contrast_temperature\", 0.07)\n    curriculum_cfg: Optional[Dict[str, Any]] = cfg.get(\"curriculum\")\n\n    # Fallback static weights when curriculum is disabled.\n    static_lambda_hier = float(cfg.get(\"lambda_hier\", 1.0))\n    static_lambda_path = float(cfg.get(\"lambda_path\", 0.0))\n    static_lambda_contrast = float(cfg.get(\"lambda_contrast\", 0.0))\n    use_contrastive_static = static_lambda_contrast > 0.0\n\n    global_step = 0\n\n    for epoch in range(num_epochs):\n        for step, batch in enumerate(dataloader, start=1):\n            global_step += 1\n            optimizer.zero_grad()\n\n            input_ids = batch[\"input_ids\"].to(device)\n            attention_mask = batch[\"attention_mask\"].to(device)\n            labels_mlm = batch[\"labels_mlm\"].to(device)\n\n            # Move level targets to device and optionally trim by curriculum.\n            level_targets = {\n                level: targets.to(device) for level, targets in batch[\"level_targets\"].items()\n            }\n\n            stage = _get_curriculum_stage(curriculum_cfg, global_step)\n\n            # Determine per-step hyperparameters (MLM is always on).\n            if stage is not None:\n                max_level = stage.get(\"max_supervised_level\")\n                if max_level is not None:\n                    max_level_int = int(max_level)\n                    level_targets = {\n                        level: tgt for level, tgt in level_targets.items() if level <= max_level_int\n                    }\n\n                lambda_hier = float(stage.get(\"lambda_hier\", static_lambda_hier))\n                lambda_path = float(stage.get(\"lambda_path\", 0.0))\n                lambda_contrast = float(stage.get(\"lambda_contrast\", 0.0))\n            else:\n                lambda_hier = static_lambda_hier\n                lambda_path = static_lambda_path\n                lambda_contrast = static_lambda_contrast\n\n            # Only pass paths into the model if we actually intend to use path loss.\n            paths_for_model = batch.get(\"paths\") if (lambda_path > 0.0 and \"paths\" in batch) else None\n\n            out = model(\n                input_ids=input_ids,\n                attention_mask=attention_mask,\n                labels_mlm=labels_mlm,\n                level_targets=level_targets,\n                paths=paths_for_model,\n            )\n\n            loss_components = out[\"loss_components\"]\n            mlm_loss = loss_components.get(\"mlm\")\n            hier_loss = loss_components.get(\"hier\")\n            path_loss = loss_components.get(\"path\")\n\n            # Aggregate loss according to either curriculum or static weights.\n            if mlm_loss is None:\n                raise RuntimeError(\"MLM loss is expected but missing from model outputs.\")\n\n            loss = mlm_loss\n\n            if hier_loss is not None and lambda_hier != 0.0:\n                loss = loss + lambda_hier * hier_loss\n\n            if path_loss is not None and lambda_path != 0.0:\n                loss = loss + lambda_path * path_loss\n\n            # Contrastive loss: tree-aware supervised contrastive over paths.\n            use_contrastive = lambda_contrast > 0.0\n            if use_contrastive and \"paths\" in batch:\n                contrast_loss = tree_contrastive_loss(\n                    embeddings=out[\"proj\"],\n                    paths=batch[\"paths\"],\n                    temperature=contrast_temp,\n                )\n                loss = loss + lambda_contrast * contrast_loss\n\n            loss.backward()\n            torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=cfg.get(\"grad_clip\", 1.0))\n            optimizer.step()\n\n            if step % cfg.get(\"log_every\", 50) == 0:\n                loss_items = {k: v.item() for k, v in loss_components.items()}\n                print(\n                    f\"[epoch {epoch+1} step {step} global_step {global_step}] \"\n                    f\"loss={loss.item():.4f} components={loss_items}\"\n                )\n\n        # Simple checkpointing at end of each epoch\n        out_dir = Path(cfg.get(\"output_dir\", \"checkpoints\"))\n        out_dir.mkdir(parents=True, exist_ok=True)\n        ckpt_path = out_dir / f\"tolbert_epoch{epoch+1}.pt\"\n        torch.save(model.state_dict(), ckpt_path)\n        print(f\"Saved checkpoint to {ckpt_path}\")\n\n\nif __name__ == \"__main__\":\n    main()\n\n","source_hash":"a3d153b42c9ecbc9731d749ebc6c9ef6775be090e4d1a5f0b71bc6b157cea378","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.train_tolbert.build_model","uri":"program://TOLBERT/function/scripts.train_tolbert.build_model#L28-L47","kind":"function","name":"build_model","path":"scripts/train_tolbert.py","language":"python","start_line":28,"end_line":47,"context_start_line":8,"context_end_line":67,"code":"  - a training loop with optional curriculum over hierarchical / path / contrastive losses\n\nIt assumes you have prepared one or more `spans_file`(s) as described in `docs/tree_of_life.md`.\n\"\"\"\n\nimport argparse\nfrom pathlib import Path\nfrom typing import Any, Dict, Optional\n\nimport torch\nfrom torch.utils.data import DataLoader, ConcatDataset\nfrom transformers import AutoTokenizer\nimport os\n\nfrom tolbert.config import load_tolbert_config\nfrom tolbert.data import TreeOfLifeDataset, collate_tree_of_life_batch\nfrom tolbert.losses import tree_contrastive_loss\nfrom tolbert.modeling import TOLBERT, TOLBERTConfig\n\n\ndef build_model(cfg: Dict[str, Any]) -> TOLBERT:\n    \"\"\"\n    Build a TOLBERT model from config.\n\n    Notes:\n      - `lambda_hier` and `lambda_path` are used as *default* weights inside\n        the model when no curriculum is configured.\n      - When a curriculum is enabled, per-step weights are applied in the\n        training loop based on `loss_components`, and these config values act\n        only as fallbacks.\n    \"\"\"\n    model_cfg = TOLBERTConfig(\n        base_model_name=cfg[\"base_model_name\"],\n        level_sizes=cfg[\"level_sizes\"],\n        proj_dim=cfg.get(\"proj_dim\", 256),\n        lambda_hier=cfg.get(\"lambda_hier\", 1.0),\n        lambda_path=cfg.get(\"lambda_path\", 0.0),\n        lambda_contrast=cfg.get(\"lambda_contrast\", 0.0),\n    )\n    return TOLBERT(model_cfg)\n\n\ndef parse_args() -> argparse.Namespace:\n    ap = argparse.ArgumentParser(description=\"Train a TOLBERT model.\")\n    ap.add_argument(\n        \"--config\",\n        type=str,\n        required=True,\n        help=\"Path to YAML/JSON config file describing model and training params.\",\n    )\n    ap.add_argument(\n        \"--device\",\n        type=str,\n        default=\"cuda\" if torch.cuda.is_available() else \"cpu\",\n        help=\"Device to use (default: cuda if available, else cpu).\",\n    )\n    return ap.parse_args()\n\n\ndef _build_dataset(cfg: Dict[str, Any], tokenizer: Any) -> torch.utils.data.Dataset:","source_hash":"a3d153b42c9ecbc9731d749ebc6c9ef6775be090e4d1a5f0b71bc6b157cea378","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.train_tolbert.parse_args","uri":"program://TOLBERT/function/scripts.train_tolbert.parse_args#L50-L64","kind":"function","name":"parse_args","path":"scripts/train_tolbert.py","language":"python","start_line":50,"end_line":64,"context_start_line":30,"context_end_line":84,"code":"    Build a TOLBERT model from config.\n\n    Notes:\n      - `lambda_hier` and `lambda_path` are used as *default* weights inside\n        the model when no curriculum is configured.\n      - When a curriculum is enabled, per-step weights are applied in the\n        training loop based on `loss_components`, and these config values act\n        only as fallbacks.\n    \"\"\"\n    model_cfg = TOLBERTConfig(\n        base_model_name=cfg[\"base_model_name\"],\n        level_sizes=cfg[\"level_sizes\"],\n        proj_dim=cfg.get(\"proj_dim\", 256),\n        lambda_hier=cfg.get(\"lambda_hier\", 1.0),\n        lambda_path=cfg.get(\"lambda_path\", 0.0),\n        lambda_contrast=cfg.get(\"lambda_contrast\", 0.0),\n    )\n    return TOLBERT(model_cfg)\n\n\ndef parse_args() -> argparse.Namespace:\n    ap = argparse.ArgumentParser(description=\"Train a TOLBERT model.\")\n    ap.add_argument(\n        \"--config\",\n        type=str,\n        required=True,\n        help=\"Path to YAML/JSON config file describing model and training params.\",\n    )\n    ap.add_argument(\n        \"--device\",\n        type=str,\n        default=\"cuda\" if torch.cuda.is_available() else \"cpu\",\n        help=\"Device to use (default: cuda if available, else cpu).\",\n    )\n    return ap.parse_args()\n\n\ndef _build_dataset(cfg: Dict[str, Any], tokenizer: Any) -> torch.utils.data.Dataset:\n    \"\"\"\n    Build a (possibly multi-domain) dataset from config.\n\n    Supported config patterns:\n      - `spans_file: /path/to/spans.jsonl`\n      - `spans_files: [ /path/to/code.jsonl, /path/to/papers.jsonl, ... ]`\n\n    In the multi-file case we simply concatenate datasets; mixed-domain\n    batches then come from the union of underlying corpora, as described\n    in the paper.\n    \"\"\"\n    max_length = cfg.get(\"max_length\", 256)\n    mask_probability = cfg.get(\"mask_probability\", 0.15)\n\n    if \"spans_files\" in cfg and cfg[\"spans_files\"] is not None:\n        spans_files_cfg = cfg[\"spans_files\"]\n        if isinstance(spans_files_cfg, str):","source_hash":"a3d153b42c9ecbc9731d749ebc6c9ef6775be090e4d1a5f0b71bc6b157cea378","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.train_tolbert._build_dataset","uri":"program://TOLBERT/function/scripts.train_tolbert._build_dataset#L67-L116","kind":"function","name":"_build_dataset","path":"scripts/train_tolbert.py","language":"python","start_line":67,"end_line":116,"context_start_line":47,"context_end_line":136,"code":"    return TOLBERT(model_cfg)\n\n\ndef parse_args() -> argparse.Namespace:\n    ap = argparse.ArgumentParser(description=\"Train a TOLBERT model.\")\n    ap.add_argument(\n        \"--config\",\n        type=str,\n        required=True,\n        help=\"Path to YAML/JSON config file describing model and training params.\",\n    )\n    ap.add_argument(\n        \"--device\",\n        type=str,\n        default=\"cuda\" if torch.cuda.is_available() else \"cpu\",\n        help=\"Device to use (default: cuda if available, else cpu).\",\n    )\n    return ap.parse_args()\n\n\ndef _build_dataset(cfg: Dict[str, Any], tokenizer: Any) -> torch.utils.data.Dataset:\n    \"\"\"\n    Build a (possibly multi-domain) dataset from config.\n\n    Supported config patterns:\n      - `spans_file: /path/to/spans.jsonl`\n      - `spans_files: [ /path/to/code.jsonl, /path/to/papers.jsonl, ... ]`\n\n    In the multi-file case we simply concatenate datasets; mixed-domain\n    batches then come from the union of underlying corpora, as described\n    in the paper.\n    \"\"\"\n    max_length = cfg.get(\"max_length\", 256)\n    mask_probability = cfg.get(\"mask_probability\", 0.15)\n\n    if \"spans_files\" in cfg and cfg[\"spans_files\"] is not None:\n        spans_files_cfg = cfg[\"spans_files\"]\n        if isinstance(spans_files_cfg, str):\n            spans_files = [spans_files_cfg]\n        else:\n            spans_files = list(spans_files_cfg)\n\n        datasets = []\n        for spans_path in spans_files:\n            if not Path(spans_path).exists():\n                raise FileNotFoundError(f\"spans_file not found: {spans_path}\")\n            datasets.append(\n                TreeOfLifeDataset(\n                    spans_file=spans_path,\n                    tokenizer=tokenizer,\n                    max_length=max_length,\n                    mask_probability=mask_probability,\n                )\n            )\n\n        if len(datasets) == 1:\n            return datasets[0]\n        return ConcatDataset(datasets)\n\n    # Fallback: single-file setup (backwards-compatible).\n    spans_file = cfg[\"spans_file\"]\n    if not Path(spans_file).exists():\n        raise FileNotFoundError(f\"spans_file not found: {spans_file}\")\n\n    return TreeOfLifeDataset(\n        spans_file=spans_file,\n        tokenizer=tokenizer,\n        max_length=max_length,\n        mask_probability=mask_probability,\n    )\n\n\ndef _get_curriculum_stage(\n    curriculum_cfg: Optional[Dict[str, Any]],\n    global_step: int,\n) -> Optional[Dict[str, Any]]:\n    \"\"\"\n    Retrieve the active curriculum stage for the given step.\n\n    Expected config shape:\n      curriculum:\n        enabled: true\n        stages:\n          - name: warmup\n            start_step: 0\n            end_step: 10000\n            max_supervised_level: 2\n            lambda_hier: 1.0\n            lambda_path: 0.0\n            lambda_contrast: 0.0","source_hash":"a3d153b42c9ecbc9731d749ebc6c9ef6775be090e4d1a5f0b71bc6b157cea378","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.train_tolbert._get_curriculum_stage","uri":"program://TOLBERT/function/scripts.train_tolbert._get_curriculum_stage#L119-L180","kind":"function","name":"_get_curriculum_stage","path":"scripts/train_tolbert.py","language":"python","start_line":119,"end_line":180,"context_start_line":99,"context_end_line":200,"code":"                )\n            )\n\n        if len(datasets) == 1:\n            return datasets[0]\n        return ConcatDataset(datasets)\n\n    # Fallback: single-file setup (backwards-compatible).\n    spans_file = cfg[\"spans_file\"]\n    if not Path(spans_file).exists():\n        raise FileNotFoundError(f\"spans_file not found: {spans_file}\")\n\n    return TreeOfLifeDataset(\n        spans_file=spans_file,\n        tokenizer=tokenizer,\n        max_length=max_length,\n        mask_probability=mask_probability,\n    )\n\n\ndef _get_curriculum_stage(\n    curriculum_cfg: Optional[Dict[str, Any]],\n    global_step: int,\n) -> Optional[Dict[str, Any]]:\n    \"\"\"\n    Retrieve the active curriculum stage for the given step.\n\n    Expected config shape:\n      curriculum:\n        enabled: true\n        stages:\n          - name: warmup\n            start_step: 0\n            end_step: 10000\n            max_supervised_level: 2\n            lambda_hier: 1.0\n            lambda_path: 0.0\n            lambda_contrast: 0.0\n          - name: deep\n            start_step: 10000\n            end_step: 20000\n            max_supervised_level: 3\n            lambda_hier: 1.0\n            lambda_path: 0.0\n            lambda_contrast: 0.0\n          - name: contrastive\n            start_step: 20000\n            end_step: 30000\n            max_supervised_level: 3\n            lambda_hier: 1.0\n            lambda_path: 0.0\n            lambda_contrast: 0.05\n          - name: path\n            start_step: 30000\n            end_step: null    # or omit to mean \"until end\"\n            max_supervised_level: 3\n            lambda_hier: 1.0\n            lambda_path: 0.05\n            lambda_contrast: 0.05\n\n    If `curriculum.enabled` is false or missing, returns None.\n    \"\"\"\n    if not curriculum_cfg or not curriculum_cfg.get(\"enabled\", False):\n        return None\n\n    stages = curriculum_cfg.get(\"stages\") or []\n    if not stages:\n        return None\n\n    for stage in stages:\n        start = int(stage.get(\"start_step\", 0))\n        end_raw = stage.get(\"end_step\", None)\n        end: Optional[int] = None if end_raw is None else int(end_raw)\n\n        if global_step < start:\n            continue\n        if end is not None and global_step >= end:\n            continue\n        return stage\n\n    # If we fall past all defined ranges, use the last stage as a default.\n    return stages[-1]\n\n\ndef main() -> None:\n    args = parse_args()\n    cfg = load_tolbert_config(args.config)\n\n    device = torch.device(args.device)\n\n    # Tokenizer and dataset(s)\n    tokenizer = AutoTokenizer.from_pretrained(\n        cfg[\"base_model_name\"],\n        cache_dir=\"/data/checkpoints/\",  # noqa: E501\n    )\n    dataset = _build_dataset(cfg, tokenizer)\n\n    dataloader = DataLoader(\n        dataset,\n        batch_size=cfg.get(\"batch_size\", 64),\n        shuffle=True,\n        num_workers=cfg.get(\"num_workers\", 0),","source_hash":"a3d153b42c9ecbc9731d749ebc6c9ef6775be090e4d1a5f0b71bc6b157cea378","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.train_tolbert.main","uri":"program://TOLBERT/function/scripts.train_tolbert.main#L183-L309","kind":"function","name":"main","path":"scripts/train_tolbert.py","language":"python","start_line":183,"end_line":309,"context_start_line":163,"context_end_line":315,"code":"\n    stages = curriculum_cfg.get(\"stages\") or []\n    if not stages:\n        return None\n\n    for stage in stages:\n        start = int(stage.get(\"start_step\", 0))\n        end_raw = stage.get(\"end_step\", None)\n        end: Optional[int] = None if end_raw is None else int(end_raw)\n\n        if global_step < start:\n            continue\n        if end is not None and global_step >= end:\n            continue\n        return stage\n\n    # If we fall past all defined ranges, use the last stage as a default.\n    return stages[-1]\n\n\ndef main() -> None:\n    args = parse_args()\n    cfg = load_tolbert_config(args.config)\n\n    device = torch.device(args.device)\n\n    # Tokenizer and dataset(s)\n    tokenizer = AutoTokenizer.from_pretrained(\n        cfg[\"base_model_name\"],\n        cache_dir=\"/data/checkpoints/\",  # noqa: E501\n    )\n    dataset = _build_dataset(cfg, tokenizer)\n\n    dataloader = DataLoader(\n        dataset,\n        batch_size=cfg.get(\"batch_size\", 64),\n        shuffle=True,\n        num_workers=cfg.get(\"num_workers\", 0),\n        collate_fn=collate_tree_of_life_batch,\n    )\n\n    # Model and optimizer\n    model = build_model(cfg).to(device)\n    model.train()\n\n    optimizer = torch.optim.AdamW(model.parameters(), lr=cfg.get(\"lr\", 1e-4))\n\n    num_epochs = cfg.get(\"num_epochs\", 1)\n    contrast_temp = cfg.get(\"contrast_temperature\", 0.07)\n    curriculum_cfg: Optional[Dict[str, Any]] = cfg.get(\"curriculum\")\n\n    # Fallback static weights when curriculum is disabled.\n    static_lambda_hier = float(cfg.get(\"lambda_hier\", 1.0))\n    static_lambda_path = float(cfg.get(\"lambda_path\", 0.0))\n    static_lambda_contrast = float(cfg.get(\"lambda_contrast\", 0.0))\n    use_contrastive_static = static_lambda_contrast > 0.0\n\n    global_step = 0\n\n    for epoch in range(num_epochs):\n        for step, batch in enumerate(dataloader, start=1):\n            global_step += 1\n            optimizer.zero_grad()\n\n            input_ids = batch[\"input_ids\"].to(device)\n            attention_mask = batch[\"attention_mask\"].to(device)\n            labels_mlm = batch[\"labels_mlm\"].to(device)\n\n            # Move level targets to device and optionally trim by curriculum.\n            level_targets = {\n                level: targets.to(device) for level, targets in batch[\"level_targets\"].items()\n            }\n\n            stage = _get_curriculum_stage(curriculum_cfg, global_step)\n\n            # Determine per-step hyperparameters (MLM is always on).\n            if stage is not None:\n                max_level = stage.get(\"max_supervised_level\")\n                if max_level is not None:\n                    max_level_int = int(max_level)\n                    level_targets = {\n                        level: tgt for level, tgt in level_targets.items() if level <= max_level_int\n                    }\n\n                lambda_hier = float(stage.get(\"lambda_hier\", static_lambda_hier))\n                lambda_path = float(stage.get(\"lambda_path\", 0.0))\n                lambda_contrast = float(stage.get(\"lambda_contrast\", 0.0))\n            else:\n                lambda_hier = static_lambda_hier\n                lambda_path = static_lambda_path\n                lambda_contrast = static_lambda_contrast\n\n            # Only pass paths into the model if we actually intend to use path loss.\n            paths_for_model = batch.get(\"paths\") if (lambda_path > 0.0 and \"paths\" in batch) else None\n\n            out = model(\n                input_ids=input_ids,\n                attention_mask=attention_mask,\n                labels_mlm=labels_mlm,\n                level_targets=level_targets,\n                paths=paths_for_model,\n            )\n\n            loss_components = out[\"loss_components\"]\n            mlm_loss = loss_components.get(\"mlm\")\n            hier_loss = loss_components.get(\"hier\")\n            path_loss = loss_components.get(\"path\")\n\n            # Aggregate loss according to either curriculum or static weights.\n            if mlm_loss is None:\n                raise RuntimeError(\"MLM loss is expected but missing from model outputs.\")\n\n            loss = mlm_loss\n\n            if hier_loss is not None and lambda_hier != 0.0:\n                loss = loss + lambda_hier * hier_loss\n\n            if path_loss is not None and lambda_path != 0.0:\n                loss = loss + lambda_path * path_loss\n\n            # Contrastive loss: tree-aware supervised contrastive over paths.\n            use_contrastive = lambda_contrast > 0.0\n            if use_contrastive and \"paths\" in batch:\n                contrast_loss = tree_contrastive_loss(\n                    embeddings=out[\"proj\"],\n                    paths=batch[\"paths\"],\n                    temperature=contrast_temp,\n                )\n                loss = loss + lambda_contrast * contrast_loss\n\n            loss.backward()\n            torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=cfg.get(\"grad_clip\", 1.0))\n            optimizer.step()\n\n            if step % cfg.get(\"log_every\", 50) == 0:\n                loss_items = {k: v.item() for k, v in loss_components.items()}\n                print(\n                    f\"[epoch {epoch+1} step {step} global_step {global_step}] \"\n                    f\"loss={loss.item():.4f} components={loss_items}\"\n                )\n\n        # Simple checkpointing at end of each epoch\n        out_dir = Path(cfg.get(\"output_dir\", \"checkpoints\"))\n        out_dir.mkdir(parents=True, exist_ok=True)\n        ckpt_path = out_dir / f\"tolbert_epoch{epoch+1}.pt\"\n        torch.save(model.state_dict(), ckpt_path)\n        print(f\"Saved checkpoint to {ckpt_path}\")\n\n\nif __name__ == \"__main__\":\n    main()\n\n","source_hash":"a3d153b42c9ecbc9731d749ebc6c9ef6775be090e4d1a5f0b71bc6b157cea378","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.repo_graph","uri":"program://TOLBERT/module/scripts.repo_graph#L1-L733","kind":"module","name":"scripts.repo_graph","path":"scripts/repo_graph.py","language":"python","start_line":1,"end_line":733,"context_start_line":1,"context_end_line":733,"code":"from __future__ import annotations\n\nimport os\nimport re\nimport hashlib\nfrom typing import Iterable, List, Tuple, Dict, Optional, Set, Any\n\nfrom modules.program_graph import ProgramGraph, Entity, Edge, Artifact, Span, ResolvedAnchor, EntityId\n\n\ndef program_id_for_repo(repo_root: str) -> str:\n    base = os.path.basename(os.path.abspath(repo_root)) or \"repo\"\n    return base\n\n\ndef artifact_uri(program_id: str, rel_path: str) -> str:\n    rel = rel_path.replace(\"\\\\\", \"/\").lstrip(\"/\")\n    return f\"program://{program_id}/artifact/{rel}\"\n\n\ndef parse_program_uri(uri: str) -> Tuple[str, str, str, Optional[Tuple[int, int]]]:\n    m = re.match(r\"^program://([^/]+)/([^/]+)/(.+?)(?:#L(\\d+)-L(\\d+))?$\", uri)\n    if not m:\n        raise ValueError(f\"invalid program uri: {uri}\")\n    pid, kind, res, a, b = m.group(1), m.group(2), m.group(3), m.group(4), m.group(5)\n    span = (int(a), int(b)) if (a and b) else None\n    return pid, kind, res, span\n\n\nclass RepoGraph(ProgramGraph):\n    def __init__(self, repo_root: str, ignore: Optional[List[str]] = None):\n        self.repo_root = os.path.abspath(repo_root)\n        self.program_id = program_id_for_repo(self.repo_root)\n        self.ignore_rules = [s for s in (ignore or []) if s]\n        self._file_hash: Dict[str, str] = {}\n        # Cached graph views\n        self._entities: Dict[EntityId, Entity] = {}\n        self._edges: List[Edge] = []\n        self._built: bool = False\n        # Convenience indices\n        #   - absolute file path → file-entity id\n        #   - symbol name (lowercased) → list of entity ids\n        self._file_entity_for_abs: Dict[str, EntityId] = {}\n        self._symbols_by_name: Dict[str, List[EntityId]] = {}\n\n    # ProgramGraph: core views\n    def entities(self) -> Iterable[Entity]:\n        self._ensure_built()\n        return self._entities.values()\n\n    def edges(self) -> Iterable[Edge]:\n        self._ensure_built()\n        return list(self._edges)\n\n    def search_refs(self, token: str) -> Iterable[Tuple[EntityId, Span]]:\n        return []\n\n    def subgraph(self, seeds: List[EntityId], radius: int) -> \"ProgramGraph\":\n        if not seeds or radius <= 0:\n            return self\n        # Generic BFS over current edges view\n        adj: Dict[str, List[str]] = {}\n        for e in self.edges():\n            adj.setdefault(e.src, []).append(e.dst)\n            adj.setdefault(e.dst, []).append(e.src)\n        cur = set(seeds)\n        seen = set(cur)\n        for _ in range(max(1, radius)):\n            nxt: Set[str] = set()\n            for s in list(cur):\n                for nb in adj.get(s, []):\n                    if nb not in seen:\n                        seen.add(nb)\n                        nxt.add(nb)\n            cur = nxt\n        # For now, RepoGraph exposes a single global view; callers that need\n        # an actual induced subgraph can post-filter entities/edges.\n        return self  # pragma: no cover - view semantics only\n\n    def artifacts(self, kind: str) -> Iterable[Artifact]:\n        if kind not in (\"artifact\", \"source\"):\n            return []\n        self._ensure_built()\n        out: List[Artifact] = []\n        for fp in self._discover_files(self.repo_root, self.ignore_rules):\n            rel = os.path.relpath(fp, self.repo_root).replace(\"\\\\\", \"/\")\n            out.append(\n                Artifact(\n                    uri=artifact_uri(self.program_id, rel),\n                    type=\"source\",\n                    hash=self._hash_for(fp),\n                    span=None,\n                )\n            )\n        return out\n\n    def resolve(self, uri: str) -> ResolvedAnchor:\n        pid, kind, res, span = parse_program_uri(uri)\n        if pid != self.program_id:\n            raise ValueError(f\"program id mismatch: {pid} != {self.program_id}\")\n        if kind == \"artifact\":\n            abs_fp = os.path.abspath(os.path.join(self.repo_root, res))\n            if not os.path.isfile(abs_fp):\n                raise FileNotFoundError(f\"artifact not found: {abs_fp}\")\n            a = int(span[0]) if span else 1\n            b = int(span[1]) if span else self._safe_count_lines(abs_fp)\n            rel = os.path.relpath(abs_fp, self.repo_root).replace(\"\\\\\", \"/\")\n            return ResolvedAnchor(\n                artifact_uri=artifact_uri(self.program_id, rel),\n                span=Span(start_line=a, end_line=b),\n                hash=self._hash_for(abs_fp),\n            )\n        # Let subclass handle entity URIs\n        return self._resolve_entity_uri(kind, res, span)\n\n    # Hooks for subclasses\n    def _resolve_entity_uri(self, kind: str, resource: str, span: Optional[Tuple[int, int]]) -> ResolvedAnchor:\n        raise KeyError(f\"unrecognized entity uri for kind={kind}, resource={resource}\")\n\n    # Build / utilities\n    def _ensure_built(self) -> None:\n        if self._built:\n            return\n        self._build_graph()\n        self._built = True\n\n    def _build_graph(self) -> None:\n        \"\"\"\n        Populate entity and edge sets for this repository.\n\n        This is intentionally language-agnostic at the core:\n          - Always creates a repo-level entity.\n          - Always creates file-level entities for discovered source artifacts.\n\n        Language-specific structure (imports, calls, packages / modules) is\n        layered on top via simple heuristics and optional backends.\n        \"\"\"\n        # Repo entity\n        repo_eid: EntityId = f\"repo:{self.program_id}\"\n        if repo_eid not in self._entities:\n            self._entities[repo_eid] = Entity(\n                id=repo_eid,\n                kind=\"repo\",\n                uri=f\"program://{self.program_id}/repo\",\n                artifact_uri=None,\n                span=None,\n                labels=[\"kind:repo\"],\n                attributes={\"root\": self.repo_root},\n            )\n\n        # Discover files and create file-level entities\n        files = self._discover_files(self.repo_root, self.ignore_rules)\n        for fp in files:\n            rel = os.path.relpath(fp, self.repo_root).replace(\"\\\\\", \"/\")\n            uri = artifact_uri(self.program_id, rel)\n            labels = [\"kind:file\"] + self._language_labels_for(rel)\n            eid: EntityId = uri  # stable id tied to artifact URI\n            if eid not in self._entities:\n                self._entities[eid] = Entity(\n                    id=eid,\n                    kind=\"file\",\n                    uri=uri,\n                    artifact_uri=uri,\n                    span=None,\n                    labels=labels,\n                    attributes={\"rel_path\": rel},\n                )\n            self._file_entity_for_abs[os.path.abspath(fp)] = eid\n            # Repo \"owns\" file\n            self._edges.append(\n                Edge(\n                    src=repo_eid,\n                    dst=eid,\n                    type=\"owns\",\n                    attributes={},\n                )\n            )\n\n        # Language-specific edges and entities.\n        self._build_language_edges_and_entities(files)\n\n    def _build_language_edges_and_entities(self, files: List[str]) -> None:\n        \"\"\"\n        Add language-specific structure for supported stacks.\n\n        - C / C++: file-level imports from #include relationships.\n        - Go: package entities and import edges.\n        - Java: imported type entities and import edges.\n        - JS / TS: module/file imports from ES modules / require().\n        - Python: optional integration via scripts.codegraph_core.CodeGraph\n          for module / function / class entities and imports / calls.\n        \"\"\"\n        # Best-effort C / C++ / Go / Java / JS import graphs\n        for abs_fp in files:\n            rel = os.path.relpath(abs_fp, self.repo_root).replace(\"\\\\\", \"/\")\n            _, ext = os.path.splitext(rel.lower())\n            if ext in (\".c\", \".h\", \".cc\", \".cpp\", \".cxx\", \".hpp\"):\n                self._add_c_includes(abs_fp)\n            elif ext == \".go\":\n                self._add_go_imports(abs_fp)\n            elif ext == \".java\":\n                self._add_java_imports(abs_fp)\n            elif ext in (\".js\", \".jsx\", \".mjs\", \".ts\", \".tsx\"):\n                self._add_js_like_imports(abs_fp)\n\n        # Optional: richer Python graph via scripts.codegraph_core\n        try:\n            from scripts.codegraph_core import CodeGraph as _PyCodeGraph  # type: ignore\n        except Exception:\n            _PyCodeGraph = None  # type: ignore\n\n        if _PyCodeGraph is not None:\n            try:\n                cg = _PyCodeGraph(self.repo_root, ignore=self.ignore_rules).build()\n            except Exception:\n                cg = None\n            if cg is not None:\n                self._ingest_python_codegraph(cg)\n\n        # Non-Python symbol entities + heuristic call graph.\n        self._add_non_python_symbols_and_calls(files)\n\n    def _discover_files(self, root: str, ignore: List[str]) -> List[str]:\n        out: List[str] = []\n        for dirpath, dirnames, filenames in os.walk(root):\n            if any(ig and ig in dirpath for ig in ignore):\n                continue\n            for fn in filenames:\n                ap = os.path.abspath(os.path.join(dirpath, fn))\n                out.append(ap)\n        return out\n\n    def _language_labels_for(self, rel_path: str) -> List[str]:\n        \"\"\"\n        Best-effort language tags for a repo-relative path based on extension.\n\n        These are intentionally coarse and are only used to annotate entities\n        (e.g., file-level entities) so that downstream tools can filter or\n        group by language family when needed.\n        \"\"\"\n        _, ext = os.path.splitext(rel_path.lower())\n        labels: List[str] = []\n        if ext == \".py\":\n            labels.append(\"lang:python\")\n        elif ext in (\".c\", \".h\"):\n            labels.append(\"lang:c\")\n        elif ext in (\".cc\", \".cpp\", \".cxx\", \".hpp\"):\n            labels.append(\"lang:cpp\")\n        elif ext in (\".js\", \".jsx\", \".mjs\"):\n            labels.append(\"lang:js\")\n        elif ext in (\".ts\", \".tsx\"):\n            labels.append(\"lang:ts\")\n        elif ext == \".go\":\n            labels.append(\"lang:go\")\n        elif ext == \".java\":\n            labels.append(\"lang:java\")\n        elif ext == \".md\":\n            labels.append(\"lang:markdown\")\n        return labels\n\n    def _safe_count_lines(self, abs_file: str) -> int:\n        try:\n            with open(abs_file, \"r\", encoding=\"utf-8\", errors=\"ignore\") as fh:\n                return sum(1 for _ in fh)\n        except Exception:\n            return 1\n\n    def _hash_for(self, abs_file: str) -> str:\n        if abs_file in self._file_hash:\n            return self._file_hash[abs_file]\n        try:\n            with open(abs_file, \"rb\") as fh:\n                raw = fh.read()\n            h = hashlib.sha256(raw).hexdigest()\n        except Exception:\n            h = \"\"\n        self._file_hash[abs_file] = h\n        return h\n\n    # --- Language-specific helpers ---\n\n    def _add_symbol_entity(\n        self,\n        abs_fp: str,\n        name: str,\n        kind: str,\n        lang_label: str,\n        start_line: int,\n        end_line: int,\n    ) -> Optional[EntityId]:\n        abs_fp = os.path.abspath(abs_fp)\n        file_eid = self._file_entity_for_abs.get(abs_fp)\n        if not file_eid:\n            return None\n        # Stable id: lang-specific prefix + file rel path + symbol name.\n        rel = os.path.relpath(abs_fp, self.repo_root).replace(\"\\\\\", \"/\")\n        sym_id: EntityId = f\"{lang_label}:{rel}:{name}\"\n        if sym_id in self._entities:\n            return sym_id\n        file_ent = self._entities[file_eid]\n        span = Span(start_line=int(start_line), end_line=int(end_line))\n        uri = f\"program://{self.program_id}/sym/{lang_label}/{rel}#{name}\"\n        labels = [f\"kind:{kind}\", f\"lang:{lang_label}\"]\n        self._entities[sym_id] = Entity(\n            id=sym_id,\n            kind=kind,\n            uri=uri,\n            artifact_uri=file_ent.artifact_uri,\n            span=span,\n            labels=labels,\n            attributes={\"name\": name, \"file\": rel},\n        )\n        # file \"owns\" symbol\n        self._edges.append(\n            Edge(\n                src=file_eid,\n                dst=sym_id,\n                type=\"owns\",\n                attributes={\"lang\": lang_label},\n            )\n        )\n        self._symbols_by_name.setdefault(name.lower(), []).append(sym_id)\n        return sym_id\n\n    def _add_c_includes(self, abs_fp: str) -> None:\n        src_eid = self._file_entity_for_abs.get(os.path.abspath(abs_fp))\n        if not src_eid:\n            return\n        try:\n            with open(abs_fp, \"r\", encoding=\"utf-8\", errors=\"ignore\") as fh:\n                text = fh.read()\n        except Exception:\n            return\n        # Match #include \"local.h\" and #include <local.h>\n        rx = re.compile(r'^\\s*#\\s*include\\s*[<\"]([^\">]+)[\">]', re.MULTILINE)\n        for m in rx.finditer(text):\n            target = m.group(1).strip()\n            if not target:\n                continue\n            # Resolve relative to current directory; ignore obvious system headers.\n            if \"/\" not in target and \"\\\\\" not in target and \".\" not in target:\n                continue\n            cand = os.path.abspath(os.path.join(os.path.dirname(abs_fp), target))\n            dst_eid = self._file_entity_for_abs.get(cand)\n            if not dst_eid:\n                continue\n            self._edges.append(\n                Edge(\n                    src=src_eid,\n                    dst=dst_eid,\n                    type=\"imports\",\n                    attributes={\"lang\": \"c_cpp\"},\n                )\n            )\n\n    def _add_go_imports(self, abs_fp: str) -> None:\n        src_eid = self._file_entity_for_abs.get(os.path.abspath(abs_fp))\n        if not src_eid:\n            return\n        try:\n            with open(abs_fp, \"r\", encoding=\"utf-8\", errors=\"ignore\") as fh:\n                lines = fh.readlines()\n        except Exception:\n            return\n        in_block = False\n        for ln in lines:\n            stripped = ln.strip()\n            if stripped.startswith(\"import \"):\n                # Single-line: import \"pkg/path\"\n                in_block = \"(\" in stripped and not stripped.rstrip().endswith(\")\")\n                m = re.search(r'[\"`](.+?)[\"`]', stripped)\n                if m:\n                    pkg = m.group(1).strip()\n                    self._add_go_import_edge(src_eid, pkg)\n            elif in_block:\n                if stripped.startswith(\")\"):\n                    in_block = False\n                    continue\n                m = re.search(r'[\"`](.+?)[\"`]', stripped)\n                if m:\n                    pkg = m.group(1).strip()\n                    self._add_go_import_edge(src_eid, pkg)\n\n    def _add_go_import_edge(self, src_eid: EntityId, pkg: str) -> None:\n        if not pkg:\n            return\n        eid: EntityId = f\"go:pkg:{pkg}\"\n        if eid not in self._entities:\n            self._entities[eid] = Entity(\n                id=eid,\n                kind=\"package\",\n                uri=f\"program://{self.program_id}/go_pkg/{pkg}\",\n                artifact_uri=None,\n                span=None,\n                labels=[\"kind:package\", \"lang:go\"],\n                attributes={\"package\": pkg},\n            )\n        self._edges.append(\n            Edge(\n                src=src_eid,\n                dst=eid,\n                type=\"imports\",\n                    attributes={\"lang\": \"go\"},\n            )\n        )\n\n    def _add_java_imports(self, abs_fp: str) -> None:\n        src_eid = self._file_entity_for_abs.get(os.path.abspath(abs_fp))\n        if not src_eid:\n            return\n        try:\n            with open(abs_fp, \"r\", encoding=\"utf-8\", errors=\"ignore\") as fh:\n                text = fh.read()\n        except Exception:\n            return\n        rx = re.compile(r'^\\s*import\\s+(static\\s+)?([a-zA-Z0-9_.]+)\\s*;', re.MULTILINE)\n        for m in rx.finditer(text):\n            fqn = m.group(2)\n            if not fqn:\n                continue\n            eid: EntityId = f\"java:import:{fqn}\"\n            if eid not in self._entities:\n                self._entities[eid] = Entity(\n                    id=eid,\n                    kind=\"type\",\n                    uri=f\"program://{self.program_id}/java_type/{fqn}\",\n                    artifact_uri=None,\n                    span=None,\n                    labels=[\"kind:type\", \"lang:java\"],\n                    attributes={\"fqn\": fqn},\n                )\n            self._edges.append(\n                Edge(\n                    src=src_eid,\n                    dst=eid,\n                    type=\"imports\",\n                    attributes={\"lang\": \"java\"},\n                )\n            )\n\n    def _add_js_like_imports(self, abs_fp: str) -> None:\n        src_eid = self._file_entity_for_abs.get(os.path.abspath(abs_fp))\n        if not src_eid:\n            return\n        try:\n            with open(abs_fp, \"r\", encoding=\"utf-8\", errors=\"ignore\") as fh:\n                text = fh.read()\n        except Exception:\n            return\n        rel = os.path.relpath(abs_fp, self.repo_root).replace(\"\\\\\", \"/\")\n        base_dir = os.path.dirname(os.path.abspath(abs_fp))\n\n        specs: Set[str] = set()\n        # import x from 'spec';  import 'spec';\n        for m in re.finditer(r'^\\s*import\\s+(?:.+?\\s+from\\s+)?[\\'\"](.+?)[\\'\"]', text, re.MULTILINE):\n            specs.add(m.group(1).strip())\n        # require('spec')\n        for m in re.finditer(r'require\\(\\s*[\\'\"](.+?)[\\'\"]\\s*\\)', text):\n            specs.add(m.group(1).strip())\n\n        for spec in specs:\n            if not spec:\n                continue\n            if spec.startswith(\".\"):\n                # Local module → resolve to file entity if possible.\n                dst_eid = self._resolve_local_js_like_spec(base_dir, spec)\n                if dst_eid:\n                    self._edges.append(\n                        Edge(\n                            src=src_eid,\n                            dst=dst_eid,\n                            type=\"imports\",\n                            attributes={\"lang\": \"js_ts\"},\n                        )\n                    )\n            else:\n                # External package\n                eid: EntityId = f\"js:pkg:{spec}\"\n                if eid not in self._entities:\n                    self._entities[eid] = Entity(\n                        id=eid,\n                        kind=\"package\",\n                        uri=f\"program://{self.program_id}/js_pkg/{spec}\",\n                        artifact_uri=None,\n                        span=None,\n                        labels=[\"kind:package\", \"lang:js\"],\n                        attributes={\"package\": spec},\n                    )\n                self._edges.append(\n                    Edge(\n                        src=src_eid,\n                        dst=eid,\n                        type=\"imports\",\n                        attributes={\"lang\": \"js_ts\"},\n                    )\n                )\n\n    def _resolve_local_js_like_spec(self, base_dir: str, spec: str) -> Optional[EntityId]:\n        # Resolve \"./foo\" style specifiers to actual files if present.\n        # Try with and without common JS/TS extensions.\n        exts = [\"\", \".js\", \".jsx\", \".mjs\", \".ts\", \".tsx\"]\n        for ext in exts:\n            cand = spec\n            if not cand.endswith(ext):\n                cand = spec + ext\n            abs_cand = os.path.abspath(os.path.join(base_dir, cand))\n            eid = self._file_entity_for_abs.get(abs_cand)\n            if eid:\n                return eid\n        return None\n\n    def _ingest_python_codegraph(self, cg: Any) -> None:\n        \"\"\"\n        Integrate a scripts.codegraph_core.CodeGraph instance as one backend.\n\n        This adds:\n          - Module / function / class entities for Python.\n          - \"owns\" edges from file entities to these symbols.\n          - \"imports\" / \"calls\" / \"tests\" edges as provided by the backend.\n        \"\"\"\n        # Entities\n        for ent in cg.entities():\n            abs_file = os.path.abspath(getattr(ent, \"file\", \"\"))\n            file_eid = self._file_entity_for_abs.get(abs_file)\n# ... truncated ...","source_hash":"cbc0aa5dcdb8bd7bf8e739e35d1190516934c4d470257d2017a31f88c0b7f173","truncated":true}
{"repo_id":"TOLBERT","entity_id":"py:scripts.repo_graph.program_id_for_repo","uri":"program://TOLBERT/function/scripts.repo_graph.program_id_for_repo#L11-L13","kind":"function","name":"program_id_for_repo","path":"scripts/repo_graph.py","language":"python","start_line":11,"end_line":13,"context_start_line":1,"context_end_line":33,"code":"from __future__ import annotations\n\nimport os\nimport re\nimport hashlib\nfrom typing import Iterable, List, Tuple, Dict, Optional, Set, Any\n\nfrom modules.program_graph import ProgramGraph, Entity, Edge, Artifact, Span, ResolvedAnchor, EntityId\n\n\ndef program_id_for_repo(repo_root: str) -> str:\n    base = os.path.basename(os.path.abspath(repo_root)) or \"repo\"\n    return base\n\n\ndef artifact_uri(program_id: str, rel_path: str) -> str:\n    rel = rel_path.replace(\"\\\\\", \"/\").lstrip(\"/\")\n    return f\"program://{program_id}/artifact/{rel}\"\n\n\ndef parse_program_uri(uri: str) -> Tuple[str, str, str, Optional[Tuple[int, int]]]:\n    m = re.match(r\"^program://([^/]+)/([^/]+)/(.+?)(?:#L(\\d+)-L(\\d+))?$\", uri)\n    if not m:\n        raise ValueError(f\"invalid program uri: {uri}\")\n    pid, kind, res, a, b = m.group(1), m.group(2), m.group(3), m.group(4), m.group(5)\n    span = (int(a), int(b)) if (a and b) else None\n    return pid, kind, res, span\n\n\nclass RepoGraph(ProgramGraph):\n    def __init__(self, repo_root: str, ignore: Optional[List[str]] = None):\n        self.repo_root = os.path.abspath(repo_root)\n        self.program_id = program_id_for_repo(self.repo_root)","source_hash":"cbc0aa5dcdb8bd7bf8e739e35d1190516934c4d470257d2017a31f88c0b7f173","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.repo_graph.artifact_uri","uri":"program://TOLBERT/function/scripts.repo_graph.artifact_uri#L16-L18","kind":"function","name":"artifact_uri","path":"scripts/repo_graph.py","language":"python","start_line":16,"end_line":18,"context_start_line":1,"context_end_line":38,"code":"from __future__ import annotations\n\nimport os\nimport re\nimport hashlib\nfrom typing import Iterable, List, Tuple, Dict, Optional, Set, Any\n\nfrom modules.program_graph import ProgramGraph, Entity, Edge, Artifact, Span, ResolvedAnchor, EntityId\n\n\ndef program_id_for_repo(repo_root: str) -> str:\n    base = os.path.basename(os.path.abspath(repo_root)) or \"repo\"\n    return base\n\n\ndef artifact_uri(program_id: str, rel_path: str) -> str:\n    rel = rel_path.replace(\"\\\\\", \"/\").lstrip(\"/\")\n    return f\"program://{program_id}/artifact/{rel}\"\n\n\ndef parse_program_uri(uri: str) -> Tuple[str, str, str, Optional[Tuple[int, int]]]:\n    m = re.match(r\"^program://([^/]+)/([^/]+)/(.+?)(?:#L(\\d+)-L(\\d+))?$\", uri)\n    if not m:\n        raise ValueError(f\"invalid program uri: {uri}\")\n    pid, kind, res, a, b = m.group(1), m.group(2), m.group(3), m.group(4), m.group(5)\n    span = (int(a), int(b)) if (a and b) else None\n    return pid, kind, res, span\n\n\nclass RepoGraph(ProgramGraph):\n    def __init__(self, repo_root: str, ignore: Optional[List[str]] = None):\n        self.repo_root = os.path.abspath(repo_root)\n        self.program_id = program_id_for_repo(self.repo_root)\n        self.ignore_rules = [s for s in (ignore or []) if s]\n        self._file_hash: Dict[str, str] = {}\n        # Cached graph views\n        self._entities: Dict[EntityId, Entity] = {}\n        self._edges: List[Edge] = []","source_hash":"cbc0aa5dcdb8bd7bf8e739e35d1190516934c4d470257d2017a31f88c0b7f173","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.repo_graph.parse_program_uri","uri":"program://TOLBERT/function/scripts.repo_graph.parse_program_uri#L21-L27","kind":"function","name":"parse_program_uri","path":"scripts/repo_graph.py","language":"python","start_line":21,"end_line":27,"context_start_line":1,"context_end_line":47,"code":"from __future__ import annotations\n\nimport os\nimport re\nimport hashlib\nfrom typing import Iterable, List, Tuple, Dict, Optional, Set, Any\n\nfrom modules.program_graph import ProgramGraph, Entity, Edge, Artifact, Span, ResolvedAnchor, EntityId\n\n\ndef program_id_for_repo(repo_root: str) -> str:\n    base = os.path.basename(os.path.abspath(repo_root)) or \"repo\"\n    return base\n\n\ndef artifact_uri(program_id: str, rel_path: str) -> str:\n    rel = rel_path.replace(\"\\\\\", \"/\").lstrip(\"/\")\n    return f\"program://{program_id}/artifact/{rel}\"\n\n\ndef parse_program_uri(uri: str) -> Tuple[str, str, str, Optional[Tuple[int, int]]]:\n    m = re.match(r\"^program://([^/]+)/([^/]+)/(.+?)(?:#L(\\d+)-L(\\d+))?$\", uri)\n    if not m:\n        raise ValueError(f\"invalid program uri: {uri}\")\n    pid, kind, res, a, b = m.group(1), m.group(2), m.group(3), m.group(4), m.group(5)\n    span = (int(a), int(b)) if (a and b) else None\n    return pid, kind, res, span\n\n\nclass RepoGraph(ProgramGraph):\n    def __init__(self, repo_root: str, ignore: Optional[List[str]] = None):\n        self.repo_root = os.path.abspath(repo_root)\n        self.program_id = program_id_for_repo(self.repo_root)\n        self.ignore_rules = [s for s in (ignore or []) if s]\n        self._file_hash: Dict[str, str] = {}\n        # Cached graph views\n        self._entities: Dict[EntityId, Entity] = {}\n        self._edges: List[Edge] = []\n        self._built: bool = False\n        # Convenience indices\n        #   - absolute file path → file-entity id\n        #   - symbol name (lowercased) → list of entity ids\n        self._file_entity_for_abs: Dict[str, EntityId] = {}\n        self._symbols_by_name: Dict[str, List[EntityId]] = {}\n\n    # ProgramGraph: core views\n    def entities(self) -> Iterable[Entity]:","source_hash":"cbc0aa5dcdb8bd7bf8e739e35d1190516934c4d470257d2017a31f88c0b7f173","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.repo_graph.RepoGraph","uri":"program://TOLBERT/class/scripts.repo_graph.RepoGraph#L30-L731","kind":"class","name":"RepoGraph","path":"scripts/repo_graph.py","language":"python","start_line":30,"end_line":731,"context_start_line":10,"context_end_line":733,"code":"\ndef program_id_for_repo(repo_root: str) -> str:\n    base = os.path.basename(os.path.abspath(repo_root)) or \"repo\"\n    return base\n\n\ndef artifact_uri(program_id: str, rel_path: str) -> str:\n    rel = rel_path.replace(\"\\\\\", \"/\").lstrip(\"/\")\n    return f\"program://{program_id}/artifact/{rel}\"\n\n\ndef parse_program_uri(uri: str) -> Tuple[str, str, str, Optional[Tuple[int, int]]]:\n    m = re.match(r\"^program://([^/]+)/([^/]+)/(.+?)(?:#L(\\d+)-L(\\d+))?$\", uri)\n    if not m:\n        raise ValueError(f\"invalid program uri: {uri}\")\n    pid, kind, res, a, b = m.group(1), m.group(2), m.group(3), m.group(4), m.group(5)\n    span = (int(a), int(b)) if (a and b) else None\n    return pid, kind, res, span\n\n\nclass RepoGraph(ProgramGraph):\n    def __init__(self, repo_root: str, ignore: Optional[List[str]] = None):\n        self.repo_root = os.path.abspath(repo_root)\n        self.program_id = program_id_for_repo(self.repo_root)\n        self.ignore_rules = [s for s in (ignore or []) if s]\n        self._file_hash: Dict[str, str] = {}\n        # Cached graph views\n        self._entities: Dict[EntityId, Entity] = {}\n        self._edges: List[Edge] = []\n        self._built: bool = False\n        # Convenience indices\n        #   - absolute file path → file-entity id\n        #   - symbol name (lowercased) → list of entity ids\n        self._file_entity_for_abs: Dict[str, EntityId] = {}\n        self._symbols_by_name: Dict[str, List[EntityId]] = {}\n\n    # ProgramGraph: core views\n    def entities(self) -> Iterable[Entity]:\n        self._ensure_built()\n        return self._entities.values()\n\n    def edges(self) -> Iterable[Edge]:\n        self._ensure_built()\n        return list(self._edges)\n\n    def search_refs(self, token: str) -> Iterable[Tuple[EntityId, Span]]:\n        return []\n\n    def subgraph(self, seeds: List[EntityId], radius: int) -> \"ProgramGraph\":\n        if not seeds or radius <= 0:\n            return self\n        # Generic BFS over current edges view\n        adj: Dict[str, List[str]] = {}\n        for e in self.edges():\n            adj.setdefault(e.src, []).append(e.dst)\n            adj.setdefault(e.dst, []).append(e.src)\n        cur = set(seeds)\n        seen = set(cur)\n        for _ in range(max(1, radius)):\n            nxt: Set[str] = set()\n            for s in list(cur):\n                for nb in adj.get(s, []):\n                    if nb not in seen:\n                        seen.add(nb)\n                        nxt.add(nb)\n            cur = nxt\n        # For now, RepoGraph exposes a single global view; callers that need\n        # an actual induced subgraph can post-filter entities/edges.\n        return self  # pragma: no cover - view semantics only\n\n    def artifacts(self, kind: str) -> Iterable[Artifact]:\n        if kind not in (\"artifact\", \"source\"):\n            return []\n        self._ensure_built()\n        out: List[Artifact] = []\n        for fp in self._discover_files(self.repo_root, self.ignore_rules):\n            rel = os.path.relpath(fp, self.repo_root).replace(\"\\\\\", \"/\")\n            out.append(\n                Artifact(\n                    uri=artifact_uri(self.program_id, rel),\n                    type=\"source\",\n                    hash=self._hash_for(fp),\n                    span=None,\n                )\n            )\n        return out\n\n    def resolve(self, uri: str) -> ResolvedAnchor:\n        pid, kind, res, span = parse_program_uri(uri)\n        if pid != self.program_id:\n            raise ValueError(f\"program id mismatch: {pid} != {self.program_id}\")\n        if kind == \"artifact\":\n            abs_fp = os.path.abspath(os.path.join(self.repo_root, res))\n            if not os.path.isfile(abs_fp):\n                raise FileNotFoundError(f\"artifact not found: {abs_fp}\")\n            a = int(span[0]) if span else 1\n            b = int(span[1]) if span else self._safe_count_lines(abs_fp)\n            rel = os.path.relpath(abs_fp, self.repo_root).replace(\"\\\\\", \"/\")\n            return ResolvedAnchor(\n                artifact_uri=artifact_uri(self.program_id, rel),\n                span=Span(start_line=a, end_line=b),\n                hash=self._hash_for(abs_fp),\n            )\n        # Let subclass handle entity URIs\n        return self._resolve_entity_uri(kind, res, span)\n\n    # Hooks for subclasses\n    def _resolve_entity_uri(self, kind: str, resource: str, span: Optional[Tuple[int, int]]) -> ResolvedAnchor:\n        raise KeyError(f\"unrecognized entity uri for kind={kind}, resource={resource}\")\n\n    # Build / utilities\n    def _ensure_built(self) -> None:\n        if self._built:\n            return\n        self._build_graph()\n        self._built = True\n\n    def _build_graph(self) -> None:\n        \"\"\"\n        Populate entity and edge sets for this repository.\n\n        This is intentionally language-agnostic at the core:\n          - Always creates a repo-level entity.\n          - Always creates file-level entities for discovered source artifacts.\n\n        Language-specific structure (imports, calls, packages / modules) is\n        layered on top via simple heuristics and optional backends.\n        \"\"\"\n        # Repo entity\n        repo_eid: EntityId = f\"repo:{self.program_id}\"\n        if repo_eid not in self._entities:\n            self._entities[repo_eid] = Entity(\n                id=repo_eid,\n                kind=\"repo\",\n                uri=f\"program://{self.program_id}/repo\",\n                artifact_uri=None,\n                span=None,\n                labels=[\"kind:repo\"],\n                attributes={\"root\": self.repo_root},\n            )\n\n        # Discover files and create file-level entities\n        files = self._discover_files(self.repo_root, self.ignore_rules)\n        for fp in files:\n            rel = os.path.relpath(fp, self.repo_root).replace(\"\\\\\", \"/\")\n            uri = artifact_uri(self.program_id, rel)\n            labels = [\"kind:file\"] + self._language_labels_for(rel)\n            eid: EntityId = uri  # stable id tied to artifact URI\n            if eid not in self._entities:\n                self._entities[eid] = Entity(\n                    id=eid,\n                    kind=\"file\",\n                    uri=uri,\n                    artifact_uri=uri,\n                    span=None,\n                    labels=labels,\n                    attributes={\"rel_path\": rel},\n                )\n            self._file_entity_for_abs[os.path.abspath(fp)] = eid\n            # Repo \"owns\" file\n            self._edges.append(\n                Edge(\n                    src=repo_eid,\n                    dst=eid,\n                    type=\"owns\",\n                    attributes={},\n                )\n            )\n\n        # Language-specific edges and entities.\n        self._build_language_edges_and_entities(files)\n\n    def _build_language_edges_and_entities(self, files: List[str]) -> None:\n        \"\"\"\n        Add language-specific structure for supported stacks.\n\n        - C / C++: file-level imports from #include relationships.\n        - Go: package entities and import edges.\n        - Java: imported type entities and import edges.\n        - JS / TS: module/file imports from ES modules / require().\n        - Python: optional integration via scripts.codegraph_core.CodeGraph\n          for module / function / class entities and imports / calls.\n        \"\"\"\n        # Best-effort C / C++ / Go / Java / JS import graphs\n        for abs_fp in files:\n            rel = os.path.relpath(abs_fp, self.repo_root).replace(\"\\\\\", \"/\")\n            _, ext = os.path.splitext(rel.lower())\n            if ext in (\".c\", \".h\", \".cc\", \".cpp\", \".cxx\", \".hpp\"):\n                self._add_c_includes(abs_fp)\n            elif ext == \".go\":\n                self._add_go_imports(abs_fp)\n            elif ext == \".java\":\n                self._add_java_imports(abs_fp)\n            elif ext in (\".js\", \".jsx\", \".mjs\", \".ts\", \".tsx\"):\n                self._add_js_like_imports(abs_fp)\n\n        # Optional: richer Python graph via scripts.codegraph_core\n        try:\n            from scripts.codegraph_core import CodeGraph as _PyCodeGraph  # type: ignore\n        except Exception:\n            _PyCodeGraph = None  # type: ignore\n\n        if _PyCodeGraph is not None:\n            try:\n                cg = _PyCodeGraph(self.repo_root, ignore=self.ignore_rules).build()\n            except Exception:\n                cg = None\n            if cg is not None:\n                self._ingest_python_codegraph(cg)\n\n        # Non-Python symbol entities + heuristic call graph.\n        self._add_non_python_symbols_and_calls(files)\n\n    def _discover_files(self, root: str, ignore: List[str]) -> List[str]:\n        out: List[str] = []\n        for dirpath, dirnames, filenames in os.walk(root):\n            if any(ig and ig in dirpath for ig in ignore):\n                continue\n            for fn in filenames:\n                ap = os.path.abspath(os.path.join(dirpath, fn))\n                out.append(ap)\n        return out\n\n    def _language_labels_for(self, rel_path: str) -> List[str]:\n        \"\"\"\n        Best-effort language tags for a repo-relative path based on extension.\n\n        These are intentionally coarse and are only used to annotate entities\n        (e.g., file-level entities) so that downstream tools can filter or\n        group by language family when needed.\n        \"\"\"\n        _, ext = os.path.splitext(rel_path.lower())\n        labels: List[str] = []\n        if ext == \".py\":\n            labels.append(\"lang:python\")\n        elif ext in (\".c\", \".h\"):\n            labels.append(\"lang:c\")\n        elif ext in (\".cc\", \".cpp\", \".cxx\", \".hpp\"):\n            labels.append(\"lang:cpp\")\n        elif ext in (\".js\", \".jsx\", \".mjs\"):\n            labels.append(\"lang:js\")\n        elif ext in (\".ts\", \".tsx\"):\n            labels.append(\"lang:ts\")\n        elif ext == \".go\":\n            labels.append(\"lang:go\")\n        elif ext == \".java\":\n            labels.append(\"lang:java\")\n        elif ext == \".md\":\n            labels.append(\"lang:markdown\")\n        return labels\n\n    def _safe_count_lines(self, abs_file: str) -> int:\n        try:\n            with open(abs_file, \"r\", encoding=\"utf-8\", errors=\"ignore\") as fh:\n                return sum(1 for _ in fh)\n        except Exception:\n            return 1\n\n    def _hash_for(self, abs_file: str) -> str:\n        if abs_file in self._file_hash:\n            return self._file_hash[abs_file]\n        try:\n            with open(abs_file, \"rb\") as fh:\n                raw = fh.read()\n            h = hashlib.sha256(raw).hexdigest()\n        except Exception:\n            h = \"\"\n        self._file_hash[abs_file] = h\n        return h\n\n    # --- Language-specific helpers ---\n\n    def _add_symbol_entity(\n        self,\n        abs_fp: str,\n        name: str,\n        kind: str,\n        lang_label: str,\n        start_line: int,\n        end_line: int,\n    ) -> Optional[EntityId]:\n        abs_fp = os.path.abspath(abs_fp)\n        file_eid = self._file_entity_for_abs.get(abs_fp)\n        if not file_eid:\n            return None\n        # Stable id: lang-specific prefix + file rel path + symbol name.\n        rel = os.path.relpath(abs_fp, self.repo_root).replace(\"\\\\\", \"/\")\n        sym_id: EntityId = f\"{lang_label}:{rel}:{name}\"\n        if sym_id in self._entities:\n            return sym_id\n        file_ent = self._entities[file_eid]\n        span = Span(start_line=int(start_line), end_line=int(end_line))\n        uri = f\"program://{self.program_id}/sym/{lang_label}/{rel}#{name}\"\n        labels = [f\"kind:{kind}\", f\"lang:{lang_label}\"]\n        self._entities[sym_id] = Entity(\n            id=sym_id,\n            kind=kind,\n            uri=uri,\n            artifact_uri=file_ent.artifact_uri,\n            span=span,\n            labels=labels,\n            attributes={\"name\": name, \"file\": rel},\n        )\n        # file \"owns\" symbol\n        self._edges.append(\n            Edge(\n                src=file_eid,\n                dst=sym_id,\n                type=\"owns\",\n                attributes={\"lang\": lang_label},\n            )\n        )\n        self._symbols_by_name.setdefault(name.lower(), []).append(sym_id)\n        return sym_id\n\n    def _add_c_includes(self, abs_fp: str) -> None:\n        src_eid = self._file_entity_for_abs.get(os.path.abspath(abs_fp))\n        if not src_eid:\n            return\n        try:\n            with open(abs_fp, \"r\", encoding=\"utf-8\", errors=\"ignore\") as fh:\n                text = fh.read()\n        except Exception:\n            return\n        # Match #include \"local.h\" and #include <local.h>\n        rx = re.compile(r'^\\s*#\\s*include\\s*[<\"]([^\">]+)[\">]', re.MULTILINE)\n        for m in rx.finditer(text):\n            target = m.group(1).strip()\n            if not target:\n                continue\n            # Resolve relative to current directory; ignore obvious system headers.\n            if \"/\" not in target and \"\\\\\" not in target and \".\" not in target:\n                continue\n            cand = os.path.abspath(os.path.join(os.path.dirname(abs_fp), target))\n            dst_eid = self._file_entity_for_abs.get(cand)\n            if not dst_eid:\n                continue\n            self._edges.append(\n                Edge(\n                    src=src_eid,\n                    dst=dst_eid,\n                    type=\"imports\",\n                    attributes={\"lang\": \"c_cpp\"},\n                )\n            )\n\n    def _add_go_imports(self, abs_fp: str) -> None:\n        src_eid = self._file_entity_for_abs.get(os.path.abspath(abs_fp))\n        if not src_eid:\n            return\n        try:\n            with open(abs_fp, \"r\", encoding=\"utf-8\", errors=\"ignore\") as fh:\n                lines = fh.readlines()\n        except Exception:\n            return\n        in_block = False\n        for ln in lines:\n            stripped = ln.strip()\n            if stripped.startswith(\"import \"):\n                # Single-line: import \"pkg/path\"\n                in_block = \"(\" in stripped and not stripped.rstrip().endswith(\")\")\n                m = re.search(r'[\"`](.+?)[\"`]', stripped)\n                if m:\n                    pkg = m.group(1).strip()\n                    self._add_go_import_edge(src_eid, pkg)\n            elif in_block:\n                if stripped.startswith(\")\"):\n                    in_block = False\n                    continue\n                m = re.search(r'[\"`](.+?)[\"`]', stripped)\n                if m:\n                    pkg = m.group(1).strip()\n                    self._add_go_import_edge(src_eid, pkg)\n\n    def _add_go_import_edge(self, src_eid: EntityId, pkg: str) -> None:\n        if not pkg:\n            return\n        eid: EntityId = f\"go:pkg:{pkg}\"\n        if eid not in self._entities:\n            self._entities[eid] = Entity(\n                id=eid,\n                kind=\"package\",\n                uri=f\"program://{self.program_id}/go_pkg/{pkg}\",\n                artifact_uri=None,\n                span=None,\n                labels=[\"kind:package\", \"lang:go\"],\n                attributes={\"package\": pkg},\n            )\n        self._edges.append(\n            Edge(\n                src=src_eid,\n                dst=eid,\n                type=\"imports\",\n                    attributes={\"lang\": \"go\"},\n            )\n        )\n\n    def _add_java_imports(self, abs_fp: str) -> None:\n        src_eid = self._file_entity_for_abs.get(os.path.abspath(abs_fp))\n        if not src_eid:\n            return\n        try:\n            with open(abs_fp, \"r\", encoding=\"utf-8\", errors=\"ignore\") as fh:\n                text = fh.read()\n        except Exception:\n            return\n        rx = re.compile(r'^\\s*import\\s+(static\\s+)?([a-zA-Z0-9_.]+)\\s*;', re.MULTILINE)\n        for m in rx.finditer(text):\n            fqn = m.group(2)\n            if not fqn:\n                continue\n            eid: EntityId = f\"java:import:{fqn}\"\n            if eid not in self._entities:\n                self._entities[eid] = Entity(\n                    id=eid,\n                    kind=\"type\",\n                    uri=f\"program://{self.program_id}/java_type/{fqn}\",\n                    artifact_uri=None,\n                    span=None,\n                    labels=[\"kind:type\", \"lang:java\"],\n                    attributes={\"fqn\": fqn},\n                )\n            self._edges.append(\n                Edge(\n                    src=src_eid,\n                    dst=eid,\n                    type=\"imports\",\n                    attributes={\"lang\": \"java\"},\n                )\n            )\n\n    def _add_js_like_imports(self, abs_fp: str) -> None:\n        src_eid = self._file_entity_for_abs.get(os.path.abspath(abs_fp))\n        if not src_eid:\n            return\n        try:\n            with open(abs_fp, \"r\", encoding=\"utf-8\", errors=\"ignore\") as fh:\n                text = fh.read()\n        except Exception:\n            return\n        rel = os.path.relpath(abs_fp, self.repo_root).replace(\"\\\\\", \"/\")\n        base_dir = os.path.dirname(os.path.abspath(abs_fp))\n\n        specs: Set[str] = set()\n        # import x from 'spec';  import 'spec';\n        for m in re.finditer(r'^\\s*import\\s+(?:.+?\\s+from\\s+)?[\\'\"](.+?)[\\'\"]', text, re.MULTILINE):\n            specs.add(m.group(1).strip())\n        # require('spec')\n        for m in re.finditer(r'require\\(\\s*[\\'\"](.+?)[\\'\"]\\s*\\)', text):\n            specs.add(m.group(1).strip())\n\n        for spec in specs:\n            if not spec:\n                continue\n            if spec.startswith(\".\"):\n                # Local module → resolve to file entity if possible.\n                dst_eid = self._resolve_local_js_like_spec(base_dir, spec)\n                if dst_eid:\n                    self._edges.append(\n                        Edge(\n                            src=src_eid,\n                            dst=dst_eid,\n                            type=\"imports\",\n                            attributes={\"lang\": \"js_ts\"},\n                        )\n                    )\n            else:\n                # External package\n                eid: EntityId = f\"js:pkg:{spec}\"\n                if eid not in self._entities:\n                    self._entities[eid] = Entity(\n                        id=eid,\n                        kind=\"package\",\n                        uri=f\"program://{self.program_id}/js_pkg/{spec}\",\n                        artifact_uri=None,\n                        span=None,\n                        labels=[\"kind:package\", \"lang:js\"],\n                        attributes={\"package\": spec},\n                    )\n                self._edges.append(\n                    Edge(\n                        src=src_eid,\n                        dst=eid,\n                        type=\"imports\",\n                        attributes={\"lang\": \"js_ts\"},\n                    )\n                )\n\n    def _resolve_local_js_like_spec(self, base_dir: str, spec: str) -> Optional[EntityId]:\n        # Resolve \"./foo\" style specifiers to actual files if present.\n        # Try with and without common JS/TS extensions.\n        exts = [\"\", \".js\", \".jsx\", \".mjs\", \".ts\", \".tsx\"]\n        for ext in exts:\n            cand = spec\n            if not cand.endswith(ext):\n                cand = spec + ext\n            abs_cand = os.path.abspath(os.path.join(base_dir, cand))\n            eid = self._file_entity_for_abs.get(abs_cand)\n            if eid:\n                return eid\n        return None\n\n    def _ingest_python_codegraph(self, cg: Any) -> None:\n        \"\"\"\n        Integrate a scripts.codegraph_core.CodeGraph instance as one backend.\n\n        This adds:\n          - Module / function / class entities for Python.\n          - \"owns\" edges from file entities to these symbols.\n          - \"imports\" / \"calls\" / \"tests\" edges as provided by the backend.\n        \"\"\"\n        # Entities\n        for ent in cg.entities():\n            abs_file = os.path.abspath(getattr(ent, \"file\", \"\"))\n            file_eid = self._file_entity_for_abs.get(abs_file)\n            if not file_eid:\n                continue\n            eid: EntityId = getattr(ent, \"id\")\n            if eid in self._entities:\n                continue\n            span = Span(start_line=int(ent.start_line), end_line=int(ent.end_line))\n# ... truncated ...","source_hash":"cbc0aa5dcdb8bd7bf8e739e35d1190516934c4d470257d2017a31f88c0b7f173","truncated":true}
{"repo_id":"TOLBERT","entity_id":"py:scripts.repo_graph.__init__","uri":"program://TOLBERT/function/scripts.repo_graph.__init__#L31-L44","kind":"function","name":"__init__","path":"scripts/repo_graph.py","language":"python","start_line":31,"end_line":44,"context_start_line":11,"context_end_line":64,"code":"def program_id_for_repo(repo_root: str) -> str:\n    base = os.path.basename(os.path.abspath(repo_root)) or \"repo\"\n    return base\n\n\ndef artifact_uri(program_id: str, rel_path: str) -> str:\n    rel = rel_path.replace(\"\\\\\", \"/\").lstrip(\"/\")\n    return f\"program://{program_id}/artifact/{rel}\"\n\n\ndef parse_program_uri(uri: str) -> Tuple[str, str, str, Optional[Tuple[int, int]]]:\n    m = re.match(r\"^program://([^/]+)/([^/]+)/(.+?)(?:#L(\\d+)-L(\\d+))?$\", uri)\n    if not m:\n        raise ValueError(f\"invalid program uri: {uri}\")\n    pid, kind, res, a, b = m.group(1), m.group(2), m.group(3), m.group(4), m.group(5)\n    span = (int(a), int(b)) if (a and b) else None\n    return pid, kind, res, span\n\n\nclass RepoGraph(ProgramGraph):\n    def __init__(self, repo_root: str, ignore: Optional[List[str]] = None):\n        self.repo_root = os.path.abspath(repo_root)\n        self.program_id = program_id_for_repo(self.repo_root)\n        self.ignore_rules = [s for s in (ignore or []) if s]\n        self._file_hash: Dict[str, str] = {}\n        # Cached graph views\n        self._entities: Dict[EntityId, Entity] = {}\n        self._edges: List[Edge] = []\n        self._built: bool = False\n        # Convenience indices\n        #   - absolute file path → file-entity id\n        #   - symbol name (lowercased) → list of entity ids\n        self._file_entity_for_abs: Dict[str, EntityId] = {}\n        self._symbols_by_name: Dict[str, List[EntityId]] = {}\n\n    # ProgramGraph: core views\n    def entities(self) -> Iterable[Entity]:\n        self._ensure_built()\n        return self._entities.values()\n\n    def edges(self) -> Iterable[Edge]:\n        self._ensure_built()\n        return list(self._edges)\n\n    def search_refs(self, token: str) -> Iterable[Tuple[EntityId, Span]]:\n        return []\n\n    def subgraph(self, seeds: List[EntityId], radius: int) -> \"ProgramGraph\":\n        if not seeds or radius <= 0:\n            return self\n        # Generic BFS over current edges view\n        adj: Dict[str, List[str]] = {}\n        for e in self.edges():\n            adj.setdefault(e.src, []).append(e.dst)","source_hash":"cbc0aa5dcdb8bd7bf8e739e35d1190516934c4d470257d2017a31f88c0b7f173","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.repo_graph.entities","uri":"program://TOLBERT/function/scripts.repo_graph.entities#L47-L49","kind":"function","name":"entities","path":"scripts/repo_graph.py","language":"python","start_line":47,"end_line":49,"context_start_line":27,"context_end_line":69,"code":"    return pid, kind, res, span\n\n\nclass RepoGraph(ProgramGraph):\n    def __init__(self, repo_root: str, ignore: Optional[List[str]] = None):\n        self.repo_root = os.path.abspath(repo_root)\n        self.program_id = program_id_for_repo(self.repo_root)\n        self.ignore_rules = [s for s in (ignore or []) if s]\n        self._file_hash: Dict[str, str] = {}\n        # Cached graph views\n        self._entities: Dict[EntityId, Entity] = {}\n        self._edges: List[Edge] = []\n        self._built: bool = False\n        # Convenience indices\n        #   - absolute file path → file-entity id\n        #   - symbol name (lowercased) → list of entity ids\n        self._file_entity_for_abs: Dict[str, EntityId] = {}\n        self._symbols_by_name: Dict[str, List[EntityId]] = {}\n\n    # ProgramGraph: core views\n    def entities(self) -> Iterable[Entity]:\n        self._ensure_built()\n        return self._entities.values()\n\n    def edges(self) -> Iterable[Edge]:\n        self._ensure_built()\n        return list(self._edges)\n\n    def search_refs(self, token: str) -> Iterable[Tuple[EntityId, Span]]:\n        return []\n\n    def subgraph(self, seeds: List[EntityId], radius: int) -> \"ProgramGraph\":\n        if not seeds or radius <= 0:\n            return self\n        # Generic BFS over current edges view\n        adj: Dict[str, List[str]] = {}\n        for e in self.edges():\n            adj.setdefault(e.src, []).append(e.dst)\n            adj.setdefault(e.dst, []).append(e.src)\n        cur = set(seeds)\n        seen = set(cur)\n        for _ in range(max(1, radius)):\n            nxt: Set[str] = set()","source_hash":"cbc0aa5dcdb8bd7bf8e739e35d1190516934c4d470257d2017a31f88c0b7f173","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.repo_graph.edges","uri":"program://TOLBERT/function/scripts.repo_graph.edges#L51-L53","kind":"function","name":"edges","path":"scripts/repo_graph.py","language":"python","start_line":51,"end_line":53,"context_start_line":31,"context_end_line":73,"code":"    def __init__(self, repo_root: str, ignore: Optional[List[str]] = None):\n        self.repo_root = os.path.abspath(repo_root)\n        self.program_id = program_id_for_repo(self.repo_root)\n        self.ignore_rules = [s for s in (ignore or []) if s]\n        self._file_hash: Dict[str, str] = {}\n        # Cached graph views\n        self._entities: Dict[EntityId, Entity] = {}\n        self._edges: List[Edge] = []\n        self._built: bool = False\n        # Convenience indices\n        #   - absolute file path → file-entity id\n        #   - symbol name (lowercased) → list of entity ids\n        self._file_entity_for_abs: Dict[str, EntityId] = {}\n        self._symbols_by_name: Dict[str, List[EntityId]] = {}\n\n    # ProgramGraph: core views\n    def entities(self) -> Iterable[Entity]:\n        self._ensure_built()\n        return self._entities.values()\n\n    def edges(self) -> Iterable[Edge]:\n        self._ensure_built()\n        return list(self._edges)\n\n    def search_refs(self, token: str) -> Iterable[Tuple[EntityId, Span]]:\n        return []\n\n    def subgraph(self, seeds: List[EntityId], radius: int) -> \"ProgramGraph\":\n        if not seeds or radius <= 0:\n            return self\n        # Generic BFS over current edges view\n        adj: Dict[str, List[str]] = {}\n        for e in self.edges():\n            adj.setdefault(e.src, []).append(e.dst)\n            adj.setdefault(e.dst, []).append(e.src)\n        cur = set(seeds)\n        seen = set(cur)\n        for _ in range(max(1, radius)):\n            nxt: Set[str] = set()\n            for s in list(cur):\n                for nb in adj.get(s, []):\n                    if nb not in seen:\n                        seen.add(nb)","source_hash":"cbc0aa5dcdb8bd7bf8e739e35d1190516934c4d470257d2017a31f88c0b7f173","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.repo_graph.search_refs","uri":"program://TOLBERT/function/scripts.repo_graph.search_refs#L55-L56","kind":"function","name":"search_refs","path":"scripts/repo_graph.py","language":"python","start_line":55,"end_line":56,"context_start_line":35,"context_end_line":76,"code":"        self._file_hash: Dict[str, str] = {}\n        # Cached graph views\n        self._entities: Dict[EntityId, Entity] = {}\n        self._edges: List[Edge] = []\n        self._built: bool = False\n        # Convenience indices\n        #   - absolute file path → file-entity id\n        #   - symbol name (lowercased) → list of entity ids\n        self._file_entity_for_abs: Dict[str, EntityId] = {}\n        self._symbols_by_name: Dict[str, List[EntityId]] = {}\n\n    # ProgramGraph: core views\n    def entities(self) -> Iterable[Entity]:\n        self._ensure_built()\n        return self._entities.values()\n\n    def edges(self) -> Iterable[Edge]:\n        self._ensure_built()\n        return list(self._edges)\n\n    def search_refs(self, token: str) -> Iterable[Tuple[EntityId, Span]]:\n        return []\n\n    def subgraph(self, seeds: List[EntityId], radius: int) -> \"ProgramGraph\":\n        if not seeds or radius <= 0:\n            return self\n        # Generic BFS over current edges view\n        adj: Dict[str, List[str]] = {}\n        for e in self.edges():\n            adj.setdefault(e.src, []).append(e.dst)\n            adj.setdefault(e.dst, []).append(e.src)\n        cur = set(seeds)\n        seen = set(cur)\n        for _ in range(max(1, radius)):\n            nxt: Set[str] = set()\n            for s in list(cur):\n                for nb in adj.get(s, []):\n                    if nb not in seen:\n                        seen.add(nb)\n                        nxt.add(nb)\n            cur = nxt\n        # For now, RepoGraph exposes a single global view; callers that need","source_hash":"cbc0aa5dcdb8bd7bf8e739e35d1190516934c4d470257d2017a31f88c0b7f173","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.repo_graph.subgraph","uri":"program://TOLBERT/function/scripts.repo_graph.subgraph#L58-L78","kind":"function","name":"subgraph","path":"scripts/repo_graph.py","language":"python","start_line":58,"end_line":78,"context_start_line":38,"context_end_line":98,"code":"        self._edges: List[Edge] = []\n        self._built: bool = False\n        # Convenience indices\n        #   - absolute file path → file-entity id\n        #   - symbol name (lowercased) → list of entity ids\n        self._file_entity_for_abs: Dict[str, EntityId] = {}\n        self._symbols_by_name: Dict[str, List[EntityId]] = {}\n\n    # ProgramGraph: core views\n    def entities(self) -> Iterable[Entity]:\n        self._ensure_built()\n        return self._entities.values()\n\n    def edges(self) -> Iterable[Edge]:\n        self._ensure_built()\n        return list(self._edges)\n\n    def search_refs(self, token: str) -> Iterable[Tuple[EntityId, Span]]:\n        return []\n\n    def subgraph(self, seeds: List[EntityId], radius: int) -> \"ProgramGraph\":\n        if not seeds or radius <= 0:\n            return self\n        # Generic BFS over current edges view\n        adj: Dict[str, List[str]] = {}\n        for e in self.edges():\n            adj.setdefault(e.src, []).append(e.dst)\n            adj.setdefault(e.dst, []).append(e.src)\n        cur = set(seeds)\n        seen = set(cur)\n        for _ in range(max(1, radius)):\n            nxt: Set[str] = set()\n            for s in list(cur):\n                for nb in adj.get(s, []):\n                    if nb not in seen:\n                        seen.add(nb)\n                        nxt.add(nb)\n            cur = nxt\n        # For now, RepoGraph exposes a single global view; callers that need\n        # an actual induced subgraph can post-filter entities/edges.\n        return self  # pragma: no cover - view semantics only\n\n    def artifacts(self, kind: str) -> Iterable[Artifact]:\n        if kind not in (\"artifact\", \"source\"):\n            return []\n        self._ensure_built()\n        out: List[Artifact] = []\n        for fp in self._discover_files(self.repo_root, self.ignore_rules):\n            rel = os.path.relpath(fp, self.repo_root).replace(\"\\\\\", \"/\")\n            out.append(\n                Artifact(\n                    uri=artifact_uri(self.program_id, rel),\n                    type=\"source\",\n                    hash=self._hash_for(fp),\n                    span=None,\n                )\n            )\n        return out\n\n    def resolve(self, uri: str) -> ResolvedAnchor:\n        pid, kind, res, span = parse_program_uri(uri)","source_hash":"cbc0aa5dcdb8bd7bf8e739e35d1190516934c4d470257d2017a31f88c0b7f173","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.repo_graph.artifacts","uri":"program://TOLBERT/function/scripts.repo_graph.artifacts#L80-L95","kind":"function","name":"artifacts","path":"scripts/repo_graph.py","language":"python","start_line":80,"end_line":95,"context_start_line":60,"context_end_line":115,"code":"            return self\n        # Generic BFS over current edges view\n        adj: Dict[str, List[str]] = {}\n        for e in self.edges():\n            adj.setdefault(e.src, []).append(e.dst)\n            adj.setdefault(e.dst, []).append(e.src)\n        cur = set(seeds)\n        seen = set(cur)\n        for _ in range(max(1, radius)):\n            nxt: Set[str] = set()\n            for s in list(cur):\n                for nb in adj.get(s, []):\n                    if nb not in seen:\n                        seen.add(nb)\n                        nxt.add(nb)\n            cur = nxt\n        # For now, RepoGraph exposes a single global view; callers that need\n        # an actual induced subgraph can post-filter entities/edges.\n        return self  # pragma: no cover - view semantics only\n\n    def artifacts(self, kind: str) -> Iterable[Artifact]:\n        if kind not in (\"artifact\", \"source\"):\n            return []\n        self._ensure_built()\n        out: List[Artifact] = []\n        for fp in self._discover_files(self.repo_root, self.ignore_rules):\n            rel = os.path.relpath(fp, self.repo_root).replace(\"\\\\\", \"/\")\n            out.append(\n                Artifact(\n                    uri=artifact_uri(self.program_id, rel),\n                    type=\"source\",\n                    hash=self._hash_for(fp),\n                    span=None,\n                )\n            )\n        return out\n\n    def resolve(self, uri: str) -> ResolvedAnchor:\n        pid, kind, res, span = parse_program_uri(uri)\n        if pid != self.program_id:\n            raise ValueError(f\"program id mismatch: {pid} != {self.program_id}\")\n        if kind == \"artifact\":\n            abs_fp = os.path.abspath(os.path.join(self.repo_root, res))\n            if not os.path.isfile(abs_fp):\n                raise FileNotFoundError(f\"artifact not found: {abs_fp}\")\n            a = int(span[0]) if span else 1\n            b = int(span[1]) if span else self._safe_count_lines(abs_fp)\n            rel = os.path.relpath(abs_fp, self.repo_root).replace(\"\\\\\", \"/\")\n            return ResolvedAnchor(\n                artifact_uri=artifact_uri(self.program_id, rel),\n                span=Span(start_line=a, end_line=b),\n                hash=self._hash_for(abs_fp),\n            )\n        # Let subclass handle entity URIs\n        return self._resolve_entity_uri(kind, res, span)\n","source_hash":"cbc0aa5dcdb8bd7bf8e739e35d1190516934c4d470257d2017a31f88c0b7f173","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.repo_graph.resolve","uri":"program://TOLBERT/function/scripts.repo_graph.resolve#L97-L114","kind":"function","name":"resolve","path":"scripts/repo_graph.py","language":"python","start_line":97,"end_line":114,"context_start_line":77,"context_end_line":134,"code":"        # an actual induced subgraph can post-filter entities/edges.\n        return self  # pragma: no cover - view semantics only\n\n    def artifacts(self, kind: str) -> Iterable[Artifact]:\n        if kind not in (\"artifact\", \"source\"):\n            return []\n        self._ensure_built()\n        out: List[Artifact] = []\n        for fp in self._discover_files(self.repo_root, self.ignore_rules):\n            rel = os.path.relpath(fp, self.repo_root).replace(\"\\\\\", \"/\")\n            out.append(\n                Artifact(\n                    uri=artifact_uri(self.program_id, rel),\n                    type=\"source\",\n                    hash=self._hash_for(fp),\n                    span=None,\n                )\n            )\n        return out\n\n    def resolve(self, uri: str) -> ResolvedAnchor:\n        pid, kind, res, span = parse_program_uri(uri)\n        if pid != self.program_id:\n            raise ValueError(f\"program id mismatch: {pid} != {self.program_id}\")\n        if kind == \"artifact\":\n            abs_fp = os.path.abspath(os.path.join(self.repo_root, res))\n            if not os.path.isfile(abs_fp):\n                raise FileNotFoundError(f\"artifact not found: {abs_fp}\")\n            a = int(span[0]) if span else 1\n            b = int(span[1]) if span else self._safe_count_lines(abs_fp)\n            rel = os.path.relpath(abs_fp, self.repo_root).replace(\"\\\\\", \"/\")\n            return ResolvedAnchor(\n                artifact_uri=artifact_uri(self.program_id, rel),\n                span=Span(start_line=a, end_line=b),\n                hash=self._hash_for(abs_fp),\n            )\n        # Let subclass handle entity URIs\n        return self._resolve_entity_uri(kind, res, span)\n\n    # Hooks for subclasses\n    def _resolve_entity_uri(self, kind: str, resource: str, span: Optional[Tuple[int, int]]) -> ResolvedAnchor:\n        raise KeyError(f\"unrecognized entity uri for kind={kind}, resource={resource}\")\n\n    # Build / utilities\n    def _ensure_built(self) -> None:\n        if self._built:\n            return\n        self._build_graph()\n        self._built = True\n\n    def _build_graph(self) -> None:\n        \"\"\"\n        Populate entity and edge sets for this repository.\n\n        This is intentionally language-agnostic at the core:\n          - Always creates a repo-level entity.\n          - Always creates file-level entities for discovered source artifacts.\n","source_hash":"cbc0aa5dcdb8bd7bf8e739e35d1190516934c4d470257d2017a31f88c0b7f173","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.repo_graph._resolve_entity_uri","uri":"program://TOLBERT/function/scripts.repo_graph._resolve_entity_uri#L117-L118","kind":"function","name":"_resolve_entity_uri","path":"scripts/repo_graph.py","language":"python","start_line":117,"end_line":118,"context_start_line":97,"context_end_line":138,"code":"    def resolve(self, uri: str) -> ResolvedAnchor:\n        pid, kind, res, span = parse_program_uri(uri)\n        if pid != self.program_id:\n            raise ValueError(f\"program id mismatch: {pid} != {self.program_id}\")\n        if kind == \"artifact\":\n            abs_fp = os.path.abspath(os.path.join(self.repo_root, res))\n            if not os.path.isfile(abs_fp):\n                raise FileNotFoundError(f\"artifact not found: {abs_fp}\")\n            a = int(span[0]) if span else 1\n            b = int(span[1]) if span else self._safe_count_lines(abs_fp)\n            rel = os.path.relpath(abs_fp, self.repo_root).replace(\"\\\\\", \"/\")\n            return ResolvedAnchor(\n                artifact_uri=artifact_uri(self.program_id, rel),\n                span=Span(start_line=a, end_line=b),\n                hash=self._hash_for(abs_fp),\n            )\n        # Let subclass handle entity URIs\n        return self._resolve_entity_uri(kind, res, span)\n\n    # Hooks for subclasses\n    def _resolve_entity_uri(self, kind: str, resource: str, span: Optional[Tuple[int, int]]) -> ResolvedAnchor:\n        raise KeyError(f\"unrecognized entity uri for kind={kind}, resource={resource}\")\n\n    # Build / utilities\n    def _ensure_built(self) -> None:\n        if self._built:\n            return\n        self._build_graph()\n        self._built = True\n\n    def _build_graph(self) -> None:\n        \"\"\"\n        Populate entity and edge sets for this repository.\n\n        This is intentionally language-agnostic at the core:\n          - Always creates a repo-level entity.\n          - Always creates file-level entities for discovered source artifacts.\n\n        Language-specific structure (imports, calls, packages / modules) is\n        layered on top via simple heuristics and optional backends.\n        \"\"\"\n        # Repo entity","source_hash":"cbc0aa5dcdb8bd7bf8e739e35d1190516934c4d470257d2017a31f88c0b7f173","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.repo_graph._ensure_built","uri":"program://TOLBERT/function/scripts.repo_graph._ensure_built#L121-L125","kind":"function","name":"_ensure_built","path":"scripts/repo_graph.py","language":"python","start_line":121,"end_line":125,"context_start_line":101,"context_end_line":145,"code":"        if kind == \"artifact\":\n            abs_fp = os.path.abspath(os.path.join(self.repo_root, res))\n            if not os.path.isfile(abs_fp):\n                raise FileNotFoundError(f\"artifact not found: {abs_fp}\")\n            a = int(span[0]) if span else 1\n            b = int(span[1]) if span else self._safe_count_lines(abs_fp)\n            rel = os.path.relpath(abs_fp, self.repo_root).replace(\"\\\\\", \"/\")\n            return ResolvedAnchor(\n                artifact_uri=artifact_uri(self.program_id, rel),\n                span=Span(start_line=a, end_line=b),\n                hash=self._hash_for(abs_fp),\n            )\n        # Let subclass handle entity URIs\n        return self._resolve_entity_uri(kind, res, span)\n\n    # Hooks for subclasses\n    def _resolve_entity_uri(self, kind: str, resource: str, span: Optional[Tuple[int, int]]) -> ResolvedAnchor:\n        raise KeyError(f\"unrecognized entity uri for kind={kind}, resource={resource}\")\n\n    # Build / utilities\n    def _ensure_built(self) -> None:\n        if self._built:\n            return\n        self._build_graph()\n        self._built = True\n\n    def _build_graph(self) -> None:\n        \"\"\"\n        Populate entity and edge sets for this repository.\n\n        This is intentionally language-agnostic at the core:\n          - Always creates a repo-level entity.\n          - Always creates file-level entities for discovered source artifacts.\n\n        Language-specific structure (imports, calls, packages / modules) is\n        layered on top via simple heuristics and optional backends.\n        \"\"\"\n        # Repo entity\n        repo_eid: EntityId = f\"repo:{self.program_id}\"\n        if repo_eid not in self._entities:\n            self._entities[repo_eid] = Entity(\n                id=repo_eid,\n                kind=\"repo\",\n                uri=f\"program://{self.program_id}/repo\",\n                artifact_uri=None,","source_hash":"cbc0aa5dcdb8bd7bf8e739e35d1190516934c4d470257d2017a31f88c0b7f173","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.repo_graph._build_graph","uri":"program://TOLBERT/function/scripts.repo_graph._build_graph#L127-L180","kind":"function","name":"_build_graph","path":"scripts/repo_graph.py","language":"python","start_line":127,"end_line":180,"context_start_line":107,"context_end_line":200,"code":"            rel = os.path.relpath(abs_fp, self.repo_root).replace(\"\\\\\", \"/\")\n            return ResolvedAnchor(\n                artifact_uri=artifact_uri(self.program_id, rel),\n                span=Span(start_line=a, end_line=b),\n                hash=self._hash_for(abs_fp),\n            )\n        # Let subclass handle entity URIs\n        return self._resolve_entity_uri(kind, res, span)\n\n    # Hooks for subclasses\n    def _resolve_entity_uri(self, kind: str, resource: str, span: Optional[Tuple[int, int]]) -> ResolvedAnchor:\n        raise KeyError(f\"unrecognized entity uri for kind={kind}, resource={resource}\")\n\n    # Build / utilities\n    def _ensure_built(self) -> None:\n        if self._built:\n            return\n        self._build_graph()\n        self._built = True\n\n    def _build_graph(self) -> None:\n        \"\"\"\n        Populate entity and edge sets for this repository.\n\n        This is intentionally language-agnostic at the core:\n          - Always creates a repo-level entity.\n          - Always creates file-level entities for discovered source artifacts.\n\n        Language-specific structure (imports, calls, packages / modules) is\n        layered on top via simple heuristics and optional backends.\n        \"\"\"\n        # Repo entity\n        repo_eid: EntityId = f\"repo:{self.program_id}\"\n        if repo_eid not in self._entities:\n            self._entities[repo_eid] = Entity(\n                id=repo_eid,\n                kind=\"repo\",\n                uri=f\"program://{self.program_id}/repo\",\n                artifact_uri=None,\n                span=None,\n                labels=[\"kind:repo\"],\n                attributes={\"root\": self.repo_root},\n            )\n\n        # Discover files and create file-level entities\n        files = self._discover_files(self.repo_root, self.ignore_rules)\n        for fp in files:\n            rel = os.path.relpath(fp, self.repo_root).replace(\"\\\\\", \"/\")\n            uri = artifact_uri(self.program_id, rel)\n            labels = [\"kind:file\"] + self._language_labels_for(rel)\n            eid: EntityId = uri  # stable id tied to artifact URI\n            if eid not in self._entities:\n                self._entities[eid] = Entity(\n                    id=eid,\n                    kind=\"file\",\n                    uri=uri,\n                    artifact_uri=uri,\n                    span=None,\n                    labels=labels,\n                    attributes={\"rel_path\": rel},\n                )\n            self._file_entity_for_abs[os.path.abspath(fp)] = eid\n            # Repo \"owns\" file\n            self._edges.append(\n                Edge(\n                    src=repo_eid,\n                    dst=eid,\n                    type=\"owns\",\n                    attributes={},\n                )\n            )\n\n        # Language-specific edges and entities.\n        self._build_language_edges_and_entities(files)\n\n    def _build_language_edges_and_entities(self, files: List[str]) -> None:\n        \"\"\"\n        Add language-specific structure for supported stacks.\n\n        - C / C++: file-level imports from #include relationships.\n        - Go: package entities and import edges.\n        - Java: imported type entities and import edges.\n        - JS / TS: module/file imports from ES modules / require().\n        - Python: optional integration via scripts.codegraph_core.CodeGraph\n          for module / function / class entities and imports / calls.\n        \"\"\"\n        # Best-effort C / C++ / Go / Java / JS import graphs\n        for abs_fp in files:\n            rel = os.path.relpath(abs_fp, self.repo_root).replace(\"\\\\\", \"/\")\n            _, ext = os.path.splitext(rel.lower())\n            if ext in (\".c\", \".h\", \".cc\", \".cpp\", \".cxx\", \".hpp\"):\n                self._add_c_includes(abs_fp)\n            elif ext == \".go\":\n                self._add_go_imports(abs_fp)","source_hash":"cbc0aa5dcdb8bd7bf8e739e35d1190516934c4d470257d2017a31f88c0b7f173","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.repo_graph._build_language_edges_and_entities","uri":"program://TOLBERT/function/scripts.repo_graph._build_language_edges_and_entities#L182-L221","kind":"function","name":"_build_language_edges_and_entities","path":"scripts/repo_graph.py","language":"python","start_line":182,"end_line":221,"context_start_line":162,"context_end_line":241,"code":"                    uri=uri,\n                    artifact_uri=uri,\n                    span=None,\n                    labels=labels,\n                    attributes={\"rel_path\": rel},\n                )\n            self._file_entity_for_abs[os.path.abspath(fp)] = eid\n            # Repo \"owns\" file\n            self._edges.append(\n                Edge(\n                    src=repo_eid,\n                    dst=eid,\n                    type=\"owns\",\n                    attributes={},\n                )\n            )\n\n        # Language-specific edges and entities.\n        self._build_language_edges_and_entities(files)\n\n    def _build_language_edges_and_entities(self, files: List[str]) -> None:\n        \"\"\"\n        Add language-specific structure for supported stacks.\n\n        - C / C++: file-level imports from #include relationships.\n        - Go: package entities and import edges.\n        - Java: imported type entities and import edges.\n        - JS / TS: module/file imports from ES modules / require().\n        - Python: optional integration via scripts.codegraph_core.CodeGraph\n          for module / function / class entities and imports / calls.\n        \"\"\"\n        # Best-effort C / C++ / Go / Java / JS import graphs\n        for abs_fp in files:\n            rel = os.path.relpath(abs_fp, self.repo_root).replace(\"\\\\\", \"/\")\n            _, ext = os.path.splitext(rel.lower())\n            if ext in (\".c\", \".h\", \".cc\", \".cpp\", \".cxx\", \".hpp\"):\n                self._add_c_includes(abs_fp)\n            elif ext == \".go\":\n                self._add_go_imports(abs_fp)\n            elif ext == \".java\":\n                self._add_java_imports(abs_fp)\n            elif ext in (\".js\", \".jsx\", \".mjs\", \".ts\", \".tsx\"):\n                self._add_js_like_imports(abs_fp)\n\n        # Optional: richer Python graph via scripts.codegraph_core\n        try:\n            from scripts.codegraph_core import CodeGraph as _PyCodeGraph  # type: ignore\n        except Exception:\n            _PyCodeGraph = None  # type: ignore\n\n        if _PyCodeGraph is not None:\n            try:\n                cg = _PyCodeGraph(self.repo_root, ignore=self.ignore_rules).build()\n            except Exception:\n                cg = None\n            if cg is not None:\n                self._ingest_python_codegraph(cg)\n\n        # Non-Python symbol entities + heuristic call graph.\n        self._add_non_python_symbols_and_calls(files)\n\n    def _discover_files(self, root: str, ignore: List[str]) -> List[str]:\n        out: List[str] = []\n        for dirpath, dirnames, filenames in os.walk(root):\n            if any(ig and ig in dirpath for ig in ignore):\n                continue\n            for fn in filenames:\n                ap = os.path.abspath(os.path.join(dirpath, fn))\n                out.append(ap)\n        return out\n\n    def _language_labels_for(self, rel_path: str) -> List[str]:\n        \"\"\"\n        Best-effort language tags for a repo-relative path based on extension.\n\n        These are intentionally coarse and are only used to annotate entities\n        (e.g., file-level entities) so that downstream tools can filter or\n        group by language family when needed.\n        \"\"\"\n        _, ext = os.path.splitext(rel_path.lower())","source_hash":"cbc0aa5dcdb8bd7bf8e739e35d1190516934c4d470257d2017a31f88c0b7f173","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.repo_graph._discover_files","uri":"program://TOLBERT/function/scripts.repo_graph._discover_files#L223-L231","kind":"function","name":"_discover_files","path":"scripts/repo_graph.py","language":"python","start_line":223,"end_line":231,"context_start_line":203,"context_end_line":251,"code":"            elif ext in (\".js\", \".jsx\", \".mjs\", \".ts\", \".tsx\"):\n                self._add_js_like_imports(abs_fp)\n\n        # Optional: richer Python graph via scripts.codegraph_core\n        try:\n            from scripts.codegraph_core import CodeGraph as _PyCodeGraph  # type: ignore\n        except Exception:\n            _PyCodeGraph = None  # type: ignore\n\n        if _PyCodeGraph is not None:\n            try:\n                cg = _PyCodeGraph(self.repo_root, ignore=self.ignore_rules).build()\n            except Exception:\n                cg = None\n            if cg is not None:\n                self._ingest_python_codegraph(cg)\n\n        # Non-Python symbol entities + heuristic call graph.\n        self._add_non_python_symbols_and_calls(files)\n\n    def _discover_files(self, root: str, ignore: List[str]) -> List[str]:\n        out: List[str] = []\n        for dirpath, dirnames, filenames in os.walk(root):\n            if any(ig and ig in dirpath for ig in ignore):\n                continue\n            for fn in filenames:\n                ap = os.path.abspath(os.path.join(dirpath, fn))\n                out.append(ap)\n        return out\n\n    def _language_labels_for(self, rel_path: str) -> List[str]:\n        \"\"\"\n        Best-effort language tags for a repo-relative path based on extension.\n\n        These are intentionally coarse and are only used to annotate entities\n        (e.g., file-level entities) so that downstream tools can filter or\n        group by language family when needed.\n        \"\"\"\n        _, ext = os.path.splitext(rel_path.lower())\n        labels: List[str] = []\n        if ext == \".py\":\n            labels.append(\"lang:python\")\n        elif ext in (\".c\", \".h\"):\n            labels.append(\"lang:c\")\n        elif ext in (\".cc\", \".cpp\", \".cxx\", \".hpp\"):\n            labels.append(\"lang:cpp\")\n        elif ext in (\".js\", \".jsx\", \".mjs\"):\n            labels.append(\"lang:js\")\n        elif ext in (\".ts\", \".tsx\"):","source_hash":"cbc0aa5dcdb8bd7bf8e739e35d1190516934c4d470257d2017a31f88c0b7f173","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.repo_graph._language_labels_for","uri":"program://TOLBERT/function/scripts.repo_graph._language_labels_for#L233-L259","kind":"function","name":"_language_labels_for","path":"scripts/repo_graph.py","language":"python","start_line":233,"end_line":259,"context_start_line":213,"context_end_line":279,"code":"            try:\n                cg = _PyCodeGraph(self.repo_root, ignore=self.ignore_rules).build()\n            except Exception:\n                cg = None\n            if cg is not None:\n                self._ingest_python_codegraph(cg)\n\n        # Non-Python symbol entities + heuristic call graph.\n        self._add_non_python_symbols_and_calls(files)\n\n    def _discover_files(self, root: str, ignore: List[str]) -> List[str]:\n        out: List[str] = []\n        for dirpath, dirnames, filenames in os.walk(root):\n            if any(ig and ig in dirpath for ig in ignore):\n                continue\n            for fn in filenames:\n                ap = os.path.abspath(os.path.join(dirpath, fn))\n                out.append(ap)\n        return out\n\n    def _language_labels_for(self, rel_path: str) -> List[str]:\n        \"\"\"\n        Best-effort language tags for a repo-relative path based on extension.\n\n        These are intentionally coarse and are only used to annotate entities\n        (e.g., file-level entities) so that downstream tools can filter or\n        group by language family when needed.\n        \"\"\"\n        _, ext = os.path.splitext(rel_path.lower())\n        labels: List[str] = []\n        if ext == \".py\":\n            labels.append(\"lang:python\")\n        elif ext in (\".c\", \".h\"):\n            labels.append(\"lang:c\")\n        elif ext in (\".cc\", \".cpp\", \".cxx\", \".hpp\"):\n            labels.append(\"lang:cpp\")\n        elif ext in (\".js\", \".jsx\", \".mjs\"):\n            labels.append(\"lang:js\")\n        elif ext in (\".ts\", \".tsx\"):\n            labels.append(\"lang:ts\")\n        elif ext == \".go\":\n            labels.append(\"lang:go\")\n        elif ext == \".java\":\n            labels.append(\"lang:java\")\n        elif ext == \".md\":\n            labels.append(\"lang:markdown\")\n        return labels\n\n    def _safe_count_lines(self, abs_file: str) -> int:\n        try:\n            with open(abs_file, \"r\", encoding=\"utf-8\", errors=\"ignore\") as fh:\n                return sum(1 for _ in fh)\n        except Exception:\n            return 1\n\n    def _hash_for(self, abs_file: str) -> str:\n        if abs_file in self._file_hash:\n            return self._file_hash[abs_file]\n        try:\n            with open(abs_file, \"rb\") as fh:\n                raw = fh.read()\n            h = hashlib.sha256(raw).hexdigest()\n        except Exception:\n            h = \"\"\n        self._file_hash[abs_file] = h\n        return h\n","source_hash":"cbc0aa5dcdb8bd7bf8e739e35d1190516934c4d470257d2017a31f88c0b7f173","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.repo_graph._safe_count_lines","uri":"program://TOLBERT/function/scripts.repo_graph._safe_count_lines#L261-L266","kind":"function","name":"_safe_count_lines","path":"scripts/repo_graph.py","language":"python","start_line":261,"end_line":266,"context_start_line":241,"context_end_line":286,"code":"        _, ext = os.path.splitext(rel_path.lower())\n        labels: List[str] = []\n        if ext == \".py\":\n            labels.append(\"lang:python\")\n        elif ext in (\".c\", \".h\"):\n            labels.append(\"lang:c\")\n        elif ext in (\".cc\", \".cpp\", \".cxx\", \".hpp\"):\n            labels.append(\"lang:cpp\")\n        elif ext in (\".js\", \".jsx\", \".mjs\"):\n            labels.append(\"lang:js\")\n        elif ext in (\".ts\", \".tsx\"):\n            labels.append(\"lang:ts\")\n        elif ext == \".go\":\n            labels.append(\"lang:go\")\n        elif ext == \".java\":\n            labels.append(\"lang:java\")\n        elif ext == \".md\":\n            labels.append(\"lang:markdown\")\n        return labels\n\n    def _safe_count_lines(self, abs_file: str) -> int:\n        try:\n            with open(abs_file, \"r\", encoding=\"utf-8\", errors=\"ignore\") as fh:\n                return sum(1 for _ in fh)\n        except Exception:\n            return 1\n\n    def _hash_for(self, abs_file: str) -> str:\n        if abs_file in self._file_hash:\n            return self._file_hash[abs_file]\n        try:\n            with open(abs_file, \"rb\") as fh:\n                raw = fh.read()\n            h = hashlib.sha256(raw).hexdigest()\n        except Exception:\n            h = \"\"\n        self._file_hash[abs_file] = h\n        return h\n\n    # --- Language-specific helpers ---\n\n    def _add_symbol_entity(\n        self,\n        abs_fp: str,\n        name: str,\n        kind: str,","source_hash":"cbc0aa5dcdb8bd7bf8e739e35d1190516934c4d470257d2017a31f88c0b7f173","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.repo_graph._hash_for","uri":"program://TOLBERT/function/scripts.repo_graph._hash_for#L268-L278","kind":"function","name":"_hash_for","path":"scripts/repo_graph.py","language":"python","start_line":268,"end_line":278,"context_start_line":248,"context_end_line":298,"code":"            labels.append(\"lang:cpp\")\n        elif ext in (\".js\", \".jsx\", \".mjs\"):\n            labels.append(\"lang:js\")\n        elif ext in (\".ts\", \".tsx\"):\n            labels.append(\"lang:ts\")\n        elif ext == \".go\":\n            labels.append(\"lang:go\")\n        elif ext == \".java\":\n            labels.append(\"lang:java\")\n        elif ext == \".md\":\n            labels.append(\"lang:markdown\")\n        return labels\n\n    def _safe_count_lines(self, abs_file: str) -> int:\n        try:\n            with open(abs_file, \"r\", encoding=\"utf-8\", errors=\"ignore\") as fh:\n                return sum(1 for _ in fh)\n        except Exception:\n            return 1\n\n    def _hash_for(self, abs_file: str) -> str:\n        if abs_file in self._file_hash:\n            return self._file_hash[abs_file]\n        try:\n            with open(abs_file, \"rb\") as fh:\n                raw = fh.read()\n            h = hashlib.sha256(raw).hexdigest()\n        except Exception:\n            h = \"\"\n        self._file_hash[abs_file] = h\n        return h\n\n    # --- Language-specific helpers ---\n\n    def _add_symbol_entity(\n        self,\n        abs_fp: str,\n        name: str,\n        kind: str,\n        lang_label: str,\n        start_line: int,\n        end_line: int,\n    ) -> Optional[EntityId]:\n        abs_fp = os.path.abspath(abs_fp)\n        file_eid = self._file_entity_for_abs.get(abs_fp)\n        if not file_eid:\n            return None\n        # Stable id: lang-specific prefix + file rel path + symbol name.\n        rel = os.path.relpath(abs_fp, self.repo_root).replace(\"\\\\\", \"/\")\n        sym_id: EntityId = f\"{lang_label}:{rel}:{name}\"\n        if sym_id in self._entities:","source_hash":"cbc0aa5dcdb8bd7bf8e739e35d1190516934c4d470257d2017a31f88c0b7f173","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.repo_graph._add_symbol_entity","uri":"program://TOLBERT/function/scripts.repo_graph._add_symbol_entity#L282-L323","kind":"function","name":"_add_symbol_entity","path":"scripts/repo_graph.py","language":"python","start_line":282,"end_line":323,"context_start_line":262,"context_end_line":343,"code":"        try:\n            with open(abs_file, \"r\", encoding=\"utf-8\", errors=\"ignore\") as fh:\n                return sum(1 for _ in fh)\n        except Exception:\n            return 1\n\n    def _hash_for(self, abs_file: str) -> str:\n        if abs_file in self._file_hash:\n            return self._file_hash[abs_file]\n        try:\n            with open(abs_file, \"rb\") as fh:\n                raw = fh.read()\n            h = hashlib.sha256(raw).hexdigest()\n        except Exception:\n            h = \"\"\n        self._file_hash[abs_file] = h\n        return h\n\n    # --- Language-specific helpers ---\n\n    def _add_symbol_entity(\n        self,\n        abs_fp: str,\n        name: str,\n        kind: str,\n        lang_label: str,\n        start_line: int,\n        end_line: int,\n    ) -> Optional[EntityId]:\n        abs_fp = os.path.abspath(abs_fp)\n        file_eid = self._file_entity_for_abs.get(abs_fp)\n        if not file_eid:\n            return None\n        # Stable id: lang-specific prefix + file rel path + symbol name.\n        rel = os.path.relpath(abs_fp, self.repo_root).replace(\"\\\\\", \"/\")\n        sym_id: EntityId = f\"{lang_label}:{rel}:{name}\"\n        if sym_id in self._entities:\n            return sym_id\n        file_ent = self._entities[file_eid]\n        span = Span(start_line=int(start_line), end_line=int(end_line))\n        uri = f\"program://{self.program_id}/sym/{lang_label}/{rel}#{name}\"\n        labels = [f\"kind:{kind}\", f\"lang:{lang_label}\"]\n        self._entities[sym_id] = Entity(\n            id=sym_id,\n            kind=kind,\n            uri=uri,\n            artifact_uri=file_ent.artifact_uri,\n            span=span,\n            labels=labels,\n            attributes={\"name\": name, \"file\": rel},\n        )\n        # file \"owns\" symbol\n        self._edges.append(\n            Edge(\n                src=file_eid,\n                dst=sym_id,\n                type=\"owns\",\n                attributes={\"lang\": lang_label},\n            )\n        )\n        self._symbols_by_name.setdefault(name.lower(), []).append(sym_id)\n        return sym_id\n\n    def _add_c_includes(self, abs_fp: str) -> None:\n        src_eid = self._file_entity_for_abs.get(os.path.abspath(abs_fp))\n        if not src_eid:\n            return\n        try:\n            with open(abs_fp, \"r\", encoding=\"utf-8\", errors=\"ignore\") as fh:\n                text = fh.read()\n        except Exception:\n            return\n        # Match #include \"local.h\" and #include <local.h>\n        rx = re.compile(r'^\\s*#\\s*include\\s*[<\"]([^\">]+)[\">]', re.MULTILINE)\n        for m in rx.finditer(text):\n            target = m.group(1).strip()\n            if not target:\n                continue\n            # Resolve relative to current directory; ignore obvious system headers.\n            if \"/\" not in target and \"\\\\\" not in target and \".\" not in target:\n                continue\n            cand = os.path.abspath(os.path.join(os.path.dirname(abs_fp), target))","source_hash":"cbc0aa5dcdb8bd7bf8e739e35d1190516934c4d470257d2017a31f88c0b7f173","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.repo_graph._add_c_includes","uri":"program://TOLBERT/function/scripts.repo_graph._add_c_includes#L325-L354","kind":"function","name":"_add_c_includes","path":"scripts/repo_graph.py","language":"python","start_line":325,"end_line":354,"context_start_line":305,"context_end_line":374,"code":"            id=sym_id,\n            kind=kind,\n            uri=uri,\n            artifact_uri=file_ent.artifact_uri,\n            span=span,\n            labels=labels,\n            attributes={\"name\": name, \"file\": rel},\n        )\n        # file \"owns\" symbol\n        self._edges.append(\n            Edge(\n                src=file_eid,\n                dst=sym_id,\n                type=\"owns\",\n                attributes={\"lang\": lang_label},\n            )\n        )\n        self._symbols_by_name.setdefault(name.lower(), []).append(sym_id)\n        return sym_id\n\n    def _add_c_includes(self, abs_fp: str) -> None:\n        src_eid = self._file_entity_for_abs.get(os.path.abspath(abs_fp))\n        if not src_eid:\n            return\n        try:\n            with open(abs_fp, \"r\", encoding=\"utf-8\", errors=\"ignore\") as fh:\n                text = fh.read()\n        except Exception:\n            return\n        # Match #include \"local.h\" and #include <local.h>\n        rx = re.compile(r'^\\s*#\\s*include\\s*[<\"]([^\">]+)[\">]', re.MULTILINE)\n        for m in rx.finditer(text):\n            target = m.group(1).strip()\n            if not target:\n                continue\n            # Resolve relative to current directory; ignore obvious system headers.\n            if \"/\" not in target and \"\\\\\" not in target and \".\" not in target:\n                continue\n            cand = os.path.abspath(os.path.join(os.path.dirname(abs_fp), target))\n            dst_eid = self._file_entity_for_abs.get(cand)\n            if not dst_eid:\n                continue\n            self._edges.append(\n                Edge(\n                    src=src_eid,\n                    dst=dst_eid,\n                    type=\"imports\",\n                    attributes={\"lang\": \"c_cpp\"},\n                )\n            )\n\n    def _add_go_imports(self, abs_fp: str) -> None:\n        src_eid = self._file_entity_for_abs.get(os.path.abspath(abs_fp))\n        if not src_eid:\n            return\n        try:\n            with open(abs_fp, \"r\", encoding=\"utf-8\", errors=\"ignore\") as fh:\n                lines = fh.readlines()\n        except Exception:\n            return\n        in_block = False\n        for ln in lines:\n            stripped = ln.strip()\n            if stripped.startswith(\"import \"):\n                # Single-line: import \"pkg/path\"\n                in_block = \"(\" in stripped and not stripped.rstrip().endswith(\")\")\n                m = re.search(r'[\"`](.+?)[\"`]', stripped)\n                if m:\n                    pkg = m.group(1).strip()\n                    self._add_go_import_edge(src_eid, pkg)","source_hash":"cbc0aa5dcdb8bd7bf8e739e35d1190516934c4d470257d2017a31f88c0b7f173","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.repo_graph._add_go_imports","uri":"program://TOLBERT/function/scripts.repo_graph._add_go_imports#L356-L382","kind":"function","name":"_add_go_imports","path":"scripts/repo_graph.py","language":"python","start_line":356,"end_line":382,"context_start_line":336,"context_end_line":402,"code":"        for m in rx.finditer(text):\n            target = m.group(1).strip()\n            if not target:\n                continue\n            # Resolve relative to current directory; ignore obvious system headers.\n            if \"/\" not in target and \"\\\\\" not in target and \".\" not in target:\n                continue\n            cand = os.path.abspath(os.path.join(os.path.dirname(abs_fp), target))\n            dst_eid = self._file_entity_for_abs.get(cand)\n            if not dst_eid:\n                continue\n            self._edges.append(\n                Edge(\n                    src=src_eid,\n                    dst=dst_eid,\n                    type=\"imports\",\n                    attributes={\"lang\": \"c_cpp\"},\n                )\n            )\n\n    def _add_go_imports(self, abs_fp: str) -> None:\n        src_eid = self._file_entity_for_abs.get(os.path.abspath(abs_fp))\n        if not src_eid:\n            return\n        try:\n            with open(abs_fp, \"r\", encoding=\"utf-8\", errors=\"ignore\") as fh:\n                lines = fh.readlines()\n        except Exception:\n            return\n        in_block = False\n        for ln in lines:\n            stripped = ln.strip()\n            if stripped.startswith(\"import \"):\n                # Single-line: import \"pkg/path\"\n                in_block = \"(\" in stripped and not stripped.rstrip().endswith(\")\")\n                m = re.search(r'[\"`](.+?)[\"`]', stripped)\n                if m:\n                    pkg = m.group(1).strip()\n                    self._add_go_import_edge(src_eid, pkg)\n            elif in_block:\n                if stripped.startswith(\")\"):\n                    in_block = False\n                    continue\n                m = re.search(r'[\"`](.+?)[\"`]', stripped)\n                if m:\n                    pkg = m.group(1).strip()\n                    self._add_go_import_edge(src_eid, pkg)\n\n    def _add_go_import_edge(self, src_eid: EntityId, pkg: str) -> None:\n        if not pkg:\n            return\n        eid: EntityId = f\"go:pkg:{pkg}\"\n        if eid not in self._entities:\n            self._entities[eid] = Entity(\n                id=eid,\n                kind=\"package\",\n                uri=f\"program://{self.program_id}/go_pkg/{pkg}\",\n                artifact_uri=None,\n                span=None,\n                labels=[\"kind:package\", \"lang:go\"],\n                attributes={\"package\": pkg},\n            )\n        self._edges.append(\n            Edge(\n                src=src_eid,\n                dst=eid,\n                type=\"imports\",","source_hash":"cbc0aa5dcdb8bd7bf8e739e35d1190516934c4d470257d2017a31f88c0b7f173","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.repo_graph._add_go_import_edge","uri":"program://TOLBERT/function/scripts.repo_graph._add_go_import_edge#L384-L405","kind":"function","name":"_add_go_import_edge","path":"scripts/repo_graph.py","language":"python","start_line":384,"end_line":405,"context_start_line":364,"context_end_line":425,"code":"            return\n        in_block = False\n        for ln in lines:\n            stripped = ln.strip()\n            if stripped.startswith(\"import \"):\n                # Single-line: import \"pkg/path\"\n                in_block = \"(\" in stripped and not stripped.rstrip().endswith(\")\")\n                m = re.search(r'[\"`](.+?)[\"`]', stripped)\n                if m:\n                    pkg = m.group(1).strip()\n                    self._add_go_import_edge(src_eid, pkg)\n            elif in_block:\n                if stripped.startswith(\")\"):\n                    in_block = False\n                    continue\n                m = re.search(r'[\"`](.+?)[\"`]', stripped)\n                if m:\n                    pkg = m.group(1).strip()\n                    self._add_go_import_edge(src_eid, pkg)\n\n    def _add_go_import_edge(self, src_eid: EntityId, pkg: str) -> None:\n        if not pkg:\n            return\n        eid: EntityId = f\"go:pkg:{pkg}\"\n        if eid not in self._entities:\n            self._entities[eid] = Entity(\n                id=eid,\n                kind=\"package\",\n                uri=f\"program://{self.program_id}/go_pkg/{pkg}\",\n                artifact_uri=None,\n                span=None,\n                labels=[\"kind:package\", \"lang:go\"],\n                attributes={\"package\": pkg},\n            )\n        self._edges.append(\n            Edge(\n                src=src_eid,\n                dst=eid,\n                type=\"imports\",\n                    attributes={\"lang\": \"go\"},\n            )\n        )\n\n    def _add_java_imports(self, abs_fp: str) -> None:\n        src_eid = self._file_entity_for_abs.get(os.path.abspath(abs_fp))\n        if not src_eid:\n            return\n        try:\n            with open(abs_fp, \"r\", encoding=\"utf-8\", errors=\"ignore\") as fh:\n                text = fh.read()\n        except Exception:\n            return\n        rx = re.compile(r'^\\s*import\\s+(static\\s+)?([a-zA-Z0-9_.]+)\\s*;', re.MULTILINE)\n        for m in rx.finditer(text):\n            fqn = m.group(2)\n            if not fqn:\n                continue\n            eid: EntityId = f\"java:import:{fqn}\"\n            if eid not in self._entities:\n                self._entities[eid] = Entity(\n                    id=eid,\n                    kind=\"type\",","source_hash":"cbc0aa5dcdb8bd7bf8e739e35d1190516934c4d470257d2017a31f88c0b7f173","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.repo_graph._add_java_imports","uri":"program://TOLBERT/function/scripts.repo_graph._add_java_imports#L407-L439","kind":"function","name":"_add_java_imports","path":"scripts/repo_graph.py","language":"python","start_line":407,"end_line":439,"context_start_line":387,"context_end_line":459,"code":"        eid: EntityId = f\"go:pkg:{pkg}\"\n        if eid not in self._entities:\n            self._entities[eid] = Entity(\n                id=eid,\n                kind=\"package\",\n                uri=f\"program://{self.program_id}/go_pkg/{pkg}\",\n                artifact_uri=None,\n                span=None,\n                labels=[\"kind:package\", \"lang:go\"],\n                attributes={\"package\": pkg},\n            )\n        self._edges.append(\n            Edge(\n                src=src_eid,\n                dst=eid,\n                type=\"imports\",\n                    attributes={\"lang\": \"go\"},\n            )\n        )\n\n    def _add_java_imports(self, abs_fp: str) -> None:\n        src_eid = self._file_entity_for_abs.get(os.path.abspath(abs_fp))\n        if not src_eid:\n            return\n        try:\n            with open(abs_fp, \"r\", encoding=\"utf-8\", errors=\"ignore\") as fh:\n                text = fh.read()\n        except Exception:\n            return\n        rx = re.compile(r'^\\s*import\\s+(static\\s+)?([a-zA-Z0-9_.]+)\\s*;', re.MULTILINE)\n        for m in rx.finditer(text):\n            fqn = m.group(2)\n            if not fqn:\n                continue\n            eid: EntityId = f\"java:import:{fqn}\"\n            if eid not in self._entities:\n                self._entities[eid] = Entity(\n                    id=eid,\n                    kind=\"type\",\n                    uri=f\"program://{self.program_id}/java_type/{fqn}\",\n                    artifact_uri=None,\n                    span=None,\n                    labels=[\"kind:type\", \"lang:java\"],\n                    attributes={\"fqn\": fqn},\n                )\n            self._edges.append(\n                Edge(\n                    src=src_eid,\n                    dst=eid,\n                    type=\"imports\",\n                    attributes={\"lang\": \"java\"},\n                )\n            )\n\n    def _add_js_like_imports(self, abs_fp: str) -> None:\n        src_eid = self._file_entity_for_abs.get(os.path.abspath(abs_fp))\n        if not src_eid:\n            return\n        try:\n            with open(abs_fp, \"r\", encoding=\"utf-8\", errors=\"ignore\") as fh:\n                text = fh.read()\n        except Exception:\n            return\n        rel = os.path.relpath(abs_fp, self.repo_root).replace(\"\\\\\", \"/\")\n        base_dir = os.path.dirname(os.path.abspath(abs_fp))\n\n        specs: Set[str] = set()\n        # import x from 'spec';  import 'spec';\n        for m in re.finditer(r'^\\s*import\\s+(?:.+?\\s+from\\s+)?[\\'\"](.+?)[\\'\"]', text, re.MULTILINE):\n            specs.add(m.group(1).strip())\n        # require('spec')\n        for m in re.finditer(r'require\\(\\s*[\\'\"](.+?)[\\'\"]\\s*\\)', text):\n            specs.add(m.group(1).strip())","source_hash":"cbc0aa5dcdb8bd7bf8e739e35d1190516934c4d470257d2017a31f88c0b7f173","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.repo_graph._add_js_like_imports","uri":"program://TOLBERT/function/scripts.repo_graph._add_js_like_imports#L441-L496","kind":"function","name":"_add_js_like_imports","path":"scripts/repo_graph.py","language":"python","start_line":441,"end_line":496,"context_start_line":421,"context_end_line":516,"code":"            eid: EntityId = f\"java:import:{fqn}\"\n            if eid not in self._entities:\n                self._entities[eid] = Entity(\n                    id=eid,\n                    kind=\"type\",\n                    uri=f\"program://{self.program_id}/java_type/{fqn}\",\n                    artifact_uri=None,\n                    span=None,\n                    labels=[\"kind:type\", \"lang:java\"],\n                    attributes={\"fqn\": fqn},\n                )\n            self._edges.append(\n                Edge(\n                    src=src_eid,\n                    dst=eid,\n                    type=\"imports\",\n                    attributes={\"lang\": \"java\"},\n                )\n            )\n\n    def _add_js_like_imports(self, abs_fp: str) -> None:\n        src_eid = self._file_entity_for_abs.get(os.path.abspath(abs_fp))\n        if not src_eid:\n            return\n        try:\n            with open(abs_fp, \"r\", encoding=\"utf-8\", errors=\"ignore\") as fh:\n                text = fh.read()\n        except Exception:\n            return\n        rel = os.path.relpath(abs_fp, self.repo_root).replace(\"\\\\\", \"/\")\n        base_dir = os.path.dirname(os.path.abspath(abs_fp))\n\n        specs: Set[str] = set()\n        # import x from 'spec';  import 'spec';\n        for m in re.finditer(r'^\\s*import\\s+(?:.+?\\s+from\\s+)?[\\'\"](.+?)[\\'\"]', text, re.MULTILINE):\n            specs.add(m.group(1).strip())\n        # require('spec')\n        for m in re.finditer(r'require\\(\\s*[\\'\"](.+?)[\\'\"]\\s*\\)', text):\n            specs.add(m.group(1).strip())\n\n        for spec in specs:\n            if not spec:\n                continue\n            if spec.startswith(\".\"):\n                # Local module → resolve to file entity if possible.\n                dst_eid = self._resolve_local_js_like_spec(base_dir, spec)\n                if dst_eid:\n                    self._edges.append(\n                        Edge(\n                            src=src_eid,\n                            dst=dst_eid,\n                            type=\"imports\",\n                            attributes={\"lang\": \"js_ts\"},\n                        )\n                    )\n            else:\n                # External package\n                eid: EntityId = f\"js:pkg:{spec}\"\n                if eid not in self._entities:\n                    self._entities[eid] = Entity(\n                        id=eid,\n                        kind=\"package\",\n                        uri=f\"program://{self.program_id}/js_pkg/{spec}\",\n                        artifact_uri=None,\n                        span=None,\n                        labels=[\"kind:package\", \"lang:js\"],\n                        attributes={\"package\": spec},\n                    )\n                self._edges.append(\n                    Edge(\n                        src=src_eid,\n                        dst=eid,\n                        type=\"imports\",\n                        attributes={\"lang\": \"js_ts\"},\n                    )\n                )\n\n    def _resolve_local_js_like_spec(self, base_dir: str, spec: str) -> Optional[EntityId]:\n        # Resolve \"./foo\" style specifiers to actual files if present.\n        # Try with and without common JS/TS extensions.\n        exts = [\"\", \".js\", \".jsx\", \".mjs\", \".ts\", \".tsx\"]\n        for ext in exts:\n            cand = spec\n            if not cand.endswith(ext):\n                cand = spec + ext\n            abs_cand = os.path.abspath(os.path.join(base_dir, cand))\n            eid = self._file_entity_for_abs.get(abs_cand)\n            if eid:\n                return eid\n        return None\n\n    def _ingest_python_codegraph(self, cg: Any) -> None:\n        \"\"\"\n        Integrate a scripts.codegraph_core.CodeGraph instance as one backend.\n\n        This adds:","source_hash":"cbc0aa5dcdb8bd7bf8e739e35d1190516934c4d470257d2017a31f88c0b7f173","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.repo_graph._resolve_local_js_like_spec","uri":"program://TOLBERT/function/scripts.repo_graph._resolve_local_js_like_spec#L498-L510","kind":"function","name":"_resolve_local_js_like_spec","path":"scripts/repo_graph.py","language":"python","start_line":498,"end_line":510,"context_start_line":478,"context_end_line":530,"code":"                eid: EntityId = f\"js:pkg:{spec}\"\n                if eid not in self._entities:\n                    self._entities[eid] = Entity(\n                        id=eid,\n                        kind=\"package\",\n                        uri=f\"program://{self.program_id}/js_pkg/{spec}\",\n                        artifact_uri=None,\n                        span=None,\n                        labels=[\"kind:package\", \"lang:js\"],\n                        attributes={\"package\": spec},\n                    )\n                self._edges.append(\n                    Edge(\n                        src=src_eid,\n                        dst=eid,\n                        type=\"imports\",\n                        attributes={\"lang\": \"js_ts\"},\n                    )\n                )\n\n    def _resolve_local_js_like_spec(self, base_dir: str, spec: str) -> Optional[EntityId]:\n        # Resolve \"./foo\" style specifiers to actual files if present.\n        # Try with and without common JS/TS extensions.\n        exts = [\"\", \".js\", \".jsx\", \".mjs\", \".ts\", \".tsx\"]\n        for ext in exts:\n            cand = spec\n            if not cand.endswith(ext):\n                cand = spec + ext\n            abs_cand = os.path.abspath(os.path.join(base_dir, cand))\n            eid = self._file_entity_for_abs.get(abs_cand)\n            if eid:\n                return eid\n        return None\n\n    def _ingest_python_codegraph(self, cg: Any) -> None:\n        \"\"\"\n        Integrate a scripts.codegraph_core.CodeGraph instance as one backend.\n\n        This adds:\n          - Module / function / class entities for Python.\n          - \"owns\" edges from file entities to these symbols.\n          - \"imports\" / \"calls\" / \"tests\" edges as provided by the backend.\n        \"\"\"\n        # Entities\n        for ent in cg.entities():\n            abs_file = os.path.abspath(getattr(ent, \"file\", \"\"))\n            file_eid = self._file_entity_for_abs.get(abs_file)\n            if not file_eid:\n                continue\n            eid: EntityId = getattr(ent, \"id\")\n            if eid in self._entities:\n                continue\n            span = Span(start_line=int(ent.start_line), end_line=int(ent.end_line))","source_hash":"cbc0aa5dcdb8bd7bf8e739e35d1190516934c4d470257d2017a31f88c0b7f173","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.repo_graph._ingest_python_codegraph","uri":"program://TOLBERT/function/scripts.repo_graph._ingest_python_codegraph#L512-L564","kind":"function","name":"_ingest_python_codegraph","path":"scripts/repo_graph.py","language":"python","start_line":512,"end_line":564,"context_start_line":492,"context_end_line":584,"code":"                        dst=eid,\n                        type=\"imports\",\n                        attributes={\"lang\": \"js_ts\"},\n                    )\n                )\n\n    def _resolve_local_js_like_spec(self, base_dir: str, spec: str) -> Optional[EntityId]:\n        # Resolve \"./foo\" style specifiers to actual files if present.\n        # Try with and without common JS/TS extensions.\n        exts = [\"\", \".js\", \".jsx\", \".mjs\", \".ts\", \".tsx\"]\n        for ext in exts:\n            cand = spec\n            if not cand.endswith(ext):\n                cand = spec + ext\n            abs_cand = os.path.abspath(os.path.join(base_dir, cand))\n            eid = self._file_entity_for_abs.get(abs_cand)\n            if eid:\n                return eid\n        return None\n\n    def _ingest_python_codegraph(self, cg: Any) -> None:\n        \"\"\"\n        Integrate a scripts.codegraph_core.CodeGraph instance as one backend.\n\n        This adds:\n          - Module / function / class entities for Python.\n          - \"owns\" edges from file entities to these symbols.\n          - \"imports\" / \"calls\" / \"tests\" edges as provided by the backend.\n        \"\"\"\n        # Entities\n        for ent in cg.entities():\n            abs_file = os.path.abspath(getattr(ent, \"file\", \"\"))\n            file_eid = self._file_entity_for_abs.get(abs_file)\n            if not file_eid:\n                continue\n            eid: EntityId = getattr(ent, \"id\")\n            if eid in self._entities:\n                continue\n            span = Span(start_line=int(ent.start_line), end_line=int(ent.end_line))\n            uri = f\"program://{self.program_id}/py_entity/{eid}\"\n            labels = [f\"kind:{ent.kind}\", \"lang:python\"]\n            self._entities[eid] = Entity(\n                id=eid,\n                kind=str(ent.kind),\n                uri=uri,\n                artifact_uri=self._entities[file_eid].artifact_uri,\n                span=span,\n                labels=labels,\n                attributes={\"name\": ent.name},\n            )\n            self._symbols_by_name.setdefault(ent.name.lower(), []).append(eid)\n            # file \"owns\" symbol\n            self._edges.append(\n                Edge(\n                    src=file_eid,\n                    dst=eid,\n                    type=\"owns\",\n                    attributes={\"lang\": \"python\"},\n                )\n            )\n\n        # Edges from backend (imports, calls, owns, tests, ...)\n        for e in cg.edges():\n            if (e.src not in self._entities) or (e.dst not in self._entities):\n                continue\n            self._edges.append(\n                Edge(\n                    src=e.src,\n                    dst=e.dst,\n                    type=e.type,\n                    attributes={\"lang\": \"python\"},\n                )\n            )\n\n    def _add_non_python_symbols_and_calls(self, files: List[str]) -> None:\n        \"\"\"\n        Add best-effort function/class symbols and a simple call graph for\n        non-Python languages (C/C++, Go, Java, JS/TS).\n\n        The call graph is heuristic: we scan for identifier`(` patterns in\n        each file and connect the *file entity* to any known symbol entity\n        with a matching name.\n        \"\"\"\n        # Pass 1: symbols\n        for abs_fp in files:\n            rel = os.path.relpath(abs_fp, self.repo_root).replace(\"\\\\\", \"/\")\n            _, ext = os.path.splitext(rel.lower())\n            if ext in (\".c\", \".h\", \".cc\", \".cpp\", \".cxx\", \".hpp\"):\n                self._index_c_cpp_symbols(abs_fp)\n            elif ext == \".go\":\n                self._index_go_symbols(abs_fp)\n            elif ext == \".java\":\n                self._index_java_symbols(abs_fp)","source_hash":"cbc0aa5dcdb8bd7bf8e739e35d1190516934c4d470257d2017a31f88c0b7f173","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.repo_graph._add_non_python_symbols_and_calls","uri":"program://TOLBERT/function/scripts.repo_graph._add_non_python_symbols_and_calls#L566-L614","kind":"function","name":"_add_non_python_symbols_and_calls","path":"scripts/repo_graph.py","language":"python","start_line":566,"end_line":614,"context_start_line":546,"context_end_line":634,"code":"                    src=file_eid,\n                    dst=eid,\n                    type=\"owns\",\n                    attributes={\"lang\": \"python\"},\n                )\n            )\n\n        # Edges from backend (imports, calls, owns, tests, ...)\n        for e in cg.edges():\n            if (e.src not in self._entities) or (e.dst not in self._entities):\n                continue\n            self._edges.append(\n                Edge(\n                    src=e.src,\n                    dst=e.dst,\n                    type=e.type,\n                    attributes={\"lang\": \"python\"},\n                )\n            )\n\n    def _add_non_python_symbols_and_calls(self, files: List[str]) -> None:\n        \"\"\"\n        Add best-effort function/class symbols and a simple call graph for\n        non-Python languages (C/C++, Go, Java, JS/TS).\n\n        The call graph is heuristic: we scan for identifier`(` patterns in\n        each file and connect the *file entity* to any known symbol entity\n        with a matching name.\n        \"\"\"\n        # Pass 1: symbols\n        for abs_fp in files:\n            rel = os.path.relpath(abs_fp, self.repo_root).replace(\"\\\\\", \"/\")\n            _, ext = os.path.splitext(rel.lower())\n            if ext in (\".c\", \".h\", \".cc\", \".cpp\", \".cxx\", \".hpp\"):\n                self._index_c_cpp_symbols(abs_fp)\n            elif ext == \".go\":\n                self._index_go_symbols(abs_fp)\n            elif ext == \".java\":\n                self._index_java_symbols(abs_fp)\n            elif ext in (\".js\", \".jsx\", \".mjs\", \".ts\", \".tsx\"):\n                self._index_js_ts_symbols(abs_fp)\n\n        # Pass 2: heuristic calls (file-level callers)\n        call_rx = re.compile(r\"\\b([A-Za-z_][A-Za-z0-9_]*)\\s*\\(\")\n        for abs_fp in files:\n            src_eid = self._file_entity_for_abs.get(os.path.abspath(abs_fp))\n            if not src_eid:\n                continue\n            try:\n                with open(abs_fp, \"r\", encoding=\"utf-8\", errors=\"ignore\") as fh:\n                    text = fh.read()\n            except Exception:\n                continue\n            for m in call_rx.finditer(text):\n                name = m.group(1)\n                if not name:\n                    continue\n                cands = self._symbols_by_name.get(name.lower())\n                if not cands:\n                    continue\n                for dst_id in cands:\n                    self._edges.append(\n                        Edge(\n                            src=src_eid,\n                            dst=dst_id,\n                            type=\"calls\",\n                            attributes={\"heuristic\": \"name_scan\"},\n                        )\n                    )\n\n    def _index_c_cpp_symbols(self, abs_fp: str) -> None:\n        \"\"\"\n        Very coarse C/C++ function and class detector based on regexes.\n        \"\"\"\n        try:\n            with open(abs_fp, \"r\", encoding=\"utf-8\", errors=\"ignore\") as fh:\n                lines = fh.readlines()\n        except Exception:\n            return\n        # Function definitions: return-type name(args) { ... }\n        func_rx = re.compile(\n            r\"^[\\t ]*(?:[A-Za-z_][\\w\\s\\*\\:&<>\\[\\]]+)\\s+([A-Za-z_][A-Za-z0-9_]*)\\s*\\([^;]*\\)\\s*\\{\"\n        )\n        # Class/struct definitions\n        class_rx = re.compile(\n            r\"^[\\t ]*(class|struct)\\s+([A-Za-z_][A-Za-z0-9_]*)\\b\"\n        )\n        for idx, line in enumerate(lines, start=1):\n            m_func = func_rx.match(line)","source_hash":"cbc0aa5dcdb8bd7bf8e739e35d1190516934c4d470257d2017a31f88c0b7f173","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.repo_graph._index_c_cpp_symbols","uri":"program://TOLBERT/function/scripts.repo_graph._index_c_cpp_symbols#L616-L645","kind":"function","name":"_index_c_cpp_symbols","path":"scripts/repo_graph.py","language":"python","start_line":616,"end_line":645,"context_start_line":596,"context_end_line":665,"code":"                    text = fh.read()\n            except Exception:\n                continue\n            for m in call_rx.finditer(text):\n                name = m.group(1)\n                if not name:\n                    continue\n                cands = self._symbols_by_name.get(name.lower())\n                if not cands:\n                    continue\n                for dst_id in cands:\n                    self._edges.append(\n                        Edge(\n                            src=src_eid,\n                            dst=dst_id,\n                            type=\"calls\",\n                            attributes={\"heuristic\": \"name_scan\"},\n                        )\n                    )\n\n    def _index_c_cpp_symbols(self, abs_fp: str) -> None:\n        \"\"\"\n        Very coarse C/C++ function and class detector based on regexes.\n        \"\"\"\n        try:\n            with open(abs_fp, \"r\", encoding=\"utf-8\", errors=\"ignore\") as fh:\n                lines = fh.readlines()\n        except Exception:\n            return\n        # Function definitions: return-type name(args) { ... }\n        func_rx = re.compile(\n            r\"^[\\t ]*(?:[A-Za-z_][\\w\\s\\*\\:&<>\\[\\]]+)\\s+([A-Za-z_][A-Za-z0-9_]*)\\s*\\([^;]*\\)\\s*\\{\"\n        )\n        # Class/struct definitions\n        class_rx = re.compile(\n            r\"^[\\t ]*(class|struct)\\s+([A-Za-z_][A-Za-z0-9_]*)\\b\"\n        )\n        for idx, line in enumerate(lines, start=1):\n            m_func = func_rx.match(line)\n            if m_func:\n                name = m_func.group(1)\n                self._add_symbol_entity(\n                    abs_fp, name=name, kind=\"function\", lang_label=\"c_cpp\", start_line=idx, end_line=idx\n                )\n            m_cls = class_rx.match(line)\n            if m_cls:\n                name = m_cls.group(2)\n                self._add_symbol_entity(\n                    abs_fp, name=name, kind=\"class\", lang_label=\"c_cpp\", start_line=idx, end_line=idx\n                )\n\n    def _index_go_symbols(self, abs_fp: str) -> None:\n        \"\"\"\n        Coarse Go function and method detector.\n        \"\"\"\n        try:\n            with open(abs_fp, \"r\", encoding=\"utf-8\", errors=\"ignore\") as fh:\n                lines = fh.readlines()\n        except Exception:\n            return\n        # func name(...) or func (recv) name(...)\n        func_rx = re.compile(\n            r\"^[\\t ]*func\\s+(?:\\([^)]+\\)\\s*)?([A-Za-z_][A-Za-z0-9_]*)\\s*\\(\"\n        )\n        for idx, line in enumerate(lines, start=1):\n            m = func_rx.match(line)\n            if m:\n                name = m.group(1)\n                self._add_symbol_entity(\n                    abs_fp, name=name, kind=\"function\", lang_label=\"go\", start_line=idx, end_line=idx","source_hash":"cbc0aa5dcdb8bd7bf8e739e35d1190516934c4d470257d2017a31f88c0b7f173","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.repo_graph._index_go_symbols","uri":"program://TOLBERT/function/scripts.repo_graph._index_go_symbols#L647-L666","kind":"function","name":"_index_go_symbols","path":"scripts/repo_graph.py","language":"python","start_line":647,"end_line":666,"context_start_line":627,"context_end_line":686,"code":"            r\"^[\\t ]*(?:[A-Za-z_][\\w\\s\\*\\:&<>\\[\\]]+)\\s+([A-Za-z_][A-Za-z0-9_]*)\\s*\\([^;]*\\)\\s*\\{\"\n        )\n        # Class/struct definitions\n        class_rx = re.compile(\n            r\"^[\\t ]*(class|struct)\\s+([A-Za-z_][A-Za-z0-9_]*)\\b\"\n        )\n        for idx, line in enumerate(lines, start=1):\n            m_func = func_rx.match(line)\n            if m_func:\n                name = m_func.group(1)\n                self._add_symbol_entity(\n                    abs_fp, name=name, kind=\"function\", lang_label=\"c_cpp\", start_line=idx, end_line=idx\n                )\n            m_cls = class_rx.match(line)\n            if m_cls:\n                name = m_cls.group(2)\n                self._add_symbol_entity(\n                    abs_fp, name=name, kind=\"class\", lang_label=\"c_cpp\", start_line=idx, end_line=idx\n                )\n\n    def _index_go_symbols(self, abs_fp: str) -> None:\n        \"\"\"\n        Coarse Go function and method detector.\n        \"\"\"\n        try:\n            with open(abs_fp, \"r\", encoding=\"utf-8\", errors=\"ignore\") as fh:\n                lines = fh.readlines()\n        except Exception:\n            return\n        # func name(...) or func (recv) name(...)\n        func_rx = re.compile(\n            r\"^[\\t ]*func\\s+(?:\\([^)]+\\)\\s*)?([A-Za-z_][A-Za-z0-9_]*)\\s*\\(\"\n        )\n        for idx, line in enumerate(lines, start=1):\n            m = func_rx.match(line)\n            if m:\n                name = m.group(1)\n                self._add_symbol_entity(\n                    abs_fp, name=name, kind=\"function\", lang_label=\"go\", start_line=idx, end_line=idx\n                )\n\n    def _index_java_symbols(self, abs_fp: str) -> None:\n        \"\"\"\n        Coarse Java class and method detector.\n        \"\"\"\n        try:\n            with open(abs_fp, \"r\", encoding=\"utf-8\", errors=\"ignore\") as fh:\n                lines = fh.readlines()\n        except Exception:\n            return\n        class_rx = re.compile(\n            r\"^[\\t ]*(?:public|protected|private|abstract|final|static|\\s)*\\s*\"\n            r\"(class|interface|enum)\\s+([A-Za-z_][A-Za-z0-9_]*)\\b\"\n        )\n        method_rx = re.compile(\n            r\"^[\\t ]*(?:public|protected|private|static|final|synchronized|\\s)+\"\n            r\"[A-Za-z_\\$][\\w\\<\\>\\[\\]]*\\s+([A-Za-z_][A-Za-z0-9_]*)\\s*\\([^;]*\\)\\s*\\{\"\n        )\n        for idx, line in enumerate(lines, start=1):\n            m_cls = class_rx.match(line)","source_hash":"cbc0aa5dcdb8bd7bf8e739e35d1190516934c4d470257d2017a31f88c0b7f173","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.repo_graph._index_java_symbols","uri":"program://TOLBERT/function/scripts.repo_graph._index_java_symbols#L668-L697","kind":"function","name":"_index_java_symbols","path":"scripts/repo_graph.py","language":"python","start_line":668,"end_line":697,"context_start_line":648,"context_end_line":717,"code":"        \"\"\"\n        Coarse Go function and method detector.\n        \"\"\"\n        try:\n            with open(abs_fp, \"r\", encoding=\"utf-8\", errors=\"ignore\") as fh:\n                lines = fh.readlines()\n        except Exception:\n            return\n        # func name(...) or func (recv) name(...)\n        func_rx = re.compile(\n            r\"^[\\t ]*func\\s+(?:\\([^)]+\\)\\s*)?([A-Za-z_][A-Za-z0-9_]*)\\s*\\(\"\n        )\n        for idx, line in enumerate(lines, start=1):\n            m = func_rx.match(line)\n            if m:\n                name = m.group(1)\n                self._add_symbol_entity(\n                    abs_fp, name=name, kind=\"function\", lang_label=\"go\", start_line=idx, end_line=idx\n                )\n\n    def _index_java_symbols(self, abs_fp: str) -> None:\n        \"\"\"\n        Coarse Java class and method detector.\n        \"\"\"\n        try:\n            with open(abs_fp, \"r\", encoding=\"utf-8\", errors=\"ignore\") as fh:\n                lines = fh.readlines()\n        except Exception:\n            return\n        class_rx = re.compile(\n            r\"^[\\t ]*(?:public|protected|private|abstract|final|static|\\s)*\\s*\"\n            r\"(class|interface|enum)\\s+([A-Za-z_][A-Za-z0-9_]*)\\b\"\n        )\n        method_rx = re.compile(\n            r\"^[\\t ]*(?:public|protected|private|static|final|synchronized|\\s)+\"\n            r\"[A-Za-z_\\$][\\w\\<\\>\\[\\]]*\\s+([A-Za-z_][A-Za-z0-9_]*)\\s*\\([^;]*\\)\\s*\\{\"\n        )\n        for idx, line in enumerate(lines, start=1):\n            m_cls = class_rx.match(line)\n            if m_cls:\n                name = m_cls.group(2)\n                self._add_symbol_entity(\n                    abs_fp, name=name, kind=\"class\", lang_label=\"java\", start_line=idx, end_line=idx\n                )\n            m_m = method_rx.match(line)\n            if m_m:\n                name = m_m.group(1)\n                self._add_symbol_entity(\n                    abs_fp, name=name, kind=\"method\", lang_label=\"java\", start_line=idx, end_line=idx\n                )\n\n    def _index_js_ts_symbols(self, abs_fp: str) -> None:\n        \"\"\"\n        Coarse JS/TS function and class detector.\n        \"\"\"\n        try:\n            with open(abs_fp, \"r\", encoding=\"utf-8\", errors=\"ignore\") as fh:\n                lines = fh.readlines()\n        except Exception:\n            return\n        func_rx = re.compile(r\"^[\\t ]*function\\s+([A-Za-z_][A-Za-z0-9_]*)\\s*\\(\")\n        arrow_rx = re.compile(\n            r\"^[\\t ]*(?:const|let|var)\\s+([A-Za-z_][A-Za-z0-9_]*)\\s*=\\s*\\([^)]*\\)\\s*=>\"\n        )\n        class_rx = re.compile(r\"^[\\t ]*class\\s+([A-Za-z_][A-Za-z0-9_]*)\\b\")\n        for idx, line in enumerate(lines, start=1):\n            m_fn = func_rx.match(line)\n            if m_fn:\n                name = m_fn.group(1)\n                self._add_symbol_entity(","source_hash":"cbc0aa5dcdb8bd7bf8e739e35d1190516934c4d470257d2017a31f88c0b7f173","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.repo_graph._index_js_ts_symbols","uri":"program://TOLBERT/function/scripts.repo_graph._index_js_ts_symbols#L699-L731","kind":"function","name":"_index_js_ts_symbols","path":"scripts/repo_graph.py","language":"python","start_line":699,"end_line":731,"context_start_line":679,"context_end_line":733,"code":"            r\"(class|interface|enum)\\s+([A-Za-z_][A-Za-z0-9_]*)\\b\"\n        )\n        method_rx = re.compile(\n            r\"^[\\t ]*(?:public|protected|private|static|final|synchronized|\\s)+\"\n            r\"[A-Za-z_\\$][\\w\\<\\>\\[\\]]*\\s+([A-Za-z_][A-Za-z0-9_]*)\\s*\\([^;]*\\)\\s*\\{\"\n        )\n        for idx, line in enumerate(lines, start=1):\n            m_cls = class_rx.match(line)\n            if m_cls:\n                name = m_cls.group(2)\n                self._add_symbol_entity(\n                    abs_fp, name=name, kind=\"class\", lang_label=\"java\", start_line=idx, end_line=idx\n                )\n            m_m = method_rx.match(line)\n            if m_m:\n                name = m_m.group(1)\n                self._add_symbol_entity(\n                    abs_fp, name=name, kind=\"method\", lang_label=\"java\", start_line=idx, end_line=idx\n                )\n\n    def _index_js_ts_symbols(self, abs_fp: str) -> None:\n        \"\"\"\n        Coarse JS/TS function and class detector.\n        \"\"\"\n        try:\n            with open(abs_fp, \"r\", encoding=\"utf-8\", errors=\"ignore\") as fh:\n                lines = fh.readlines()\n        except Exception:\n            return\n        func_rx = re.compile(r\"^[\\t ]*function\\s+([A-Za-z_][A-Za-z0-9_]*)\\s*\\(\")\n        arrow_rx = re.compile(\n            r\"^[\\t ]*(?:const|let|var)\\s+([A-Za-z_][A-Za-z0-9_]*)\\s*=\\s*\\([^)]*\\)\\s*=>\"\n        )\n        class_rx = re.compile(r\"^[\\t ]*class\\s+([A-Za-z_][A-Za-z0-9_]*)\\b\")\n        for idx, line in enumerate(lines, start=1):\n            m_fn = func_rx.match(line)\n            if m_fn:\n                name = m_fn.group(1)\n                self._add_symbol_entity(\n                    abs_fp, name=name, kind=\"function\", lang_label=\"js_ts\", start_line=idx, end_line=idx\n                )\n            m_arrow = arrow_rx.match(line)\n            if m_arrow:\n                name = m_arrow.group(1)\n                self._add_symbol_entity(\n                    abs_fp, name=name, kind=\"function\", lang_label=\"js_ts\", start_line=idx, end_line=idx\n                )\n            m_cls = class_rx.match(line)\n            if m_cls:\n                name = m_cls.group(1)\n                self._add_symbol_entity(\n                    abs_fp, name=name, kind=\"class\", lang_label=\"js_ts\", start_line=idx, end_line=idx\n                )\n\n","source_hash":"cbc0aa5dcdb8bd7bf8e739e35d1190516934c4d470257d2017a31f88c0b7f173","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.eval_hierarchical_classification","uri":"program://TOLBERT/module/scripts.eval_hierarchical_classification#L1-L225","kind":"module","name":"scripts.eval_hierarchical_classification","path":"scripts/eval_hierarchical_classification.py","language":"python","start_line":1,"end_line":225,"context_start_line":1,"context_end_line":225,"code":"\"\"\"\nEvaluate a trained TOLBERT checkpoint on a labeled spans_file.\n\nThis script implements the hierarchical classification metrics discussed\nin the TOLBERT paper:\n\n  - per-level accuracy\n  - per-level micro F1 (for single-label multiclass this equals accuracy)\n  - path accuracy (all supervised levels correct for a span)\n\nUsage (CodeHierarchy example):\n\n  python -m scripts.eval_hierarchical_classification \\\\\n      --config configs/codehierarchy_example.yaml \\\\\n      --checkpoint checkpoints/codehierarchy/tolbert_epoch5.pt \\\\\n      --spans-file data/codehierarchy/spans_test.jsonl\n\"\"\"\n\nfrom __future__ import annotations\n\nimport argparse\nfrom pathlib import Path\nfrom typing import Any, Dict, List\n\nimport torch\nfrom torch.utils.data import DataLoader\nfrom transformers import AutoTokenizer\nimport os\n\nfrom tolbert.config import load_tolbert_config\nfrom tolbert.data import TreeOfLifeDataset, collate_tree_of_life_batch\nfrom tolbert.modeling import TOLBERT, TOLBERTConfig\n\n\ndef build_model(cfg: Dict[str, Any], checkpoint: str, device: torch.device) -> TOLBERT:\n    model_cfg = TOLBERTConfig(\n        base_model_name=cfg[\"base_model_name\"],\n        level_sizes=cfg[\"level_sizes\"],\n        proj_dim=cfg.get(\"proj_dim\", 256),\n        lambda_hier=cfg.get(\"lambda_hier\", 1.0),\n        lambda_path=cfg.get(\"lambda_path\", 0.0),\n        lambda_contrast=0.0,\n    )\n    model = TOLBERT(model_cfg)\n    state = torch.load(checkpoint, map_location=\"cpu\")\n    model.load_state_dict(state)\n    model.to(device)\n    model.eval()\n    return model\n\n\ndef parse_args() -> argparse.Namespace:\n    ap = argparse.ArgumentParser(description=\"Evaluate hierarchical classification for TOLBERT.\")\n    ap.add_argument(\"--config\", type=str, required=True, help=\"Training config used for the model.\")\n    ap.add_argument(\"--checkpoint\", type=str, required=True, help=\"Path to model .pt checkpoint.\")\n    ap.add_argument(\"--spans-file\", type=str, required=True, help=\"Labeled spans JSONL file for eval.\")\n    ap.add_argument(\n        \"--batch-size\",\n        type=int,\n        default=64,\n        help=\"Evaluation batch size (default: 64).\",\n    )\n    ap.add_argument(\n        \"--device\",\n        type=str,\n        default=\"cuda\" if torch.cuda.is_available() else \"cpu\",\n        help=\"Device to use.\",\n    )\n    return ap.parse_args()\n\n\ndef main() -> None:\n    args = parse_args()\n    cfg = load_tolbert_config(args.config)\n    device = torch.device(args.device)\n\n    spans_path = Path(args.spans_file)\n    if not spans_path.exists():\n        raise FileNotFoundError(f\"spans_file not found: {spans_path}\")\n\n    tokenizer = AutoTokenizer.from_pretrained(\n        cfg[\"base_model_name\"],\n        cache_dir=\"/data/checkpoints/\",  # noqa: E501\n    )\n\n    dataset = TreeOfLifeDataset(\n        spans_file=str(spans_path),\n        tokenizer=tokenizer,\n        max_length=cfg.get(\"max_length\", 256),\n        mask_probability=cfg.get(\"mask_probability\", 0.15),\n    )\n\n    dataloader = DataLoader(\n        dataset,\n        batch_size=args.batch_size,\n        shuffle=False,\n        num_workers=cfg.get(\"num_workers\", 0),\n        collate_fn=collate_tree_of_life_batch,\n    )\n\n    model = build_model(cfg, checkpoint=args.checkpoint, device=device)\n\n    # Metrics accumulators: per-level correct / total\n    level_correct: Dict[int, int] = {}\n    level_total: Dict[int, int] = {}\n\n    # For path accuracy we track per-example correctness across supervised levels.\n    path_correct = 0\n    path_total = 0\n\n    # For hierarchical precision/recall/F1 (Kiritchenko-style, single-path case),\n    # we treat each (level, node_id) pair as one \"label\". Since every supervised\n    # level has exactly one node, this reduces to counting how many levels are\n    # correct across all examples.\n    hier_total_true = 0\n    hier_total_pred = 0\n    hier_total_correct = 0\n\n    with torch.no_grad():\n        for batch in dataloader:\n            input_ids = batch[\"input_ids\"].to(device)\n            attention_mask = batch[\"attention_mask\"].to(device)\n            level_targets = {\n                level: targets.to(device) for level, targets in batch[\"level_targets\"].items()\n            }\n\n            out = model(\n                input_ids=input_ids,\n                attention_mask=attention_mask,\n                level_targets=level_targets,\n                paths=batch.get(\"paths\"),\n            )\n            level_logits: Dict[str, torch.Tensor] = out[\"level_logits\"]\n\n            batch_size = input_ids.size(0)\n            # Track per-example path correctness over all available levels.\n            per_example_all_correct: List[bool] = [True] * batch_size\n\n            for level_int, targets in level_targets.items():\n                logits = level_logits[str(level_int)]\n                preds = logits.argmax(dim=-1)\n\n                # Ignore positions where target == -100 (unknown/masked level)\n                mask = targets != -100\n                if mask.sum().item() == 0:\n                    continue\n\n                correct = (preds == targets) & mask\n                num_correct = correct.sum().item()\n                num_total = mask.sum().item()\n\n                level_correct[level_int] = level_correct.get(level_int, 0) + num_correct\n                level_total[level_int] = level_total.get(level_int, 0) + num_total\n\n                # For hierarchical precision/recall we count each supervised\n                # (example, level) as one \"true\" label and one \"predicted\" label.\n                # A label is correct iff the level prediction matches the target.\n                hier_total_true += num_total\n                hier_total_pred += num_total\n                hier_total_correct += num_correct\n\n                # Update per-example correctness for path accuracy\n                # Only consider examples where this level is supervised.\n                for i in range(batch_size):\n                    if not mask[i]:\n                        continue\n                    if not bool(correct[i]):\n                        per_example_all_correct[i] = False\n\n            # Update path metrics: any example that had at least one supervised level\n            # contributes to the denominator; it counts as correct only if all such\n            # supervised levels were predicted correctly.\n            for i in range(batch_size):\n                # A sample is included if it has any supervised level\n                has_any_level = any(\n                    batch[\"level_targets\"][lvl][i].item() != -100\n                    for lvl in batch[\"level_targets\"]\n                )\n                if not has_any_level:\n                    continue\n                path_total += 1\n                if per_example_all_correct[i]:\n                    path_correct += 1\n\n    print(\"=== Hierarchical Classification Evaluation ===\")\n    for level in sorted(level_total.keys()):\n        acc = level_correct[level] / max(1, level_total[level])\n        # For single-label multiclass, micro-F1 equals accuracy; we report it explicitly.\n        micro_f1 = acc\n        print(\n            f\"Level {level}: \"\n            f\"accuracy={acc:.4f} \"\n            f\"micro_F1={micro_f1:.4f} \"\n            f\"(n={level_total[level]})\"\n        )\n\n    path_acc = path_correct / max(1, path_total)\n    print(f\"Path accuracy (all supervised levels correct): {path_acc:.4f} (n={path_total})\")\n\n    # Global hierarchical precision/recall/F1 over the full path, adapted from\n    # Kiritchenko et al. to the single-path, single-label-per-level setting.\n    # Here:\n    #   - \"true labels\"  = all supervised (example, level) pairs,\n    #   - \"pred labels\"  = one prediction per supervised level,\n    #   - \"correct\"      = prediction matches the ground-truth node at that level.\n    if hier_total_true > 0 and hier_total_pred > 0:\n        hier_prec = hier_total_correct / hier_total_pred\n        hier_rec = hier_total_correct / hier_total_true\n        if hier_prec + hier_rec > 0.0:\n            hier_f1 = 2.0 * hier_prec * hier_rec / (hier_prec + hier_rec)\n        else:\n            hier_f1 = 0.0\n        print(\n            \"Hierarchical P/R/F1 over paths \"\n            f\"(micro-style over all levels): \"\n            f\"precision={hier_prec:.4f} recall={hier_rec:.4f} F1={hier_f1:.4f}\"\n        )\n    else:\n        print(\"Hierarchical P/R/F1 over paths: undefined (no supervised labels).\")\n\n\nif __name__ == \"__main__\":\n    main()\n\n","source_hash":"acb23c51c73bcda18fef8093cea458f7e7c239b33c9544dfb7e51fa2e0aae41f","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.eval_hierarchical_classification.build_model","uri":"program://TOLBERT/function/scripts.eval_hierarchical_classification.build_model#L35-L49","kind":"function","name":"build_model","path":"scripts/eval_hierarchical_classification.py","language":"python","start_line":35,"end_line":49,"context_start_line":15,"context_end_line":69,"code":"      --checkpoint checkpoints/codehierarchy/tolbert_epoch5.pt \\\\\n      --spans-file data/codehierarchy/spans_test.jsonl\n\"\"\"\n\nfrom __future__ import annotations\n\nimport argparse\nfrom pathlib import Path\nfrom typing import Any, Dict, List\n\nimport torch\nfrom torch.utils.data import DataLoader\nfrom transformers import AutoTokenizer\nimport os\n\nfrom tolbert.config import load_tolbert_config\nfrom tolbert.data import TreeOfLifeDataset, collate_tree_of_life_batch\nfrom tolbert.modeling import TOLBERT, TOLBERTConfig\n\n\ndef build_model(cfg: Dict[str, Any], checkpoint: str, device: torch.device) -> TOLBERT:\n    model_cfg = TOLBERTConfig(\n        base_model_name=cfg[\"base_model_name\"],\n        level_sizes=cfg[\"level_sizes\"],\n        proj_dim=cfg.get(\"proj_dim\", 256),\n        lambda_hier=cfg.get(\"lambda_hier\", 1.0),\n        lambda_path=cfg.get(\"lambda_path\", 0.0),\n        lambda_contrast=0.0,\n    )\n    model = TOLBERT(model_cfg)\n    state = torch.load(checkpoint, map_location=\"cpu\")\n    model.load_state_dict(state)\n    model.to(device)\n    model.eval()\n    return model\n\n\ndef parse_args() -> argparse.Namespace:\n    ap = argparse.ArgumentParser(description=\"Evaluate hierarchical classification for TOLBERT.\")\n    ap.add_argument(\"--config\", type=str, required=True, help=\"Training config used for the model.\")\n    ap.add_argument(\"--checkpoint\", type=str, required=True, help=\"Path to model .pt checkpoint.\")\n    ap.add_argument(\"--spans-file\", type=str, required=True, help=\"Labeled spans JSONL file for eval.\")\n    ap.add_argument(\n        \"--batch-size\",\n        type=int,\n        default=64,\n        help=\"Evaluation batch size (default: 64).\",\n    )\n    ap.add_argument(\n        \"--device\",\n        type=str,\n        default=\"cuda\" if torch.cuda.is_available() else \"cpu\",\n        help=\"Device to use.\",\n    )\n    return ap.parse_args()","source_hash":"acb23c51c73bcda18fef8093cea458f7e7c239b33c9544dfb7e51fa2e0aae41f","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.eval_hierarchical_classification.parse_args","uri":"program://TOLBERT/function/scripts.eval_hierarchical_classification.parse_args#L52-L69","kind":"function","name":"parse_args","path":"scripts/eval_hierarchical_classification.py","language":"python","start_line":52,"end_line":69,"context_start_line":32,"context_end_line":89,"code":"from tolbert.modeling import TOLBERT, TOLBERTConfig\n\n\ndef build_model(cfg: Dict[str, Any], checkpoint: str, device: torch.device) -> TOLBERT:\n    model_cfg = TOLBERTConfig(\n        base_model_name=cfg[\"base_model_name\"],\n        level_sizes=cfg[\"level_sizes\"],\n        proj_dim=cfg.get(\"proj_dim\", 256),\n        lambda_hier=cfg.get(\"lambda_hier\", 1.0),\n        lambda_path=cfg.get(\"lambda_path\", 0.0),\n        lambda_contrast=0.0,\n    )\n    model = TOLBERT(model_cfg)\n    state = torch.load(checkpoint, map_location=\"cpu\")\n    model.load_state_dict(state)\n    model.to(device)\n    model.eval()\n    return model\n\n\ndef parse_args() -> argparse.Namespace:\n    ap = argparse.ArgumentParser(description=\"Evaluate hierarchical classification for TOLBERT.\")\n    ap.add_argument(\"--config\", type=str, required=True, help=\"Training config used for the model.\")\n    ap.add_argument(\"--checkpoint\", type=str, required=True, help=\"Path to model .pt checkpoint.\")\n    ap.add_argument(\"--spans-file\", type=str, required=True, help=\"Labeled spans JSONL file for eval.\")\n    ap.add_argument(\n        \"--batch-size\",\n        type=int,\n        default=64,\n        help=\"Evaluation batch size (default: 64).\",\n    )\n    ap.add_argument(\n        \"--device\",\n        type=str,\n        default=\"cuda\" if torch.cuda.is_available() else \"cpu\",\n        help=\"Device to use.\",\n    )\n    return ap.parse_args()\n\n\ndef main() -> None:\n    args = parse_args()\n    cfg = load_tolbert_config(args.config)\n    device = torch.device(args.device)\n\n    spans_path = Path(args.spans_file)\n    if not spans_path.exists():\n        raise FileNotFoundError(f\"spans_file not found: {spans_path}\")\n\n    tokenizer = AutoTokenizer.from_pretrained(\n        cfg[\"base_model_name\"],\n        cache_dir=\"/data/checkpoints/\",  # noqa: E501\n    )\n\n    dataset = TreeOfLifeDataset(\n        spans_file=str(spans_path),\n        tokenizer=tokenizer,\n        max_length=cfg.get(\"max_length\", 256),","source_hash":"acb23c51c73bcda18fef8093cea458f7e7c239b33c9544dfb7e51fa2e0aae41f","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.eval_hierarchical_classification.main","uri":"program://TOLBERT/function/scripts.eval_hierarchical_classification.main#L72-L219","kind":"function","name":"main","path":"scripts/eval_hierarchical_classification.py","language":"python","start_line":72,"end_line":219,"context_start_line":52,"context_end_line":225,"code":"def parse_args() -> argparse.Namespace:\n    ap = argparse.ArgumentParser(description=\"Evaluate hierarchical classification for TOLBERT.\")\n    ap.add_argument(\"--config\", type=str, required=True, help=\"Training config used for the model.\")\n    ap.add_argument(\"--checkpoint\", type=str, required=True, help=\"Path to model .pt checkpoint.\")\n    ap.add_argument(\"--spans-file\", type=str, required=True, help=\"Labeled spans JSONL file for eval.\")\n    ap.add_argument(\n        \"--batch-size\",\n        type=int,\n        default=64,\n        help=\"Evaluation batch size (default: 64).\",\n    )\n    ap.add_argument(\n        \"--device\",\n        type=str,\n        default=\"cuda\" if torch.cuda.is_available() else \"cpu\",\n        help=\"Device to use.\",\n    )\n    return ap.parse_args()\n\n\ndef main() -> None:\n    args = parse_args()\n    cfg = load_tolbert_config(args.config)\n    device = torch.device(args.device)\n\n    spans_path = Path(args.spans_file)\n    if not spans_path.exists():\n        raise FileNotFoundError(f\"spans_file not found: {spans_path}\")\n\n    tokenizer = AutoTokenizer.from_pretrained(\n        cfg[\"base_model_name\"],\n        cache_dir=\"/data/checkpoints/\",  # noqa: E501\n    )\n\n    dataset = TreeOfLifeDataset(\n        spans_file=str(spans_path),\n        tokenizer=tokenizer,\n        max_length=cfg.get(\"max_length\", 256),\n        mask_probability=cfg.get(\"mask_probability\", 0.15),\n    )\n\n    dataloader = DataLoader(\n        dataset,\n        batch_size=args.batch_size,\n        shuffle=False,\n        num_workers=cfg.get(\"num_workers\", 0),\n        collate_fn=collate_tree_of_life_batch,\n    )\n\n    model = build_model(cfg, checkpoint=args.checkpoint, device=device)\n\n    # Metrics accumulators: per-level correct / total\n    level_correct: Dict[int, int] = {}\n    level_total: Dict[int, int] = {}\n\n    # For path accuracy we track per-example correctness across supervised levels.\n    path_correct = 0\n    path_total = 0\n\n    # For hierarchical precision/recall/F1 (Kiritchenko-style, single-path case),\n    # we treat each (level, node_id) pair as one \"label\". Since every supervised\n    # level has exactly one node, this reduces to counting how many levels are\n    # correct across all examples.\n    hier_total_true = 0\n    hier_total_pred = 0\n    hier_total_correct = 0\n\n    with torch.no_grad():\n        for batch in dataloader:\n            input_ids = batch[\"input_ids\"].to(device)\n            attention_mask = batch[\"attention_mask\"].to(device)\n            level_targets = {\n                level: targets.to(device) for level, targets in batch[\"level_targets\"].items()\n            }\n\n            out = model(\n                input_ids=input_ids,\n                attention_mask=attention_mask,\n                level_targets=level_targets,\n                paths=batch.get(\"paths\"),\n            )\n            level_logits: Dict[str, torch.Tensor] = out[\"level_logits\"]\n\n            batch_size = input_ids.size(0)\n            # Track per-example path correctness over all available levels.\n            per_example_all_correct: List[bool] = [True] * batch_size\n\n            for level_int, targets in level_targets.items():\n                logits = level_logits[str(level_int)]\n                preds = logits.argmax(dim=-1)\n\n                # Ignore positions where target == -100 (unknown/masked level)\n                mask = targets != -100\n                if mask.sum().item() == 0:\n                    continue\n\n                correct = (preds == targets) & mask\n                num_correct = correct.sum().item()\n                num_total = mask.sum().item()\n\n                level_correct[level_int] = level_correct.get(level_int, 0) + num_correct\n                level_total[level_int] = level_total.get(level_int, 0) + num_total\n\n                # For hierarchical precision/recall we count each supervised\n                # (example, level) as one \"true\" label and one \"predicted\" label.\n                # A label is correct iff the level prediction matches the target.\n                hier_total_true += num_total\n                hier_total_pred += num_total\n                hier_total_correct += num_correct\n\n                # Update per-example correctness for path accuracy\n                # Only consider examples where this level is supervised.\n                for i in range(batch_size):\n                    if not mask[i]:\n                        continue\n                    if not bool(correct[i]):\n                        per_example_all_correct[i] = False\n\n            # Update path metrics: any example that had at least one supervised level\n            # contributes to the denominator; it counts as correct only if all such\n            # supervised levels were predicted correctly.\n            for i in range(batch_size):\n                # A sample is included if it has any supervised level\n                has_any_level = any(\n                    batch[\"level_targets\"][lvl][i].item() != -100\n                    for lvl in batch[\"level_targets\"]\n                )\n                if not has_any_level:\n                    continue\n                path_total += 1\n                if per_example_all_correct[i]:\n                    path_correct += 1\n\n    print(\"=== Hierarchical Classification Evaluation ===\")\n    for level in sorted(level_total.keys()):\n        acc = level_correct[level] / max(1, level_total[level])\n        # For single-label multiclass, micro-F1 equals accuracy; we report it explicitly.\n        micro_f1 = acc\n        print(\n            f\"Level {level}: \"\n            f\"accuracy={acc:.4f} \"\n            f\"micro_F1={micro_f1:.4f} \"\n            f\"(n={level_total[level]})\"\n        )\n\n    path_acc = path_correct / max(1, path_total)\n    print(f\"Path accuracy (all supervised levels correct): {path_acc:.4f} (n={path_total})\")\n\n    # Global hierarchical precision/recall/F1 over the full path, adapted from\n    # Kiritchenko et al. to the single-path, single-label-per-level setting.\n    # Here:\n    #   - \"true labels\"  = all supervised (example, level) pairs,\n    #   - \"pred labels\"  = one prediction per supervised level,\n    #   - \"correct\"      = prediction matches the ground-truth node at that level.\n    if hier_total_true > 0 and hier_total_pred > 0:\n        hier_prec = hier_total_correct / hier_total_pred\n        hier_rec = hier_total_correct / hier_total_true\n        if hier_prec + hier_rec > 0.0:\n            hier_f1 = 2.0 * hier_prec * hier_rec / (hier_prec + hier_rec)\n        else:\n            hier_f1 = 0.0\n        print(\n            \"Hierarchical P/R/F1 over paths \"\n            f\"(micro-style over all levels): \"\n            f\"precision={hier_prec:.4f} recall={hier_rec:.4f} F1={hier_f1:.4f}\"\n        )\n    else:\n        print(\"Hierarchical P/R/F1 over paths: undefined (no supervised labels).\")\n\n\nif __name__ == \"__main__\":\n    main()\n\n","source_hash":"acb23c51c73bcda18fef8093cea458f7e7c239b33c9544dfb7e51fa2e0aae41f","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.build_repo_tree_of_life","uri":"program://TOLBERT/module/scripts.build_repo_tree_of_life#L1-L286","kind":"module","name":"scripts.build_repo_tree_of_life","path":"scripts/build_repo_tree_of_life.py","language":"python","start_line":1,"end_line":286,"context_start_line":1,"context_end_line":286,"code":"\"\"\"\nBuild a simple Tree-of-Life taxonomy and span records from a single repository\nusing the language-agnostic RepoGraph.\n\nThis is a concrete, graph-driven implementation of the code-side part of\n`docs/tree_of_life.md`:\n\n  - Nodes:\n      level 0: root\n      level 1: language nodes (Python, Java, C/C++, Go, JS/TS, ...)\n      level 2: repo node\n      level 3: top-level directory nodes (subtrees within the repo)\n      level 4: file nodes\n      level 5: symbol nodes (functions / methods / classes), when available\n\n  - Edges:\n      parent_id / child_id edges forming a tree over the above nodes.\n\n  - Spans:\n      one span per file, with a node_path from root → language → repo →\n      top-level directory → file.\n\nYou can use the resulting nodes.jsonl / edges.jsonl / spans.jsonl as direct\ninputs to the training pipeline described in `docs/tree_of_life.md` and\n`docs/training.md`.\n\"\"\"\n\nfrom __future__ import annotations\n\nimport argparse\nimport json\nimport os\nfrom pathlib import Path\nfrom typing import Dict, List, Optional, Tuple\n\nfrom scripts.repo_graph import RepoGraph\n\n\ndef _primary_language_for_file_entity(labels: List[str]) -> Optional[str]:\n    for lab in labels:\n        if lab.startswith(\"lang:\"):\n            return lab.split(\":\", 1)[1]\n    return None\n\n\ndef build_tree_for_repo(\n    repo_root: Path,\n) -> Tuple[List[Dict[str, object]], List[Dict[str, object]], List[Dict[str, object]]]:\n    \"\"\"\n    Return (nodes, edges, spans) lists.\n    \"\"\"\n    g = RepoGraph(str(repo_root))\n    ents = list(g.entities())\n\n    # Node id assignment\n    next_id = 0\n\n    def alloc_id() -> int:\n        nonlocal next_id\n        nid = next_id\n        next_id += 1\n        return nid\n\n    nodes: List[Dict[str, object]] = []\n    edges: List[Dict[str, object]] = []\n    spans: List[Dict[str, object]] = []\n\n    # Level 0: root\n    root_id = alloc_id()\n    nodes.append(\n        {\n            \"node_id\": root_id,\n            \"level\": 0,\n            \"type\": \"root\",\n            \"parent_id\": None,\n            \"name\": \"Root\",\n            \"attributes\": {},\n        }\n    )\n\n    # Language nodes (level 1)\n    lang_to_id: Dict[str, int] = {}\n\n    # Single repo node (level 2)\n    repo_name = os.path.basename(os.path.abspath(repo_root))\n    # We will pick a \"primary language\" below for the repo parent.\n\n    # File / symbol entities from RepoGraph\n    file_ents: List[Tuple[str, object]] = []  # (entity_id, entity)\n    symbol_ents: List[Tuple[str, object]] = []\n    for e in ents:\n        if getattr(e, \"kind\", \"\") == \"file\":\n            file_ents.append((e.id, e))\n        elif getattr(e, \"kind\", \"\") in (\"function\", \"class\", \"method\"):\n            symbol_ents.append((e.id, e))\n\n    # Collect languages observed in files\n    file_langs: Dict[str, int] = {}\n    for _, e in file_ents:\n        lang = _primary_language_for_file_entity(getattr(e, \"labels\", []))\n        if not lang:\n            continue\n        file_langs[lang] = file_langs.get(lang, 0) + 1\n\n    # Create language nodes\n    for lang in sorted(file_langs.keys()):\n        nid = alloc_id()\n        lang_to_id[lang] = nid\n        nodes.append(\n            {\n                \"node_id\": nid,\n                \"level\": 1,\n                \"type\": \"language\",\n                \"parent_id\": root_id,\n                \"name\": lang,\n                \"attributes\": {},\n            }\n        )\n        edges.append({\"parent_id\": root_id, \"child_id\": nid})\n\n    # Choose a primary language for the repo (highest file count; fallback: None)\n    primary_lang: Optional[str] = None\n    if file_langs:\n        primary_lang = max(file_langs.items(), key=lambda kv: kv[1])[0]\n\n    repo_parent = lang_to_id.get(primary_lang, root_id)\n    repo_id = alloc_id()\n    nodes.append(\n        {\n            \"node_id\": repo_id,\n            \"level\": 2,\n            \"type\": \"repo\",\n            \"parent_id\": repo_parent,\n            \"name\": repo_name,\n            \"attributes\": {\"root\": str(repo_root)},\n        }\n    )\n    edges.append({\"parent_id\": repo_parent, \"child_id\": repo_id})\n\n    # Level 3: top-level directories / subtrees\n    subdir_to_id: Dict[str, int] = {}\n    for _, e in file_ents:\n        rel = str(getattr(e, \"attributes\", {}).get(\"rel_path\", \"\"))\n        top = rel.split(\"/\", 1)[0] if \"/\" in rel else \"\"\n        key = top or \"(root)\"\n        if key in subdir_to_id:\n            continue\n        nid = alloc_id()\n        subdir_to_id[key] = nid\n        nodes.append(\n            {\n                \"node_id\": nid,\n                \"level\": 3,\n                \"type\": \"subdir\",\n                \"parent_id\": repo_id,\n                \"name\": key,\n                \"attributes\": {},\n            }\n        )\n        edges.append({\"parent_id\": repo_id, \"child_id\": nid})\n\n    # Level 4: files\n    fileid_to_nodeid: Dict[str, int] = {}\n    for eid, e in file_ents:\n        rel = str(getattr(e, \"attributes\", {}).get(\"rel_path\", \"\"))\n        top = rel.split(\"/\", 1)[0] if \"/\" in rel else \"\"\n        key = top or \"(root)\"\n        parent_id = subdir_to_id[key]\n        nid = alloc_id()\n        fileid_to_nodeid[eid] = nid\n        nodes.append(\n            {\n                \"node_id\": nid,\n                \"level\": 4,\n                \"type\": \"file\",\n                \"parent_id\": parent_id,\n                \"name\": rel,\n                \"attributes\": {\"artifact_uri\": getattr(e, \"artifact_uri\", None)},\n            }\n        )\n        edges.append({\"parent_id\": parent_id, \"child_id\": nid})\n\n    # Level 5: symbols (functions / methods / classes).\n    for _, e in symbol_ents:\n        art_uri = getattr(e, \"artifact_uri\", None)\n        if not art_uri:\n            continue\n        # Find the file entity that owns this symbol via artifact_uri match.\n        parent_node_id: Optional[int] = None\n        for fe_id, fe in file_ents:\n            if getattr(fe, \"artifact_uri\", None) == art_uri:\n                parent_node_id = fileid_to_nodeid.get(fe_id)\n                break\n        if parent_node_id is None:\n            continue\n        nid = alloc_id()\n        nodes.append(\n            {\n                \"node_id\": nid,\n                \"level\": 5,\n                \"type\": getattr(e, \"kind\", \"symbol\"),\n                \"parent_id\": parent_node_id,\n                \"name\": str(getattr(e, \"attributes\", {}).get(\"name\", \"\")),\n                \"attributes\": {\n                    \"artifact_uri\": art_uri,\n                    \"span\": {\n                        \"start_line\": getattr(getattr(e, \"span\", None), \"start_line\", None),  # type: ignore[attr-defined]  # noqa: E501\n                        \"end_line\": getattr(getattr(e, \"span\", None), \"end_line\", None),  # type: ignore[attr-defined]  # noqa: E501\n                    },\n                },\n            }\n        )\n        edges.append({\"parent_id\": parent_node_id, \"child_id\": nid})\n\n    # Spans: one per file, rooted at file nodes.\n    for eid, e in file_ents:\n        rel = str(getattr(e, \"attributes\", {}).get(\"rel_path\", \"\"))\n        abs_path = repo_root / rel\n        try:\n            text = abs_path.read_text(encoding=\"utf-8\")\n        except Exception:\n            continue\n        file_node_id = fileid_to_nodeid[eid]\n        # Node path: root → language (primary) → repo → subdir → file.\n        lang_id = repo_parent if repo_parent != root_id else None\n        top = rel.split(\"/\", 1)[0] if \"/\" in rel else \"\"\n        key = top or \"(root)\"\n        subdir_id = subdir_to_id[key]\n        path: List[int] = [root_id]\n        if lang_id is not None:\n            path.append(lang_id)\n        path.extend([repo_id, subdir_id, file_node_id])\n        spans.append(\n            {\n                \"span_id\": rel,\n                \"text\": text,\n                \"source_id\": rel,\n                \"node_path\": path,\n                \"meta\": {},\n            }\n        )\n\n    return nodes, edges, spans\n\n\ndef main() -> None:\n    ap = argparse.ArgumentParser()\n    ap.add_argument(\"repo_root\", type=str, help=\"Path to a single repository root\")\n    ap.add_argument(\"--nodes-out\", type=str, required=True, help=\"Output nodes.jsonl\")\n    ap.add_argument(\"--edges-out\", type=str, required=True, help=\"Output edges.jsonl\")\n    ap.add_argument(\n        \"--spans-out\",\n        type=str,\n        default=None,\n        help=\"Optional spans.jsonl output (one span per file)\",\n    )\n    args = ap.parse_args()\n\n    repo_root = Path(args.repo_root)\n    nodes, edges, spans = build_tree_for_repo(repo_root)\n\n    nodes_path = Path(args.nodes_out)\n    edges_path = Path(args.edges_out)\n    nodes_path.parent.mkdir(parents=True, exist_ok=True)\n    edges_path.parent.mkdir(parents=True, exist_ok=True)\n\n    with nodes_path.open(\"w\", encoding=\"utf-8\") as f:\n        for row in nodes:\n            f.write(json.dumps(row) + \"\\n\")\n\n    with edges_path.open(\"w\", encoding=\"utf-8\") as f:\n        for row in edges:\n            f.write(json.dumps(row) + \"\\n\")\n\n    if args.spans_out is not None:\n        spans_path = Path(args.spans_out)\n        spans_path.parent.mkdir(parents=True, exist_ok=True)\n        with spans_path.open(\"w\", encoding=\"utf-8\") as f:\n            for row in spans:\n                f.write(json.dumps(row) + \"\\n\")\n\n\nif __name__ == \"__main__\":\n    main()\n\n","source_hash":"b673708c0bd5ff3dd51161d80a8765539b0df20bd24126c18bc79efc8f1e18a8","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.build_repo_tree_of_life._primary_language_for_file_entity","uri":"program://TOLBERT/function/scripts.build_repo_tree_of_life._primary_language_for_file_entity#L39-L43","kind":"function","name":"_primary_language_for_file_entity","path":"scripts/build_repo_tree_of_life.py","language":"python","start_line":39,"end_line":43,"context_start_line":19,"context_end_line":63,"code":"  - Spans:\n      one span per file, with a node_path from root → language → repo →\n      top-level directory → file.\n\nYou can use the resulting nodes.jsonl / edges.jsonl / spans.jsonl as direct\ninputs to the training pipeline described in `docs/tree_of_life.md` and\n`docs/training.md`.\n\"\"\"\n\nfrom __future__ import annotations\n\nimport argparse\nimport json\nimport os\nfrom pathlib import Path\nfrom typing import Dict, List, Optional, Tuple\n\nfrom scripts.repo_graph import RepoGraph\n\n\ndef _primary_language_for_file_entity(labels: List[str]) -> Optional[str]:\n    for lab in labels:\n        if lab.startswith(\"lang:\"):\n            return lab.split(\":\", 1)[1]\n    return None\n\n\ndef build_tree_for_repo(\n    repo_root: Path,\n) -> Tuple[List[Dict[str, object]], List[Dict[str, object]], List[Dict[str, object]]]:\n    \"\"\"\n    Return (nodes, edges, spans) lists.\n    \"\"\"\n    g = RepoGraph(str(repo_root))\n    ents = list(g.entities())\n\n    # Node id assignment\n    next_id = 0\n\n    def alloc_id() -> int:\n        nonlocal next_id\n        nid = next_id\n        next_id += 1\n        return nid\n","source_hash":"b673708c0bd5ff3dd51161d80a8765539b0df20bd24126c18bc79efc8f1e18a8","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.build_repo_tree_of_life.build_tree_for_repo","uri":"program://TOLBERT/function/scripts.build_repo_tree_of_life.build_tree_for_repo#L46-L243","kind":"function","name":"build_tree_for_repo","path":"scripts/build_repo_tree_of_life.py","language":"python","start_line":46,"end_line":243,"context_start_line":26,"context_end_line":263,"code":"\"\"\"\n\nfrom __future__ import annotations\n\nimport argparse\nimport json\nimport os\nfrom pathlib import Path\nfrom typing import Dict, List, Optional, Tuple\n\nfrom scripts.repo_graph import RepoGraph\n\n\ndef _primary_language_for_file_entity(labels: List[str]) -> Optional[str]:\n    for lab in labels:\n        if lab.startswith(\"lang:\"):\n            return lab.split(\":\", 1)[1]\n    return None\n\n\ndef build_tree_for_repo(\n    repo_root: Path,\n) -> Tuple[List[Dict[str, object]], List[Dict[str, object]], List[Dict[str, object]]]:\n    \"\"\"\n    Return (nodes, edges, spans) lists.\n    \"\"\"\n    g = RepoGraph(str(repo_root))\n    ents = list(g.entities())\n\n    # Node id assignment\n    next_id = 0\n\n    def alloc_id() -> int:\n        nonlocal next_id\n        nid = next_id\n        next_id += 1\n        return nid\n\n    nodes: List[Dict[str, object]] = []\n    edges: List[Dict[str, object]] = []\n    spans: List[Dict[str, object]] = []\n\n    # Level 0: root\n    root_id = alloc_id()\n    nodes.append(\n        {\n            \"node_id\": root_id,\n            \"level\": 0,\n            \"type\": \"root\",\n            \"parent_id\": None,\n            \"name\": \"Root\",\n            \"attributes\": {},\n        }\n    )\n\n    # Language nodes (level 1)\n    lang_to_id: Dict[str, int] = {}\n\n    # Single repo node (level 2)\n    repo_name = os.path.basename(os.path.abspath(repo_root))\n    # We will pick a \"primary language\" below for the repo parent.\n\n    # File / symbol entities from RepoGraph\n    file_ents: List[Tuple[str, object]] = []  # (entity_id, entity)\n    symbol_ents: List[Tuple[str, object]] = []\n    for e in ents:\n        if getattr(e, \"kind\", \"\") == \"file\":\n            file_ents.append((e.id, e))\n        elif getattr(e, \"kind\", \"\") in (\"function\", \"class\", \"method\"):\n            symbol_ents.append((e.id, e))\n\n    # Collect languages observed in files\n    file_langs: Dict[str, int] = {}\n    for _, e in file_ents:\n        lang = _primary_language_for_file_entity(getattr(e, \"labels\", []))\n        if not lang:\n            continue\n        file_langs[lang] = file_langs.get(lang, 0) + 1\n\n    # Create language nodes\n    for lang in sorted(file_langs.keys()):\n        nid = alloc_id()\n        lang_to_id[lang] = nid\n        nodes.append(\n            {\n                \"node_id\": nid,\n                \"level\": 1,\n                \"type\": \"language\",\n                \"parent_id\": root_id,\n                \"name\": lang,\n                \"attributes\": {},\n            }\n        )\n        edges.append({\"parent_id\": root_id, \"child_id\": nid})\n\n    # Choose a primary language for the repo (highest file count; fallback: None)\n    primary_lang: Optional[str] = None\n    if file_langs:\n        primary_lang = max(file_langs.items(), key=lambda kv: kv[1])[0]\n\n    repo_parent = lang_to_id.get(primary_lang, root_id)\n    repo_id = alloc_id()\n    nodes.append(\n        {\n            \"node_id\": repo_id,\n            \"level\": 2,\n            \"type\": \"repo\",\n            \"parent_id\": repo_parent,\n            \"name\": repo_name,\n            \"attributes\": {\"root\": str(repo_root)},\n        }\n    )\n    edges.append({\"parent_id\": repo_parent, \"child_id\": repo_id})\n\n    # Level 3: top-level directories / subtrees\n    subdir_to_id: Dict[str, int] = {}\n    for _, e in file_ents:\n        rel = str(getattr(e, \"attributes\", {}).get(\"rel_path\", \"\"))\n        top = rel.split(\"/\", 1)[0] if \"/\" in rel else \"\"\n        key = top or \"(root)\"\n        if key in subdir_to_id:\n            continue\n        nid = alloc_id()\n        subdir_to_id[key] = nid\n        nodes.append(\n            {\n                \"node_id\": nid,\n                \"level\": 3,\n                \"type\": \"subdir\",\n                \"parent_id\": repo_id,\n                \"name\": key,\n                \"attributes\": {},\n            }\n        )\n        edges.append({\"parent_id\": repo_id, \"child_id\": nid})\n\n    # Level 4: files\n    fileid_to_nodeid: Dict[str, int] = {}\n    for eid, e in file_ents:\n        rel = str(getattr(e, \"attributes\", {}).get(\"rel_path\", \"\"))\n        top = rel.split(\"/\", 1)[0] if \"/\" in rel else \"\"\n        key = top or \"(root)\"\n        parent_id = subdir_to_id[key]\n        nid = alloc_id()\n        fileid_to_nodeid[eid] = nid\n        nodes.append(\n            {\n                \"node_id\": nid,\n                \"level\": 4,\n                \"type\": \"file\",\n                \"parent_id\": parent_id,\n                \"name\": rel,\n                \"attributes\": {\"artifact_uri\": getattr(e, \"artifact_uri\", None)},\n            }\n        )\n        edges.append({\"parent_id\": parent_id, \"child_id\": nid})\n\n    # Level 5: symbols (functions / methods / classes).\n    for _, e in symbol_ents:\n        art_uri = getattr(e, \"artifact_uri\", None)\n        if not art_uri:\n            continue\n        # Find the file entity that owns this symbol via artifact_uri match.\n        parent_node_id: Optional[int] = None\n        for fe_id, fe in file_ents:\n            if getattr(fe, \"artifact_uri\", None) == art_uri:\n                parent_node_id = fileid_to_nodeid.get(fe_id)\n                break\n        if parent_node_id is None:\n            continue\n        nid = alloc_id()\n        nodes.append(\n            {\n                \"node_id\": nid,\n                \"level\": 5,\n                \"type\": getattr(e, \"kind\", \"symbol\"),\n                \"parent_id\": parent_node_id,\n                \"name\": str(getattr(e, \"attributes\", {}).get(\"name\", \"\")),\n                \"attributes\": {\n                    \"artifact_uri\": art_uri,\n                    \"span\": {\n                        \"start_line\": getattr(getattr(e, \"span\", None), \"start_line\", None),  # type: ignore[attr-defined]  # noqa: E501\n                        \"end_line\": getattr(getattr(e, \"span\", None), \"end_line\", None),  # type: ignore[attr-defined]  # noqa: E501\n                    },\n                },\n            }\n        )\n        edges.append({\"parent_id\": parent_node_id, \"child_id\": nid})\n\n    # Spans: one per file, rooted at file nodes.\n    for eid, e in file_ents:\n        rel = str(getattr(e, \"attributes\", {}).get(\"rel_path\", \"\"))\n        abs_path = repo_root / rel\n        try:\n            text = abs_path.read_text(encoding=\"utf-8\")\n        except Exception:\n            continue\n        file_node_id = fileid_to_nodeid[eid]\n        # Node path: root → language (primary) → repo → subdir → file.\n        lang_id = repo_parent if repo_parent != root_id else None\n        top = rel.split(\"/\", 1)[0] if \"/\" in rel else \"\"\n        key = top or \"(root)\"\n        subdir_id = subdir_to_id[key]\n        path: List[int] = [root_id]\n        if lang_id is not None:\n            path.append(lang_id)\n        path.extend([repo_id, subdir_id, file_node_id])\n        spans.append(\n            {\n                \"span_id\": rel,\n                \"text\": text,\n                \"source_id\": rel,\n                \"node_path\": path,\n                \"meta\": {},\n            }\n        )\n\n    return nodes, edges, spans\n\n\ndef main() -> None:\n    ap = argparse.ArgumentParser()\n    ap.add_argument(\"repo_root\", type=str, help=\"Path to a single repository root\")\n    ap.add_argument(\"--nodes-out\", type=str, required=True, help=\"Output nodes.jsonl\")\n    ap.add_argument(\"--edges-out\", type=str, required=True, help=\"Output edges.jsonl\")\n    ap.add_argument(\n        \"--spans-out\",\n        type=str,\n        default=None,\n        help=\"Optional spans.jsonl output (one span per file)\",\n    )\n    args = ap.parse_args()\n\n    repo_root = Path(args.repo_root)\n    nodes, edges, spans = build_tree_for_repo(repo_root)\n\n    nodes_path = Path(args.nodes_out)\n    edges_path = Path(args.edges_out)","source_hash":"b673708c0bd5ff3dd51161d80a8765539b0df20bd24126c18bc79efc8f1e18a8","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.build_repo_tree_of_life.main","uri":"program://TOLBERT/function/scripts.build_repo_tree_of_life.main#L246-L280","kind":"function","name":"main","path":"scripts/build_repo_tree_of_life.py","language":"python","start_line":246,"end_line":280,"context_start_line":226,"context_end_line":286,"code":"        top = rel.split(\"/\", 1)[0] if \"/\" in rel else \"\"\n        key = top or \"(root)\"\n        subdir_id = subdir_to_id[key]\n        path: List[int] = [root_id]\n        if lang_id is not None:\n            path.append(lang_id)\n        path.extend([repo_id, subdir_id, file_node_id])\n        spans.append(\n            {\n                \"span_id\": rel,\n                \"text\": text,\n                \"source_id\": rel,\n                \"node_path\": path,\n                \"meta\": {},\n            }\n        )\n\n    return nodes, edges, spans\n\n\ndef main() -> None:\n    ap = argparse.ArgumentParser()\n    ap.add_argument(\"repo_root\", type=str, help=\"Path to a single repository root\")\n    ap.add_argument(\"--nodes-out\", type=str, required=True, help=\"Output nodes.jsonl\")\n    ap.add_argument(\"--edges-out\", type=str, required=True, help=\"Output edges.jsonl\")\n    ap.add_argument(\n        \"--spans-out\",\n        type=str,\n        default=None,\n        help=\"Optional spans.jsonl output (one span per file)\",\n    )\n    args = ap.parse_args()\n\n    repo_root = Path(args.repo_root)\n    nodes, edges, spans = build_tree_for_repo(repo_root)\n\n    nodes_path = Path(args.nodes_out)\n    edges_path = Path(args.edges_out)\n    nodes_path.parent.mkdir(parents=True, exist_ok=True)\n    edges_path.parent.mkdir(parents=True, exist_ok=True)\n\n    with nodes_path.open(\"w\", encoding=\"utf-8\") as f:\n        for row in nodes:\n            f.write(json.dumps(row) + \"\\n\")\n\n    with edges_path.open(\"w\", encoding=\"utf-8\") as f:\n        for row in edges:\n            f.write(json.dumps(row) + \"\\n\")\n\n    if args.spans_out is not None:\n        spans_path = Path(args.spans_out)\n        spans_path.parent.mkdir(parents=True, exist_ok=True)\n        with spans_path.open(\"w\", encoding=\"utf-8\") as f:\n            for row in spans:\n                f.write(json.dumps(row) + \"\\n\")\n\n\nif __name__ == \"__main__\":\n    main()\n\n","source_hash":"b673708c0bd5ff3dd51161d80a8765539b0df20bd24126c18bc79efc8f1e18a8","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.build_repo_tree_of_life.alloc_id","uri":"program://TOLBERT/function/scripts.build_repo_tree_of_life.alloc_id#L58-L62","kind":"function","name":"alloc_id","path":"scripts/build_repo_tree_of_life.py","language":"python","start_line":58,"end_line":62,"context_start_line":38,"context_end_line":82,"code":"\ndef _primary_language_for_file_entity(labels: List[str]) -> Optional[str]:\n    for lab in labels:\n        if lab.startswith(\"lang:\"):\n            return lab.split(\":\", 1)[1]\n    return None\n\n\ndef build_tree_for_repo(\n    repo_root: Path,\n) -> Tuple[List[Dict[str, object]], List[Dict[str, object]], List[Dict[str, object]]]:\n    \"\"\"\n    Return (nodes, edges, spans) lists.\n    \"\"\"\n    g = RepoGraph(str(repo_root))\n    ents = list(g.entities())\n\n    # Node id assignment\n    next_id = 0\n\n    def alloc_id() -> int:\n        nonlocal next_id\n        nid = next_id\n        next_id += 1\n        return nid\n\n    nodes: List[Dict[str, object]] = []\n    edges: List[Dict[str, object]] = []\n    spans: List[Dict[str, object]] = []\n\n    # Level 0: root\n    root_id = alloc_id()\n    nodes.append(\n        {\n            \"node_id\": root_id,\n            \"level\": 0,\n            \"type\": \"root\",\n            \"parent_id\": None,\n            \"name\": \"Root\",\n            \"attributes\": {},\n        }\n    )\n\n    # Language nodes (level 1)\n    lang_to_id: Dict[str, int] = {}","source_hash":"b673708c0bd5ff3dd51161d80a8765539b0df20bd24126c18bc79efc8f1e18a8","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.build_codehierarchy_spans","uri":"program://TOLBERT/module/scripts.build_codehierarchy_spans#L1-L380","kind":"module","name":"scripts.build_codehierarchy_spans","path":"scripts/build_codehierarchy_spans.py","language":"python","start_line":1,"end_line":380,"context_start_line":1,"context_end_line":380,"code":"\"\"\"\nBuild CodeHierarchy-style JSONL spans and simple ontology metadata.\n\nThis is a *reference* implementation of the dataset construction described\nin the TOLBERT paper for the CodeHierarchy benchmark. It does not fetch or\nship any GitHub data; instead, it expects you to point it at a directory of\nlocal repositories plus a small metadata file that assigns each repo to a\nlanguage and coarse category.\n\nInput:\n  - --repos_root:\n      Directory that contains one subdirectory per repository, e.g.\n        repos_root/\n          repo1/\n            ...\n          repo2/\n            ...\n  - --metadata_file:\n      A CSV or JSONL file with, at minimum, the fields:\n        repo_name, language, category\n      where:\n        - repo_name matches the subdirectory name under repos_root\n        - language is a string label (e.g. \"Python\", \"Java\", \"C++\")\n        - category is a coarse repo category (e.g. \"Web\", \"ML\", \"Systems\")\n\nOutputs:\n  - --spans_out:\n      JSONL file with one record per *file* (not per function) of the form:\n        {\n          \"span_id\": \"repo/file.py\",\n          \"text\": \"... full file contents ...\",\n          \"source_id\": \"repo/file.py\",\n          \"node_path\": [root_id, lang_id, cat_id, repo_id],\n          \"meta\": { ... optional extra metadata ... }\n        }\n\n  - --nodes_out (optional):\n      JSONL file describing ontology nodes with fields:\n        node_id, level, type, parent_id, name\n\n  - --level_sizes_out (optional):\n      Small JSON file with:\n        {\"level_sizes\": [num_level0, num_level1, num_level2, num_level3]}\n      which you can copy into your training config as `level_sizes`.\n\nThis script is intentionally lightweight. It is meant to make the paper's\nCodeHierarchy setup reproducible given local mirrors of the repositories and\na small metadata file, without hard-coding any GitHub-specific details.\n\"\"\"\n\nfrom __future__ import annotations\n\nimport argparse\nimport csv\nimport json\nimport os\nfrom dataclasses import dataclass\nfrom pathlib import Path\nfrom typing import Dict, List, Optional, Tuple\n\n\n@dataclass\nclass RepoMeta:\n    repo_name: str\n    language: str\n    category: str\n\n\ndef load_metadata(path: Path) -> List[RepoMeta]:\n    metas: List[RepoMeta] = []\n    if path.suffix.lower() in {\".jsonl\", \".json\"}:\n        with path.open(\"r\", encoding=\"utf-8\") as f:\n            for line in f:\n                line = line.strip()\n                if not line:\n                    continue\n                obj = json.loads(line)\n                metas.append(\n                    RepoMeta(\n                        repo_name=obj[\"repo_name\"],\n                        language=obj[\"language\"],\n                        category=obj[\"category\"],\n                    )\n                )\n        return metas\n\n    # Default: CSV with header\n    with path.open(\"r\", encoding=\"utf-8\") as f:\n        reader = csv.DictReader(f)\n        for row in reader:\n            metas.append(\n                RepoMeta(\n                    repo_name=row[\"repo_name\"],\n                    language=row[\"language\"],\n                    category=row[\"category\"],\n                )\n            )\n    return metas\n\n\ndef build_ontology(metas: List[RepoMeta]) -> Tuple[Dict[str, int], Dict[str, int], Dict[str, int]]:\n    \"\"\"\n    Build simple integer ID mappings:\n      - language -> lang_node_id\n      - (language, category) -> cat_node_id\n      - repo_name -> repo_node_id\n\n    Level conventions:\n      level 0: root (id 0)\n      level 1: language nodes\n      level 2: category nodes (per language)\n      level 3: repo nodes\n    \"\"\"\n    next_id = 0\n    # Root\n    root_id = next_id\n    next_id += 1\n\n    lang_ids: Dict[str, int] = {}\n    cat_ids: Dict[str, int] = {}\n    repo_ids: Dict[str, int] = {}\n\n    for m in metas:\n        if m.language not in lang_ids:\n            lang_ids[m.language] = next_id\n            next_id += 1\n        cat_key = f\"{m.language}::{m.category}\"\n        if cat_key not in cat_ids:\n            cat_ids[cat_key] = next_id\n            next_id += 1\n        if m.repo_name not in repo_ids:\n            repo_ids[m.repo_name] = next_id\n            next_id += 1\n\n    return lang_ids, cat_ids, repo_ids\n\n\ndef write_nodes_jsonl(\n    out_path: Path,\n    lang_ids: Dict[str, int],\n    cat_ids: Dict[str, int],\n    repo_ids: Dict[str, int],\n) -> None:\n    \"\"\"\n    Emit a minimal nodes.jsonl compatible with docs/tree_of_life.md.\n    \"\"\"\n    with out_path.open(\"w\", encoding=\"utf-8\") as f:\n        # Root\n        f.write(\n            json.dumps(\n                {\n                    \"node_id\": 0,\n                    \"level\": 0,\n                    \"type\": \"root\",\n                    \"parent_id\": None,\n                    \"name\": \"Root\",\n                    \"attributes\": {},\n                }\n            )\n            + \"\\n\"\n        )\n\n        # Languages (level 1)\n        for lang, nid in lang_ids.items():\n            f.write(\n                json.dumps(\n                    {\n                        \"node_id\": nid,\n                        \"level\": 1,\n                        \"type\": \"language\",\n                        \"parent_id\": 0,\n                        \"name\": lang,\n                        \"attributes\": {},\n                    }\n                )\n                + \"\\n\"\n            )\n\n        # Categories (level 2)\n        for key, nid in cat_ids.items():\n            lang, cat = key.split(\"::\", 1)\n            parent_id = lang_ids[lang]\n            f.write(\n                json.dumps(\n                    {\n                        \"node_id\": nid,\n                        \"level\": 2,\n                        \"type\": \"category\",\n                        \"parent_id\": parent_id,\n                        \"name\": cat,\n                        \"attributes\": {\"language\": lang},\n                    }\n                )\n                + \"\\n\"\n            )\n\n        # Repos (level 3)\n        for repo, nid in repo_ids.items():\n            # We do not encode parent here; it can be inferred from metadata if needed.\n            f.write(\n                json.dumps(\n                    {\n                        \"node_id\": nid,\n                        \"level\": 3,\n                        \"type\": \"repo\",\n                        \"parent_id\": None,\n                        \"name\": repo,\n                        \"attributes\": {},\n                    }\n                )\n                + \"\\n\"\n            )\n\n\ndef build_span_records(\n    repos_root: Path,\n    metas: List[RepoMeta],\n    lang_ids: Dict[str, int],\n    cat_ids: Dict[str, int],\n    repo_ids: Dict[str, int],\n) -> List[Dict[str, object]]:\n    \"\"\"\n    Iterate over repositories and files, generating one span per file.\n    \"\"\"\n    root_id = 0\n    spans: List[Dict[str, object]] = []\n\n    meta_by_repo: Dict[str, RepoMeta] = {m.repo_name: m for m in metas}\n\n    for repo_name, repo_id in repo_ids.items():\n        repo_dir = repos_root / repo_name\n        if not repo_dir.is_dir():\n            continue\n\n        m = meta_by_repo.get(repo_name)\n        if m is None:\n            continue\n\n        lang_id = lang_ids[m.language]\n        cat_key = f\"{m.language}::{m.category}\"\n        cat_id = cat_ids[cat_key]\n\n        for dirpath, _, filenames in os.walk(repo_dir):\n            for fname in filenames:\n                # Basic filter: only include source-like files\n                if not fname.endswith((\".py\", \".java\", \".cpp\", \".cc\", \".cxx\", \".h\", \".hpp\")):\n                    continue\n                fpath = Path(dirpath) / fname\n                try:\n                    text = fpath.read_text(encoding=\"utf-8\")\n                except (UnicodeDecodeError, OSError):\n                    continue\n\n                rel_path = fpath.relative_to(repos_root).as_posix()\n                span_id = rel_path\n                node_path = [root_id, lang_id, cat_id, repo_id]\n\n                spans.append(\n                    {\n                        \"span_id\": span_id,\n                        \"text\": text,\n                        \"source_id\": rel_path,\n                        \"node_path\": node_path,\n                        \"meta\": {\n                            \"repo_name\": repo_name,\n                            \"language\": m.language,\n                            \"category\": m.category,\n                        },\n                    }\n                )\n\n    return spans\n\n\ndef write_spans_jsonl(spans: List[Dict[str, object]], out_path: Path) -> None:\n    with out_path.open(\"w\", encoding=\"utf-8\") as f:\n        for rec in spans:\n            f.write(json.dumps(rec) + \"\\n\")\n\n\ndef write_level_sizes(\n    lang_ids: Dict[str, int],\n    cat_ids: Dict[str, int],\n    repo_ids: Dict[str, int],\n    out_path: Path,\n) -> None:\n    \"\"\"\n    Write a small JSON helper with level_sizes for convenience.\n\n    Note: TOLBERTConfig.level_sizes expects a dict[int, int] mapping\n    level index -> number of nodes at that level (excluding the root\n    level, which typically has no head). For CodeHierarchy we use:\n      level 1: languages\n      level 2: categories\n      level 3: repos\n\n    You can either:\n      - Paste this dict into a YAML config (which preserves int keys), or\n      - Load it manually and convert keys to ints before constructing\n        TOLBERTConfig if you prefer JSON configs.\n    \"\"\"\n    level_sizes = {\n        1: len(lang_ids),\n        2: len(cat_ids),\n        3: len(repo_ids),\n    }\n    out = {\"level_sizes\": level_sizes}\n    with out_path.open(\"w\", encoding=\"utf-8\") as f:\n        json.dump(out, f, indent=2)\n\n\ndef parse_args() -> argparse.Namespace:\n    ap = argparse.ArgumentParser(description=\"Build CodeHierarchy spans JSONL and ontology metadata.\")\n    ap.add_argument(\"--repos_root\", type=str, required=True, help=\"Directory containing local repos.\")\n    ap.add_argument(\n        \"--metadata_file\",\n        type=str,\n        required=True,\n        help=\"CSV or JSONL file with columns: repo_name, language, category.\",\n    )\n    ap.add_argument(\n        \"--spans_out\",\n        type=str,\n        required=True,\n        help=\"Output path for spans JSONL file.\",\n    )\n    ap.add_argument(\n        \"--nodes_out\",\n        type=str,\n        default=\"\",\n        help=\"Optional output path for nodes JSONL (ontology nodes).\",\n    )\n    ap.add_argument(\n        \"--level_sizes_out\",\n        type=str,\n        default=\"\",\n        help=\"Optional output path for level_sizes JSON file.\",\n    )\n    return ap.parse_args()\n\n\ndef main() -> None:\n    args = parse_args()\n\n    repos_root = Path(args.repos_root)\n    if not repos_root.is_dir():\n        raise FileNotFoundError(f\"repos_root does not exist or is not a directory: {repos_root}\")\n\n    meta_path = Path(args.metadata_file)\n    metas = load_metadata(meta_path)\n\n    lang_ids, cat_ids, repo_ids = build_ontology(metas)\n\n    spans = build_span_records(\n        repos_root=repos_root,\n        metas=metas,\n        lang_ids=lang_ids,\n        cat_ids=cat_ids,\n        repo_ids=repo_ids,\n    )\n\n    spans_out = Path(args.spans_out)\n    spans_out.parent.mkdir(parents=True, exist_ok=True)\n    write_spans_jsonl(spans, spans_out)\n\n    if args.nodes_out:\n        nodes_out = Path(args.nodes_out)\n        nodes_out.parent.mkdir(parents=True, exist_ok=True)\n        write_nodes_jsonl(nodes_out, lang_ids, cat_ids, repo_ids)\n\n    if args.level_sizes_out:\n        ls_out = Path(args.level_sizes_out)\n        ls_out.parent.mkdir(parents=True, exist_ok=True)\n        write_level_sizes(lang_ids, cat_ids, repo_ids, ls_out)\n\n\nif __name__ == \"__main__\":\n    main()\n\n","source_hash":"822e0397f322d201e0770f48c87c652ef9c45741ca9b6bea2e680752d11b73dc","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.build_codehierarchy_spans.RepoMeta","uri":"program://TOLBERT/class/scripts.build_codehierarchy_spans.RepoMeta#L63-L66","kind":"class","name":"RepoMeta","path":"scripts/build_codehierarchy_spans.py","language":"python","start_line":63,"end_line":66,"context_start_line":43,"context_end_line":86,"code":"        {\"level_sizes\": [num_level0, num_level1, num_level2, num_level3]}\n      which you can copy into your training config as `level_sizes`.\n\nThis script is intentionally lightweight. It is meant to make the paper's\nCodeHierarchy setup reproducible given local mirrors of the repositories and\na small metadata file, without hard-coding any GitHub-specific details.\n\"\"\"\n\nfrom __future__ import annotations\n\nimport argparse\nimport csv\nimport json\nimport os\nfrom dataclasses import dataclass\nfrom pathlib import Path\nfrom typing import Dict, List, Optional, Tuple\n\n\n@dataclass\nclass RepoMeta:\n    repo_name: str\n    language: str\n    category: str\n\n\ndef load_metadata(path: Path) -> List[RepoMeta]:\n    metas: List[RepoMeta] = []\n    if path.suffix.lower() in {\".jsonl\", \".json\"}:\n        with path.open(\"r\", encoding=\"utf-8\") as f:\n            for line in f:\n                line = line.strip()\n                if not line:\n                    continue\n                obj = json.loads(line)\n                metas.append(\n                    RepoMeta(\n                        repo_name=obj[\"repo_name\"],\n                        language=obj[\"language\"],\n                        category=obj[\"category\"],\n                    )\n                )\n        return metas\n","source_hash":"822e0397f322d201e0770f48c87c652ef9c45741ca9b6bea2e680752d11b73dc","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.build_codehierarchy_spans.load_metadata","uri":"program://TOLBERT/function/scripts.build_codehierarchy_spans.load_metadata#L69-L98","kind":"function","name":"load_metadata","path":"scripts/build_codehierarchy_spans.py","language":"python","start_line":69,"end_line":98,"context_start_line":49,"context_end_line":118,"code":"\"\"\"\n\nfrom __future__ import annotations\n\nimport argparse\nimport csv\nimport json\nimport os\nfrom dataclasses import dataclass\nfrom pathlib import Path\nfrom typing import Dict, List, Optional, Tuple\n\n\n@dataclass\nclass RepoMeta:\n    repo_name: str\n    language: str\n    category: str\n\n\ndef load_metadata(path: Path) -> List[RepoMeta]:\n    metas: List[RepoMeta] = []\n    if path.suffix.lower() in {\".jsonl\", \".json\"}:\n        with path.open(\"r\", encoding=\"utf-8\") as f:\n            for line in f:\n                line = line.strip()\n                if not line:\n                    continue\n                obj = json.loads(line)\n                metas.append(\n                    RepoMeta(\n                        repo_name=obj[\"repo_name\"],\n                        language=obj[\"language\"],\n                        category=obj[\"category\"],\n                    )\n                )\n        return metas\n\n    # Default: CSV with header\n    with path.open(\"r\", encoding=\"utf-8\") as f:\n        reader = csv.DictReader(f)\n        for row in reader:\n            metas.append(\n                RepoMeta(\n                    repo_name=row[\"repo_name\"],\n                    language=row[\"language\"],\n                    category=row[\"category\"],\n                )\n            )\n    return metas\n\n\ndef build_ontology(metas: List[RepoMeta]) -> Tuple[Dict[str, int], Dict[str, int], Dict[str, int]]:\n    \"\"\"\n    Build simple integer ID mappings:\n      - language -> lang_node_id\n      - (language, category) -> cat_node_id\n      - repo_name -> repo_node_id\n\n    Level conventions:\n      level 0: root (id 0)\n      level 1: language nodes\n      level 2: category nodes (per language)\n      level 3: repo nodes\n    \"\"\"\n    next_id = 0\n    # Root\n    root_id = next_id\n    next_id += 1\n","source_hash":"822e0397f322d201e0770f48c87c652ef9c45741ca9b6bea2e680752d11b73dc","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.build_codehierarchy_spans.build_ontology","uri":"program://TOLBERT/function/scripts.build_codehierarchy_spans.build_ontology#L101-L135","kind":"function","name":"build_ontology","path":"scripts/build_codehierarchy_spans.py","language":"python","start_line":101,"end_line":135,"context_start_line":81,"context_end_line":155,"code":"                        language=obj[\"language\"],\n                        category=obj[\"category\"],\n                    )\n                )\n        return metas\n\n    # Default: CSV with header\n    with path.open(\"r\", encoding=\"utf-8\") as f:\n        reader = csv.DictReader(f)\n        for row in reader:\n            metas.append(\n                RepoMeta(\n                    repo_name=row[\"repo_name\"],\n                    language=row[\"language\"],\n                    category=row[\"category\"],\n                )\n            )\n    return metas\n\n\ndef build_ontology(metas: List[RepoMeta]) -> Tuple[Dict[str, int], Dict[str, int], Dict[str, int]]:\n    \"\"\"\n    Build simple integer ID mappings:\n      - language -> lang_node_id\n      - (language, category) -> cat_node_id\n      - repo_name -> repo_node_id\n\n    Level conventions:\n      level 0: root (id 0)\n      level 1: language nodes\n      level 2: category nodes (per language)\n      level 3: repo nodes\n    \"\"\"\n    next_id = 0\n    # Root\n    root_id = next_id\n    next_id += 1\n\n    lang_ids: Dict[str, int] = {}\n    cat_ids: Dict[str, int] = {}\n    repo_ids: Dict[str, int] = {}\n\n    for m in metas:\n        if m.language not in lang_ids:\n            lang_ids[m.language] = next_id\n            next_id += 1\n        cat_key = f\"{m.language}::{m.category}\"\n        if cat_key not in cat_ids:\n            cat_ids[cat_key] = next_id\n            next_id += 1\n        if m.repo_name not in repo_ids:\n            repo_ids[m.repo_name] = next_id\n            next_id += 1\n\n    return lang_ids, cat_ids, repo_ids\n\n\ndef write_nodes_jsonl(\n    out_path: Path,\n    lang_ids: Dict[str, int],\n    cat_ids: Dict[str, int],\n    repo_ids: Dict[str, int],\n) -> None:\n    \"\"\"\n    Emit a minimal nodes.jsonl compatible with docs/tree_of_life.md.\n    \"\"\"\n    with out_path.open(\"w\", encoding=\"utf-8\") as f:\n        # Root\n        f.write(\n            json.dumps(\n                {\n                    \"node_id\": 0,\n                    \"level\": 0,\n                    \"type\": \"root\",\n                    \"parent_id\": None,","source_hash":"822e0397f322d201e0770f48c87c652ef9c45741ca9b6bea2e680752d11b73dc","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.build_codehierarchy_spans.write_nodes_jsonl","uri":"program://TOLBERT/function/scripts.build_codehierarchy_spans.write_nodes_jsonl#L138-L212","kind":"function","name":"write_nodes_jsonl","path":"scripts/build_codehierarchy_spans.py","language":"python","start_line":138,"end_line":212,"context_start_line":118,"context_end_line":232,"code":"\n    lang_ids: Dict[str, int] = {}\n    cat_ids: Dict[str, int] = {}\n    repo_ids: Dict[str, int] = {}\n\n    for m in metas:\n        if m.language not in lang_ids:\n            lang_ids[m.language] = next_id\n            next_id += 1\n        cat_key = f\"{m.language}::{m.category}\"\n        if cat_key not in cat_ids:\n            cat_ids[cat_key] = next_id\n            next_id += 1\n        if m.repo_name not in repo_ids:\n            repo_ids[m.repo_name] = next_id\n            next_id += 1\n\n    return lang_ids, cat_ids, repo_ids\n\n\ndef write_nodes_jsonl(\n    out_path: Path,\n    lang_ids: Dict[str, int],\n    cat_ids: Dict[str, int],\n    repo_ids: Dict[str, int],\n) -> None:\n    \"\"\"\n    Emit a minimal nodes.jsonl compatible with docs/tree_of_life.md.\n    \"\"\"\n    with out_path.open(\"w\", encoding=\"utf-8\") as f:\n        # Root\n        f.write(\n            json.dumps(\n                {\n                    \"node_id\": 0,\n                    \"level\": 0,\n                    \"type\": \"root\",\n                    \"parent_id\": None,\n                    \"name\": \"Root\",\n                    \"attributes\": {},\n                }\n            )\n            + \"\\n\"\n        )\n\n        # Languages (level 1)\n        for lang, nid in lang_ids.items():\n            f.write(\n                json.dumps(\n                    {\n                        \"node_id\": nid,\n                        \"level\": 1,\n                        \"type\": \"language\",\n                        \"parent_id\": 0,\n                        \"name\": lang,\n                        \"attributes\": {},\n                    }\n                )\n                + \"\\n\"\n            )\n\n        # Categories (level 2)\n        for key, nid in cat_ids.items():\n            lang, cat = key.split(\"::\", 1)\n            parent_id = lang_ids[lang]\n            f.write(\n                json.dumps(\n                    {\n                        \"node_id\": nid,\n                        \"level\": 2,\n                        \"type\": \"category\",\n                        \"parent_id\": parent_id,\n                        \"name\": cat,\n                        \"attributes\": {\"language\": lang},\n                    }\n                )\n                + \"\\n\"\n            )\n\n        # Repos (level 3)\n        for repo, nid in repo_ids.items():\n            # We do not encode parent here; it can be inferred from metadata if needed.\n            f.write(\n                json.dumps(\n                    {\n                        \"node_id\": nid,\n                        \"level\": 3,\n                        \"type\": \"repo\",\n                        \"parent_id\": None,\n                        \"name\": repo,\n                        \"attributes\": {},\n                    }\n                )\n                + \"\\n\"\n            )\n\n\ndef build_span_records(\n    repos_root: Path,\n    metas: List[RepoMeta],\n    lang_ids: Dict[str, int],\n    cat_ids: Dict[str, int],\n    repo_ids: Dict[str, int],\n) -> List[Dict[str, object]]:\n    \"\"\"\n    Iterate over repositories and files, generating one span per file.\n    \"\"\"\n    root_id = 0\n    spans: List[Dict[str, object]] = []\n\n    meta_by_repo: Dict[str, RepoMeta] = {m.repo_name: m for m in metas}\n\n    for repo_name, repo_id in repo_ids.items():\n        repo_dir = repos_root / repo_name\n        if not repo_dir.is_dir():","source_hash":"822e0397f322d201e0770f48c87c652ef9c45741ca9b6bea2e680752d11b73dc","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.build_codehierarchy_spans.build_span_records","uri":"program://TOLBERT/function/scripts.build_codehierarchy_spans.build_span_records#L215-L272","kind":"function","name":"build_span_records","path":"scripts/build_codehierarchy_spans.py","language":"python","start_line":215,"end_line":272,"context_start_line":195,"context_end_line":292,"code":"            )\n\n        # Repos (level 3)\n        for repo, nid in repo_ids.items():\n            # We do not encode parent here; it can be inferred from metadata if needed.\n            f.write(\n                json.dumps(\n                    {\n                        \"node_id\": nid,\n                        \"level\": 3,\n                        \"type\": \"repo\",\n                        \"parent_id\": None,\n                        \"name\": repo,\n                        \"attributes\": {},\n                    }\n                )\n                + \"\\n\"\n            )\n\n\ndef build_span_records(\n    repos_root: Path,\n    metas: List[RepoMeta],\n    lang_ids: Dict[str, int],\n    cat_ids: Dict[str, int],\n    repo_ids: Dict[str, int],\n) -> List[Dict[str, object]]:\n    \"\"\"\n    Iterate over repositories and files, generating one span per file.\n    \"\"\"\n    root_id = 0\n    spans: List[Dict[str, object]] = []\n\n    meta_by_repo: Dict[str, RepoMeta] = {m.repo_name: m for m in metas}\n\n    for repo_name, repo_id in repo_ids.items():\n        repo_dir = repos_root / repo_name\n        if not repo_dir.is_dir():\n            continue\n\n        m = meta_by_repo.get(repo_name)\n        if m is None:\n            continue\n\n        lang_id = lang_ids[m.language]\n        cat_key = f\"{m.language}::{m.category}\"\n        cat_id = cat_ids[cat_key]\n\n        for dirpath, _, filenames in os.walk(repo_dir):\n            for fname in filenames:\n                # Basic filter: only include source-like files\n                if not fname.endswith((\".py\", \".java\", \".cpp\", \".cc\", \".cxx\", \".h\", \".hpp\")):\n                    continue\n                fpath = Path(dirpath) / fname\n                try:\n                    text = fpath.read_text(encoding=\"utf-8\")\n                except (UnicodeDecodeError, OSError):\n                    continue\n\n                rel_path = fpath.relative_to(repos_root).as_posix()\n                span_id = rel_path\n                node_path = [root_id, lang_id, cat_id, repo_id]\n\n                spans.append(\n                    {\n                        \"span_id\": span_id,\n                        \"text\": text,\n                        \"source_id\": rel_path,\n                        \"node_path\": node_path,\n                        \"meta\": {\n                            \"repo_name\": repo_name,\n                            \"language\": m.language,\n                            \"category\": m.category,\n                        },\n                    }\n                )\n\n    return spans\n\n\ndef write_spans_jsonl(spans: List[Dict[str, object]], out_path: Path) -> None:\n    with out_path.open(\"w\", encoding=\"utf-8\") as f:\n        for rec in spans:\n            f.write(json.dumps(rec) + \"\\n\")\n\n\ndef write_level_sizes(\n    lang_ids: Dict[str, int],\n    cat_ids: Dict[str, int],\n    repo_ids: Dict[str, int],\n    out_path: Path,\n) -> None:\n    \"\"\"\n    Write a small JSON helper with level_sizes for convenience.\n\n    Note: TOLBERTConfig.level_sizes expects a dict[int, int] mapping\n    level index -> number of nodes at that level (excluding the root\n    level, which typically has no head). For CodeHierarchy we use:","source_hash":"822e0397f322d201e0770f48c87c652ef9c45741ca9b6bea2e680752d11b73dc","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.build_codehierarchy_spans.write_spans_jsonl","uri":"program://TOLBERT/function/scripts.build_codehierarchy_spans.write_spans_jsonl#L275-L278","kind":"function","name":"write_spans_jsonl","path":"scripts/build_codehierarchy_spans.py","language":"python","start_line":275,"end_line":278,"context_start_line":255,"context_end_line":298,"code":"                span_id = rel_path\n                node_path = [root_id, lang_id, cat_id, repo_id]\n\n                spans.append(\n                    {\n                        \"span_id\": span_id,\n                        \"text\": text,\n                        \"source_id\": rel_path,\n                        \"node_path\": node_path,\n                        \"meta\": {\n                            \"repo_name\": repo_name,\n                            \"language\": m.language,\n                            \"category\": m.category,\n                        },\n                    }\n                )\n\n    return spans\n\n\ndef write_spans_jsonl(spans: List[Dict[str, object]], out_path: Path) -> None:\n    with out_path.open(\"w\", encoding=\"utf-8\") as f:\n        for rec in spans:\n            f.write(json.dumps(rec) + \"\\n\")\n\n\ndef write_level_sizes(\n    lang_ids: Dict[str, int],\n    cat_ids: Dict[str, int],\n    repo_ids: Dict[str, int],\n    out_path: Path,\n) -> None:\n    \"\"\"\n    Write a small JSON helper with level_sizes for convenience.\n\n    Note: TOLBERTConfig.level_sizes expects a dict[int, int] mapping\n    level index -> number of nodes at that level (excluding the root\n    level, which typically has no head). For CodeHierarchy we use:\n      level 1: languages\n      level 2: categories\n      level 3: repos\n\n    You can either:\n      - Paste this dict into a YAML config (which preserves int keys), or","source_hash":"822e0397f322d201e0770f48c87c652ef9c45741ca9b6bea2e680752d11b73dc","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.build_codehierarchy_spans.write_level_sizes","uri":"program://TOLBERT/function/scripts.build_codehierarchy_spans.write_level_sizes#L281-L309","kind":"function","name":"write_level_sizes","path":"scripts/build_codehierarchy_spans.py","language":"python","start_line":281,"end_line":309,"context_start_line":261,"context_end_line":329,"code":"                        \"text\": text,\n                        \"source_id\": rel_path,\n                        \"node_path\": node_path,\n                        \"meta\": {\n                            \"repo_name\": repo_name,\n                            \"language\": m.language,\n                            \"category\": m.category,\n                        },\n                    }\n                )\n\n    return spans\n\n\ndef write_spans_jsonl(spans: List[Dict[str, object]], out_path: Path) -> None:\n    with out_path.open(\"w\", encoding=\"utf-8\") as f:\n        for rec in spans:\n            f.write(json.dumps(rec) + \"\\n\")\n\n\ndef write_level_sizes(\n    lang_ids: Dict[str, int],\n    cat_ids: Dict[str, int],\n    repo_ids: Dict[str, int],\n    out_path: Path,\n) -> None:\n    \"\"\"\n    Write a small JSON helper with level_sizes for convenience.\n\n    Note: TOLBERTConfig.level_sizes expects a dict[int, int] mapping\n    level index -> number of nodes at that level (excluding the root\n    level, which typically has no head). For CodeHierarchy we use:\n      level 1: languages\n      level 2: categories\n      level 3: repos\n\n    You can either:\n      - Paste this dict into a YAML config (which preserves int keys), or\n      - Load it manually and convert keys to ints before constructing\n        TOLBERTConfig if you prefer JSON configs.\n    \"\"\"\n    level_sizes = {\n        1: len(lang_ids),\n        2: len(cat_ids),\n        3: len(repo_ids),\n    }\n    out = {\"level_sizes\": level_sizes}\n    with out_path.open(\"w\", encoding=\"utf-8\") as f:\n        json.dump(out, f, indent=2)\n\n\ndef parse_args() -> argparse.Namespace:\n    ap = argparse.ArgumentParser(description=\"Build CodeHierarchy spans JSONL and ontology metadata.\")\n    ap.add_argument(\"--repos_root\", type=str, required=True, help=\"Directory containing local repos.\")\n    ap.add_argument(\n        \"--metadata_file\",\n        type=str,\n        required=True,\n        help=\"CSV or JSONL file with columns: repo_name, language, category.\",\n    )\n    ap.add_argument(\n        \"--spans_out\",\n        type=str,\n        required=True,\n        help=\"Output path for spans JSONL file.\",\n    )\n    ap.add_argument(\n        \"--nodes_out\",\n        type=str,","source_hash":"822e0397f322d201e0770f48c87c652ef9c45741ca9b6bea2e680752d11b73dc","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.build_codehierarchy_spans.parse_args","uri":"program://TOLBERT/function/scripts.build_codehierarchy_spans.parse_args#L312-L339","kind":"function","name":"parse_args","path":"scripts/build_codehierarchy_spans.py","language":"python","start_line":312,"end_line":339,"context_start_line":292,"context_end_line":359,"code":"    level, which typically has no head). For CodeHierarchy we use:\n      level 1: languages\n      level 2: categories\n      level 3: repos\n\n    You can either:\n      - Paste this dict into a YAML config (which preserves int keys), or\n      - Load it manually and convert keys to ints before constructing\n        TOLBERTConfig if you prefer JSON configs.\n    \"\"\"\n    level_sizes = {\n        1: len(lang_ids),\n        2: len(cat_ids),\n        3: len(repo_ids),\n    }\n    out = {\"level_sizes\": level_sizes}\n    with out_path.open(\"w\", encoding=\"utf-8\") as f:\n        json.dump(out, f, indent=2)\n\n\ndef parse_args() -> argparse.Namespace:\n    ap = argparse.ArgumentParser(description=\"Build CodeHierarchy spans JSONL and ontology metadata.\")\n    ap.add_argument(\"--repos_root\", type=str, required=True, help=\"Directory containing local repos.\")\n    ap.add_argument(\n        \"--metadata_file\",\n        type=str,\n        required=True,\n        help=\"CSV or JSONL file with columns: repo_name, language, category.\",\n    )\n    ap.add_argument(\n        \"--spans_out\",\n        type=str,\n        required=True,\n        help=\"Output path for spans JSONL file.\",\n    )\n    ap.add_argument(\n        \"--nodes_out\",\n        type=str,\n        default=\"\",\n        help=\"Optional output path for nodes JSONL (ontology nodes).\",\n    )\n    ap.add_argument(\n        \"--level_sizes_out\",\n        type=str,\n        default=\"\",\n        help=\"Optional output path for level_sizes JSON file.\",\n    )\n    return ap.parse_args()\n\n\ndef main() -> None:\n    args = parse_args()\n\n    repos_root = Path(args.repos_root)\n    if not repos_root.is_dir():\n        raise FileNotFoundError(f\"repos_root does not exist or is not a directory: {repos_root}\")\n\n    meta_path = Path(args.metadata_file)\n    metas = load_metadata(meta_path)\n\n    lang_ids, cat_ids, repo_ids = build_ontology(metas)\n\n    spans = build_span_records(\n        repos_root=repos_root,\n        metas=metas,\n        lang_ids=lang_ids,\n        cat_ids=cat_ids,\n        repo_ids=repo_ids,","source_hash":"822e0397f322d201e0770f48c87c652ef9c45741ca9b6bea2e680752d11b73dc","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.build_codehierarchy_spans.main","uri":"program://TOLBERT/function/scripts.build_codehierarchy_spans.main#L342-L374","kind":"function","name":"main","path":"scripts/build_codehierarchy_spans.py","language":"python","start_line":342,"end_line":374,"context_start_line":322,"context_end_line":380,"code":"        \"--spans_out\",\n        type=str,\n        required=True,\n        help=\"Output path for spans JSONL file.\",\n    )\n    ap.add_argument(\n        \"--nodes_out\",\n        type=str,\n        default=\"\",\n        help=\"Optional output path for nodes JSONL (ontology nodes).\",\n    )\n    ap.add_argument(\n        \"--level_sizes_out\",\n        type=str,\n        default=\"\",\n        help=\"Optional output path for level_sizes JSON file.\",\n    )\n    return ap.parse_args()\n\n\ndef main() -> None:\n    args = parse_args()\n\n    repos_root = Path(args.repos_root)\n    if not repos_root.is_dir():\n        raise FileNotFoundError(f\"repos_root does not exist or is not a directory: {repos_root}\")\n\n    meta_path = Path(args.metadata_file)\n    metas = load_metadata(meta_path)\n\n    lang_ids, cat_ids, repo_ids = build_ontology(metas)\n\n    spans = build_span_records(\n        repos_root=repos_root,\n        metas=metas,\n        lang_ids=lang_ids,\n        cat_ids=cat_ids,\n        repo_ids=repo_ids,\n    )\n\n    spans_out = Path(args.spans_out)\n    spans_out.parent.mkdir(parents=True, exist_ok=True)\n    write_spans_jsonl(spans, spans_out)\n\n    if args.nodes_out:\n        nodes_out = Path(args.nodes_out)\n        nodes_out.parent.mkdir(parents=True, exist_ok=True)\n        write_nodes_jsonl(nodes_out, lang_ids, cat_ids, repo_ids)\n\n    if args.level_sizes_out:\n        ls_out = Path(args.level_sizes_out)\n        ls_out.parent.mkdir(parents=True, exist_ok=True)\n        write_level_sizes(lang_ids, cat_ids, repo_ids, ls_out)\n\n\nif __name__ == \"__main__\":\n    main()\n\n","source_hash":"822e0397f322d201e0770f48c87c652ef9c45741ca9b6bea2e680752d11b73dc","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.build_arxiv_cls_spans","uri":"program://TOLBERT/module/scripts.build_arxiv_cls_spans#L1-L412","kind":"module","name":"scripts.build_arxiv_cls_spans","path":"scripts/build_arxiv_cls_spans.py","language":"python","start_line":1,"end_line":412,"context_start_line":1,"context_end_line":412,"code":"\"\"\"\nBuild ArXiv-CLS–style JSONL spans and simple ontology metadata.\n\nThis script is a small helper for the ArXiv-CLS variant described in the\nTOLBERT paper. It mirrors the style of `build_wos_spans.py` / `build_codehierarchy_spans.py`,\nbut targets the 2-level arXiv category hierarchy.\n\nThe ArXiv-CLS setup in the paper uses:\n\n  - Documents: recent arXiv CS papers (e.g., title + abstract text).\n  - Labels: a two-level arXiv category taxonomy, e.g.:\n        domain  = \"cs\"\n        category = \"cs.LG\"\n\nYou are expected to provide a metadata file (CSV or JSONL) with at least:\n\n  - doc_id:   unique paper identifier (e.g., arXiv ID)\n  - domain:   top-level arXiv area (e.g., \"cs\", \"math\")\n  - category: fine-grained arXiv category (e.g., \"cs.LG\", \"cs.CL\")\n  - text:     text span to encode (e.g., title + abstract)\n\nYou can override these column names via CLI flags so you can adapt to\nyour particular preprocessing pipeline.\n\nOutputs\n=======\n\n- --spans-out:\n    JSONL file with one record per paper of the form:\n\n      {\n        \"span_id\": \"arxiv-2101.00001\",\n        \"text\": \"... title + abstract ...\",\n        \"source_id\": \"arxiv-2101.00001\",\n        \"node_path\": [root_id, domain_id, category_id],\n        \"meta\": {\n          \"doc_id\": \"...\",\n          \"domain\": \"...\",\n          \"category\": \"...\"\n        }\n      }\n\n- --nodes-out (optional):\n    JSONL ontology file with fields:\n      node_id, level, type, parent_id, name, attributes\n\n- --level-sizes-out (optional):\n    Small JSON helper:\n\n      {\"level_sizes\": {1: num_domains, 2: num_categories}}\n\n    which you can paste into a config (see `configs/wos_example.yaml` or\n    `configs/codehierarchy_example.yaml` for reference).\n\nThe resulting `spans_out` file is directly consumable by\n`tolbert.data.TreeOfLifeDataset` and the training skeleton in\n`scripts/train_tolbert.py`, as long as your config's `level_sizes`\nmatches the ontology this script builds.\n\"\"\"\n\nfrom __future__ import annotations\n\nimport argparse\nimport csv\nimport json\nfrom dataclasses import dataclass\nfrom pathlib import Path\nfrom typing import Dict, List, Optional, Tuple\n\n\n@dataclass\nclass ArxivRow:\n    doc_id: str\n    domain: str\n    category: str\n    text: str\n\n\ndef _row_to_meta(\n    row: Dict[str, object],\n    *,\n    id_col: str,\n    domain_col: str,\n    category_col: str,\n    text_col: str,\n) -> Optional[ArxivRow]:\n    try:\n        doc_id = str(row[id_col])\n        domain = str(row[domain_col])\n        category = str(row[category_col])\n        text = str(row[text_col])\n    except KeyError as exc:\n        raise KeyError(f\"Missing required column {exc!s} in metadata record: {row}\") from exc\n\n    if not text or not text.strip():\n        # Skip empty-text rows; they are not useful training examples.\n        return None\n\n    return ArxivRow(doc_id=doc_id, domain=domain, category=category, text=text)\n\n\ndef load_arxiv_metadata(\n    path: Path,\n    *,\n    id_col: str,\n    domain_col: str,\n    category_col: str,\n    text_col: str,\n) -> List[ArxivRow]:\n    \"\"\"\n    Load ArXiv-CLS metadata from CSV or JSON(L).\n    \"\"\"\n    rows: List[ArxivRow] = []\n    suffix = path.suffix.lower()\n\n    if suffix in {\".jsonl\", \".json\"}:\n        with path.open(\"r\", encoding=\"utf-8\") as f:\n            for line in f:\n                line = line.strip()\n                if not line:\n                    continue\n                obj = json.loads(line)\n                # Allow records nested under \"data\" for compatibility with some pipelines.\n                if isinstance(obj, dict) and \"data\" in obj and isinstance(obj[\"data\"], dict):\n                    obj = obj[\"data\"]\n                if not isinstance(obj, dict):\n                    continue\n                meta = _row_to_meta(\n                    obj,\n                    id_col=id_col,\n                    domain_col=domain_col,\n                    category_col=category_col,\n                    text_col=text_col,\n                )\n                if meta is not None:\n                    rows.append(meta)\n        return rows\n\n    # Default: CSV with header\n    with path.open(\"r\", encoding=\"utf-8\") as f:\n        reader = csv.DictReader(f)\n        for row in reader:\n            meta = _row_to_meta(\n                row,\n                id_col=id_col,\n                domain_col=domain_col,\n                category_col=category_col,\n                text_col=text_col,\n            )\n            if meta is not None:\n                rows.append(meta)\n    return rows\n\n\ndef build_ontology(rows: List[ArxivRow]) -> Tuple[Dict[str, int], Dict[str, int]]:\n    \"\"\"\n    Build integer node IDs for:\n\n      - level 1:  unique domains (e.g., \"cs\", \"math\")\n      - level 2:  (domain, category) pairs (e.g., \"cs::cs.LG\")\n\n    Level conventions:\n      level 0: root (id 0)\n      level 1: domain nodes\n      level 2: category nodes (per domain)\n    \"\"\"\n    next_id = 0\n    root_id = next_id\n    next_id += 1\n\n    domain_ids: Dict[str, int] = {}\n    category_ids: Dict[str, int] = {}\n\n    for r in rows:\n        if r.domain not in domain_ids:\n            domain_ids[r.domain] = next_id\n            next_id += 1\n\n        cat_key = f\"{r.domain}::{r.category}\"\n        if cat_key not in category_ids:\n            category_ids[cat_key] = next_id\n            next_id += 1\n\n    # root_id is currently unused in the returned dicts but documented for clarity\n    _ = root_id\n    return domain_ids, category_ids\n\n\ndef write_nodes_jsonl(\n    out_path: Path,\n    domain_ids: Dict[str, int],\n    category_ids: Dict[str, int],\n) -> None:\n    \"\"\"\n    Emit a minimal nodes.jsonl compatible with docs/tree_of_life.md.\n    \"\"\"\n    with out_path.open(\"w\", encoding=\"utf-8\") as f:\n        # Root (level 0)\n        f.write(\n            json.dumps(\n                {\n                    \"node_id\": 0,\n                    \"level\": 0,\n                    \"type\": \"root\",\n                    \"parent_id\": None,\n                    \"name\": \"Root\",\n                    \"attributes\": {},\n                }\n            )\n            + \"\\n\"\n        )\n\n        # Domains (level 1)\n        for domain_name, nid in domain_ids.items():\n            f.write(\n                json.dumps(\n                    {\n                        \"node_id\": nid,\n                        \"level\": 1,\n                        \"type\": \"domain\",\n                        \"parent_id\": 0,\n                        \"name\": domain_name,\n                        \"attributes\": {},\n                    }\n                )\n                + \"\\n\"\n            )\n\n        # Categories (level 2)\n        for key, nid in category_ids.items():\n            domain_name, category_name = key.split(\"::\", 1)\n            parent_id = domain_ids[domain_name]\n            f.write(\n                json.dumps(\n                    {\n                        \"node_id\": nid,\n                        \"level\": 2,\n                        \"type\": \"category\",\n                        \"parent_id\": parent_id,\n                        \"name\": category_name,\n                        \"attributes\": {\"domain\": domain_name},\n                    }\n                )\n                + \"\\n\"\n            )\n\n\ndef build_spans(\n    rows: List[ArxivRow],\n    domain_ids: Dict[str, int],\n    category_ids: Dict[str, int],\n) -> List[Dict[str, object]]:\n    \"\"\"\n    Build span records with node_path = [root_id, domain_id, category_id].\n    \"\"\"\n    spans: List[Dict[str, object]] = []\n    root_id = 0\n\n    for r in rows:\n        domain_id = domain_ids[r.domain]\n        cat_key = f\"{r.domain}::{r.category}\"\n        category_id = category_ids[cat_key]\n\n        node_path = [root_id, domain_id, category_id]\n\n        span_id = r.doc_id\n        source_id = r.doc_id\n\n        spans.append(\n            {\n                \"span_id\": span_id,\n                \"text\": r.text,\n                \"source_id\": source_id,\n                \"node_path\": node_path,\n                \"meta\": {\n                    \"doc_id\": r.doc_id,\n                    \"domain\": r.domain,\n                    \"category\": r.category,\n                },\n            }\n        )\n\n    return spans\n\n\ndef write_spans_jsonl(spans: List[Dict[str, object]], out_path: Path) -> None:\n    with out_path.open(\"w\", encoding=\"utf-8\") as f:\n        for rec in spans:\n            f.write(json.dumps(rec) + \"\\n\")\n\n\ndef write_level_sizes(\n    domain_ids: Dict[str, int],\n    category_ids: Dict[str, int],\n    out_path: Path,\n) -> None:\n    \"\"\"\n    Write level_sizes helper as a dict[int, int] mapping level index\n    (excluding the root) to number of classes at that level.\n\n    For ArXiv-CLS we use:\n      level 1: domains\n      level 2: categories\n    \"\"\"\n    level_sizes = {\n        1: len(domain_ids),\n        2: len(category_ids),\n    }\n    out = {\"level_sizes\": level_sizes}\n    with out_path.open(\"w\", encoding=\"utf-8\") as f:\n        json.dump(out, f, indent=2)\n\n\ndef parse_args() -> argparse.Namespace:\n    ap = argparse.ArgumentParser(\n        description=\"Build ArXiv-CLS spans JSONL and ontology metadata.\",\n    )\n    ap.add_argument(\n        \"--metadata-file\",\n        type=str,\n        required=True,\n        help=\"CSV or JSONL file with at least: doc_id, domain, category, text.\",\n    )\n    ap.add_argument(\n        \"--spans-out\",\n        type=str,\n        required=True,\n        help=\"Output path for spans JSONL file.\",\n    )\n    ap.add_argument(\n        \"--nodes-out\",\n        type=str,\n        default=\"\",\n        help=\"Optional output path for nodes JSONL (ontology nodes).\",\n    )\n    ap.add_argument(\n        \"--level-sizes-out\",\n        type=str,\n        default=\"\",\n        help=\"Optional output path for level_sizes JSON file.\",\n    )\n\n    # Column name overrides for flexibility.\n    ap.add_argument(\n        \"--id-col\",\n        type=str,\n        default=\"doc_id\",\n        help=\"Column name for document ID.\",\n    )\n    ap.add_argument(\n        \"--domain-col\",\n        type=str,\n        default=\"domain\",\n        help='Column name for top-level arXiv area (e.g., \"cs\").',\n    )\n    ap.add_argument(\n        \"--category-col\",\n        type=str,\n        default=\"category\",\n        help='Column name for fine-grained arXiv category (e.g., \"cs.LG\").',\n    )\n    ap.add_argument(\n        \"--text-col\",\n        type=str,\n        default=\"text\",\n        help=\"Column name containing the paper text (e.g., title + abstract).\",\n    )\n\n    return ap.parse_args()\n\n\ndef main() -> None:\n    args = parse_args()\n\n    meta_path = Path(args.metadata_file)\n    if not meta_path.is_file():\n        raise FileNotFoundError(f\"metadata_file does not exist or is not a file: {meta_path}\")\n\n    rows = load_arxiv_metadata(\n        meta_path,\n        id_col=args.id_col,\n        domain_col=args.domain_col,\n        category_col=args.category_col,\n        text_col=args.text_col,\n    )\n    if not rows:\n        raise RuntimeError(f\"No valid ArXiv-CLS records were loaded from metadata file: {meta_path}\")\n\n    domain_ids, category_ids = build_ontology(rows)\n\n    spans = build_spans(rows, domain_ids=domain_ids, category_ids=category_ids)\n\n    spans_out = Path(args.spans_out)\n    spans_out.parent.mkdir(parents=True, exist_ok=True)\n    write_spans_jsonl(spans, spans_out)\n\n    if args.nodes_out:\n        nodes_out = Path(args.nodes_out)\n        nodes_out.parent.mkdir(parents=True, exist_ok=True)\n        write_nodes_jsonl(nodes_out, domain_ids, category_ids)\n\n    if args.level_sizes_out:\n        ls_out = Path(args.level_sizes_out)\n        ls_out.parent.mkdir(parents=True, exist_ok=True)\n        write_level_sizes(domain_ids, category_ids, ls_out)\n\n\nif __name__ == \"__main__\":\n    main()\n\n\n","source_hash":"eef2318b47079f127398f996d922b9fd8f45972facc8ba3737540e1cc84ee77d","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.build_arxiv_cls_spans.ArxivRow","uri":"program://TOLBERT/class/scripts.build_arxiv_cls_spans.ArxivRow#L72-L76","kind":"class","name":"ArxivRow","path":"scripts/build_arxiv_cls_spans.py","language":"python","start_line":72,"end_line":76,"context_start_line":52,"context_end_line":96,"code":"    which you can paste into a config (see `configs/wos_example.yaml` or\n    `configs/codehierarchy_example.yaml` for reference).\n\nThe resulting `spans_out` file is directly consumable by\n`tolbert.data.TreeOfLifeDataset` and the training skeleton in\n`scripts/train_tolbert.py`, as long as your config's `level_sizes`\nmatches the ontology this script builds.\n\"\"\"\n\nfrom __future__ import annotations\n\nimport argparse\nimport csv\nimport json\nfrom dataclasses import dataclass\nfrom pathlib import Path\nfrom typing import Dict, List, Optional, Tuple\n\n\n@dataclass\nclass ArxivRow:\n    doc_id: str\n    domain: str\n    category: str\n    text: str\n\n\ndef _row_to_meta(\n    row: Dict[str, object],\n    *,\n    id_col: str,\n    domain_col: str,\n    category_col: str,\n    text_col: str,\n) -> Optional[ArxivRow]:\n    try:\n        doc_id = str(row[id_col])\n        domain = str(row[domain_col])\n        category = str(row[category_col])\n        text = str(row[text_col])\n    except KeyError as exc:\n        raise KeyError(f\"Missing required column {exc!s} in metadata record: {row}\") from exc\n\n    if not text or not text.strip():\n        # Skip empty-text rows; they are not useful training examples.","source_hash":"eef2318b47079f127398f996d922b9fd8f45972facc8ba3737540e1cc84ee77d","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.build_arxiv_cls_spans._row_to_meta","uri":"program://TOLBERT/function/scripts.build_arxiv_cls_spans._row_to_meta#L79-L99","kind":"function","name":"_row_to_meta","path":"scripts/build_arxiv_cls_spans.py","language":"python","start_line":79,"end_line":99,"context_start_line":59,"context_end_line":119,"code":"\"\"\"\n\nfrom __future__ import annotations\n\nimport argparse\nimport csv\nimport json\nfrom dataclasses import dataclass\nfrom pathlib import Path\nfrom typing import Dict, List, Optional, Tuple\n\n\n@dataclass\nclass ArxivRow:\n    doc_id: str\n    domain: str\n    category: str\n    text: str\n\n\ndef _row_to_meta(\n    row: Dict[str, object],\n    *,\n    id_col: str,\n    domain_col: str,\n    category_col: str,\n    text_col: str,\n) -> Optional[ArxivRow]:\n    try:\n        doc_id = str(row[id_col])\n        domain = str(row[domain_col])\n        category = str(row[category_col])\n        text = str(row[text_col])\n    except KeyError as exc:\n        raise KeyError(f\"Missing required column {exc!s} in metadata record: {row}\") from exc\n\n    if not text or not text.strip():\n        # Skip empty-text rows; they are not useful training examples.\n        return None\n\n    return ArxivRow(doc_id=doc_id, domain=domain, category=category, text=text)\n\n\ndef load_arxiv_metadata(\n    path: Path,\n    *,\n    id_col: str,\n    domain_col: str,\n    category_col: str,\n    text_col: str,\n) -> List[ArxivRow]:\n    \"\"\"\n    Load ArXiv-CLS metadata from CSV or JSON(L).\n    \"\"\"\n    rows: List[ArxivRow] = []\n    suffix = path.suffix.lower()\n\n    if suffix in {\".jsonl\", \".json\"}:\n        with path.open(\"r\", encoding=\"utf-8\") as f:\n            for line in f:\n                line = line.strip()","source_hash":"eef2318b47079f127398f996d922b9fd8f45972facc8ba3737540e1cc84ee77d","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.build_arxiv_cls_spans.load_arxiv_metadata","uri":"program://TOLBERT/function/scripts.build_arxiv_cls_spans.load_arxiv_metadata#L102-L152","kind":"function","name":"load_arxiv_metadata","path":"scripts/build_arxiv_cls_spans.py","language":"python","start_line":102,"end_line":152,"context_start_line":82,"context_end_line":172,"code":"    id_col: str,\n    domain_col: str,\n    category_col: str,\n    text_col: str,\n) -> Optional[ArxivRow]:\n    try:\n        doc_id = str(row[id_col])\n        domain = str(row[domain_col])\n        category = str(row[category_col])\n        text = str(row[text_col])\n    except KeyError as exc:\n        raise KeyError(f\"Missing required column {exc!s} in metadata record: {row}\") from exc\n\n    if not text or not text.strip():\n        # Skip empty-text rows; they are not useful training examples.\n        return None\n\n    return ArxivRow(doc_id=doc_id, domain=domain, category=category, text=text)\n\n\ndef load_arxiv_metadata(\n    path: Path,\n    *,\n    id_col: str,\n    domain_col: str,\n    category_col: str,\n    text_col: str,\n) -> List[ArxivRow]:\n    \"\"\"\n    Load ArXiv-CLS metadata from CSV or JSON(L).\n    \"\"\"\n    rows: List[ArxivRow] = []\n    suffix = path.suffix.lower()\n\n    if suffix in {\".jsonl\", \".json\"}:\n        with path.open(\"r\", encoding=\"utf-8\") as f:\n            for line in f:\n                line = line.strip()\n                if not line:\n                    continue\n                obj = json.loads(line)\n                # Allow records nested under \"data\" for compatibility with some pipelines.\n                if isinstance(obj, dict) and \"data\" in obj and isinstance(obj[\"data\"], dict):\n                    obj = obj[\"data\"]\n                if not isinstance(obj, dict):\n                    continue\n                meta = _row_to_meta(\n                    obj,\n                    id_col=id_col,\n                    domain_col=domain_col,\n                    category_col=category_col,\n                    text_col=text_col,\n                )\n                if meta is not None:\n                    rows.append(meta)\n        return rows\n\n    # Default: CSV with header\n    with path.open(\"r\", encoding=\"utf-8\") as f:\n        reader = csv.DictReader(f)\n        for row in reader:\n            meta = _row_to_meta(\n                row,\n                id_col=id_col,\n                domain_col=domain_col,\n                category_col=category_col,\n                text_col=text_col,\n            )\n            if meta is not None:\n                rows.append(meta)\n    return rows\n\n\ndef build_ontology(rows: List[ArxivRow]) -> Tuple[Dict[str, int], Dict[str, int]]:\n    \"\"\"\n    Build integer node IDs for:\n\n      - level 1:  unique domains (e.g., \"cs\", \"math\")\n      - level 2:  (domain, category) pairs (e.g., \"cs::cs.LG\")\n\n    Level conventions:\n      level 0: root (id 0)\n      level 1: domain nodes\n      level 2: category nodes (per domain)\n    \"\"\"\n    next_id = 0\n    root_id = next_id\n    next_id += 1\n\n    domain_ids: Dict[str, int] = {}\n    category_ids: Dict[str, int] = {}","source_hash":"eef2318b47079f127398f996d922b9fd8f45972facc8ba3737540e1cc84ee77d","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.build_arxiv_cls_spans.build_ontology","uri":"program://TOLBERT/function/scripts.build_arxiv_cls_spans.build_ontology#L155-L186","kind":"function","name":"build_ontology","path":"scripts/build_arxiv_cls_spans.py","language":"python","start_line":155,"end_line":186,"context_start_line":135,"context_end_line":206,"code":"                if meta is not None:\n                    rows.append(meta)\n        return rows\n\n    # Default: CSV with header\n    with path.open(\"r\", encoding=\"utf-8\") as f:\n        reader = csv.DictReader(f)\n        for row in reader:\n            meta = _row_to_meta(\n                row,\n                id_col=id_col,\n                domain_col=domain_col,\n                category_col=category_col,\n                text_col=text_col,\n            )\n            if meta is not None:\n                rows.append(meta)\n    return rows\n\n\ndef build_ontology(rows: List[ArxivRow]) -> Tuple[Dict[str, int], Dict[str, int]]:\n    \"\"\"\n    Build integer node IDs for:\n\n      - level 1:  unique domains (e.g., \"cs\", \"math\")\n      - level 2:  (domain, category) pairs (e.g., \"cs::cs.LG\")\n\n    Level conventions:\n      level 0: root (id 0)\n      level 1: domain nodes\n      level 2: category nodes (per domain)\n    \"\"\"\n    next_id = 0\n    root_id = next_id\n    next_id += 1\n\n    domain_ids: Dict[str, int] = {}\n    category_ids: Dict[str, int] = {}\n\n    for r in rows:\n        if r.domain not in domain_ids:\n            domain_ids[r.domain] = next_id\n            next_id += 1\n\n        cat_key = f\"{r.domain}::{r.category}\"\n        if cat_key not in category_ids:\n            category_ids[cat_key] = next_id\n            next_id += 1\n\n    # root_id is currently unused in the returned dicts but documented for clarity\n    _ = root_id\n    return domain_ids, category_ids\n\n\ndef write_nodes_jsonl(\n    out_path: Path,\n    domain_ids: Dict[str, int],\n    category_ids: Dict[str, int],\n) -> None:\n    \"\"\"\n    Emit a minimal nodes.jsonl compatible with docs/tree_of_life.md.\n    \"\"\"\n    with out_path.open(\"w\", encoding=\"utf-8\") as f:\n        # Root (level 0)\n        f.write(\n            json.dumps(\n                {\n                    \"node_id\": 0,\n                    \"level\": 0,\n                    \"type\": \"root\",\n                    \"parent_id\": None,\n                    \"name\": \"Root\",","source_hash":"eef2318b47079f127398f996d922b9fd8f45972facc8ba3737540e1cc84ee77d","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.build_arxiv_cls_spans.write_nodes_jsonl","uri":"program://TOLBERT/function/scripts.build_arxiv_cls_spans.write_nodes_jsonl#L189-L245","kind":"function","name":"write_nodes_jsonl","path":"scripts/build_arxiv_cls_spans.py","language":"python","start_line":189,"end_line":245,"context_start_line":169,"context_end_line":265,"code":"    next_id += 1\n\n    domain_ids: Dict[str, int] = {}\n    category_ids: Dict[str, int] = {}\n\n    for r in rows:\n        if r.domain not in domain_ids:\n            domain_ids[r.domain] = next_id\n            next_id += 1\n\n        cat_key = f\"{r.domain}::{r.category}\"\n        if cat_key not in category_ids:\n            category_ids[cat_key] = next_id\n            next_id += 1\n\n    # root_id is currently unused in the returned dicts but documented for clarity\n    _ = root_id\n    return domain_ids, category_ids\n\n\ndef write_nodes_jsonl(\n    out_path: Path,\n    domain_ids: Dict[str, int],\n    category_ids: Dict[str, int],\n) -> None:\n    \"\"\"\n    Emit a minimal nodes.jsonl compatible with docs/tree_of_life.md.\n    \"\"\"\n    with out_path.open(\"w\", encoding=\"utf-8\") as f:\n        # Root (level 0)\n        f.write(\n            json.dumps(\n                {\n                    \"node_id\": 0,\n                    \"level\": 0,\n                    \"type\": \"root\",\n                    \"parent_id\": None,\n                    \"name\": \"Root\",\n                    \"attributes\": {},\n                }\n            )\n            + \"\\n\"\n        )\n\n        # Domains (level 1)\n        for domain_name, nid in domain_ids.items():\n            f.write(\n                json.dumps(\n                    {\n                        \"node_id\": nid,\n                        \"level\": 1,\n                        \"type\": \"domain\",\n                        \"parent_id\": 0,\n                        \"name\": domain_name,\n                        \"attributes\": {},\n                    }\n                )\n                + \"\\n\"\n            )\n\n        # Categories (level 2)\n        for key, nid in category_ids.items():\n            domain_name, category_name = key.split(\"::\", 1)\n            parent_id = domain_ids[domain_name]\n            f.write(\n                json.dumps(\n                    {\n                        \"node_id\": nid,\n                        \"level\": 2,\n                        \"type\": \"category\",\n                        \"parent_id\": parent_id,\n                        \"name\": category_name,\n                        \"attributes\": {\"domain\": domain_name},\n                    }\n                )\n                + \"\\n\"\n            )\n\n\ndef build_spans(\n    rows: List[ArxivRow],\n    domain_ids: Dict[str, int],\n    category_ids: Dict[str, int],\n) -> List[Dict[str, object]]:\n    \"\"\"\n    Build span records with node_path = [root_id, domain_id, category_id].\n    \"\"\"\n    spans: List[Dict[str, object]] = []\n    root_id = 0\n\n    for r in rows:\n        domain_id = domain_ids[r.domain]\n        cat_key = f\"{r.domain}::{r.category}\"\n        category_id = category_ids[cat_key]\n\n        node_path = [root_id, domain_id, category_id]\n","source_hash":"eef2318b47079f127398f996d922b9fd8f45972facc8ba3737540e1cc84ee77d","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.build_arxiv_cls_spans.build_spans","uri":"program://TOLBERT/function/scripts.build_arxiv_cls_spans.build_spans#L248-L283","kind":"function","name":"build_spans","path":"scripts/build_arxiv_cls_spans.py","language":"python","start_line":248,"end_line":283,"context_start_line":228,"context_end_line":303,"code":"\n        # Categories (level 2)\n        for key, nid in category_ids.items():\n            domain_name, category_name = key.split(\"::\", 1)\n            parent_id = domain_ids[domain_name]\n            f.write(\n                json.dumps(\n                    {\n                        \"node_id\": nid,\n                        \"level\": 2,\n                        \"type\": \"category\",\n                        \"parent_id\": parent_id,\n                        \"name\": category_name,\n                        \"attributes\": {\"domain\": domain_name},\n                    }\n                )\n                + \"\\n\"\n            )\n\n\ndef build_spans(\n    rows: List[ArxivRow],\n    domain_ids: Dict[str, int],\n    category_ids: Dict[str, int],\n) -> List[Dict[str, object]]:\n    \"\"\"\n    Build span records with node_path = [root_id, domain_id, category_id].\n    \"\"\"\n    spans: List[Dict[str, object]] = []\n    root_id = 0\n\n    for r in rows:\n        domain_id = domain_ids[r.domain]\n        cat_key = f\"{r.domain}::{r.category}\"\n        category_id = category_ids[cat_key]\n\n        node_path = [root_id, domain_id, category_id]\n\n        span_id = r.doc_id\n        source_id = r.doc_id\n\n        spans.append(\n            {\n                \"span_id\": span_id,\n                \"text\": r.text,\n                \"source_id\": source_id,\n                \"node_path\": node_path,\n                \"meta\": {\n                    \"doc_id\": r.doc_id,\n                    \"domain\": r.domain,\n                    \"category\": r.category,\n                },\n            }\n        )\n\n    return spans\n\n\ndef write_spans_jsonl(spans: List[Dict[str, object]], out_path: Path) -> None:\n    with out_path.open(\"w\", encoding=\"utf-8\") as f:\n        for rec in spans:\n            f.write(json.dumps(rec) + \"\\n\")\n\n\ndef write_level_sizes(\n    domain_ids: Dict[str, int],\n    category_ids: Dict[str, int],\n    out_path: Path,\n) -> None:\n    \"\"\"\n    Write level_sizes helper as a dict[int, int] mapping level index\n    (excluding the root) to number of classes at that level.\n\n    For ArXiv-CLS we use:\n      level 1: domains\n      level 2: categories","source_hash":"eef2318b47079f127398f996d922b9fd8f45972facc8ba3737540e1cc84ee77d","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.build_arxiv_cls_spans.write_spans_jsonl","uri":"program://TOLBERT/function/scripts.build_arxiv_cls_spans.write_spans_jsonl#L286-L289","kind":"function","name":"write_spans_jsonl","path":"scripts/build_arxiv_cls_spans.py","language":"python","start_line":286,"end_line":289,"context_start_line":266,"context_end_line":309,"code":"        span_id = r.doc_id\n        source_id = r.doc_id\n\n        spans.append(\n            {\n                \"span_id\": span_id,\n                \"text\": r.text,\n                \"source_id\": source_id,\n                \"node_path\": node_path,\n                \"meta\": {\n                    \"doc_id\": r.doc_id,\n                    \"domain\": r.domain,\n                    \"category\": r.category,\n                },\n            }\n        )\n\n    return spans\n\n\ndef write_spans_jsonl(spans: List[Dict[str, object]], out_path: Path) -> None:\n    with out_path.open(\"w\", encoding=\"utf-8\") as f:\n        for rec in spans:\n            f.write(json.dumps(rec) + \"\\n\")\n\n\ndef write_level_sizes(\n    domain_ids: Dict[str, int],\n    category_ids: Dict[str, int],\n    out_path: Path,\n) -> None:\n    \"\"\"\n    Write level_sizes helper as a dict[int, int] mapping level index\n    (excluding the root) to number of classes at that level.\n\n    For ArXiv-CLS we use:\n      level 1: domains\n      level 2: categories\n    \"\"\"\n    level_sizes = {\n        1: len(domain_ids),\n        2: len(category_ids),\n    }\n    out = {\"level_sizes\": level_sizes}","source_hash":"eef2318b47079f127398f996d922b9fd8f45972facc8ba3737540e1cc84ee77d","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.build_arxiv_cls_spans.write_level_sizes","uri":"program://TOLBERT/function/scripts.build_arxiv_cls_spans.write_level_sizes#L292-L311","kind":"function","name":"write_level_sizes","path":"scripts/build_arxiv_cls_spans.py","language":"python","start_line":292,"end_line":311,"context_start_line":272,"context_end_line":331,"code":"                \"text\": r.text,\n                \"source_id\": source_id,\n                \"node_path\": node_path,\n                \"meta\": {\n                    \"doc_id\": r.doc_id,\n                    \"domain\": r.domain,\n                    \"category\": r.category,\n                },\n            }\n        )\n\n    return spans\n\n\ndef write_spans_jsonl(spans: List[Dict[str, object]], out_path: Path) -> None:\n    with out_path.open(\"w\", encoding=\"utf-8\") as f:\n        for rec in spans:\n            f.write(json.dumps(rec) + \"\\n\")\n\n\ndef write_level_sizes(\n    domain_ids: Dict[str, int],\n    category_ids: Dict[str, int],\n    out_path: Path,\n) -> None:\n    \"\"\"\n    Write level_sizes helper as a dict[int, int] mapping level index\n    (excluding the root) to number of classes at that level.\n\n    For ArXiv-CLS we use:\n      level 1: domains\n      level 2: categories\n    \"\"\"\n    level_sizes = {\n        1: len(domain_ids),\n        2: len(category_ids),\n    }\n    out = {\"level_sizes\": level_sizes}\n    with out_path.open(\"w\", encoding=\"utf-8\") as f:\n        json.dump(out, f, indent=2)\n\n\ndef parse_args() -> argparse.Namespace:\n    ap = argparse.ArgumentParser(\n        description=\"Build ArXiv-CLS spans JSONL and ontology metadata.\",\n    )\n    ap.add_argument(\n        \"--metadata-file\",\n        type=str,\n        required=True,\n        help=\"CSV or JSONL file with at least: doc_id, domain, category, text.\",\n    )\n    ap.add_argument(\n        \"--spans-out\",\n        type=str,\n        required=True,\n        help=\"Output path for spans JSONL file.\",\n    )\n    ap.add_argument(\n        \"--nodes-out\",","source_hash":"eef2318b47079f127398f996d922b9fd8f45972facc8ba3737540e1cc84ee77d","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.build_arxiv_cls_spans.parse_args","uri":"program://TOLBERT/function/scripts.build_arxiv_cls_spans.parse_args#L314-L369","kind":"function","name":"parse_args","path":"scripts/build_arxiv_cls_spans.py","language":"python","start_line":314,"end_line":369,"context_start_line":294,"context_end_line":389,"code":"    category_ids: Dict[str, int],\n    out_path: Path,\n) -> None:\n    \"\"\"\n    Write level_sizes helper as a dict[int, int] mapping level index\n    (excluding the root) to number of classes at that level.\n\n    For ArXiv-CLS we use:\n      level 1: domains\n      level 2: categories\n    \"\"\"\n    level_sizes = {\n        1: len(domain_ids),\n        2: len(category_ids),\n    }\n    out = {\"level_sizes\": level_sizes}\n    with out_path.open(\"w\", encoding=\"utf-8\") as f:\n        json.dump(out, f, indent=2)\n\n\ndef parse_args() -> argparse.Namespace:\n    ap = argparse.ArgumentParser(\n        description=\"Build ArXiv-CLS spans JSONL and ontology metadata.\",\n    )\n    ap.add_argument(\n        \"--metadata-file\",\n        type=str,\n        required=True,\n        help=\"CSV or JSONL file with at least: doc_id, domain, category, text.\",\n    )\n    ap.add_argument(\n        \"--spans-out\",\n        type=str,\n        required=True,\n        help=\"Output path for spans JSONL file.\",\n    )\n    ap.add_argument(\n        \"--nodes-out\",\n        type=str,\n        default=\"\",\n        help=\"Optional output path for nodes JSONL (ontology nodes).\",\n    )\n    ap.add_argument(\n        \"--level-sizes-out\",\n        type=str,\n        default=\"\",\n        help=\"Optional output path for level_sizes JSON file.\",\n    )\n\n    # Column name overrides for flexibility.\n    ap.add_argument(\n        \"--id-col\",\n        type=str,\n        default=\"doc_id\",\n        help=\"Column name for document ID.\",\n    )\n    ap.add_argument(\n        \"--domain-col\",\n        type=str,\n        default=\"domain\",\n        help='Column name for top-level arXiv area (e.g., \"cs\").',\n    )\n    ap.add_argument(\n        \"--category-col\",\n        type=str,\n        default=\"category\",\n        help='Column name for fine-grained arXiv category (e.g., \"cs.LG\").',\n    )\n    ap.add_argument(\n        \"--text-col\",\n        type=str,\n        default=\"text\",\n        help=\"Column name containing the paper text (e.g., title + abstract).\",\n    )\n\n    return ap.parse_args()\n\n\ndef main() -> None:\n    args = parse_args()\n\n    meta_path = Path(args.metadata_file)\n    if not meta_path.is_file():\n        raise FileNotFoundError(f\"metadata_file does not exist or is not a file: {meta_path}\")\n\n    rows = load_arxiv_metadata(\n        meta_path,\n        id_col=args.id_col,\n        domain_col=args.domain_col,\n        category_col=args.category_col,\n        text_col=args.text_col,\n    )\n    if not rows:\n        raise RuntimeError(f\"No valid ArXiv-CLS records were loaded from metadata file: {meta_path}\")\n\n    domain_ids, category_ids = build_ontology(rows)","source_hash":"eef2318b47079f127398f996d922b9fd8f45972facc8ba3737540e1cc84ee77d","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.build_arxiv_cls_spans.main","uri":"program://TOLBERT/function/scripts.build_arxiv_cls_spans.main#L372-L405","kind":"function","name":"main","path":"scripts/build_arxiv_cls_spans.py","language":"python","start_line":372,"end_line":405,"context_start_line":352,"context_end_line":412,"code":"        type=str,\n        default=\"domain\",\n        help='Column name for top-level arXiv area (e.g., \"cs\").',\n    )\n    ap.add_argument(\n        \"--category-col\",\n        type=str,\n        default=\"category\",\n        help='Column name for fine-grained arXiv category (e.g., \"cs.LG\").',\n    )\n    ap.add_argument(\n        \"--text-col\",\n        type=str,\n        default=\"text\",\n        help=\"Column name containing the paper text (e.g., title + abstract).\",\n    )\n\n    return ap.parse_args()\n\n\ndef main() -> None:\n    args = parse_args()\n\n    meta_path = Path(args.metadata_file)\n    if not meta_path.is_file():\n        raise FileNotFoundError(f\"metadata_file does not exist or is not a file: {meta_path}\")\n\n    rows = load_arxiv_metadata(\n        meta_path,\n        id_col=args.id_col,\n        domain_col=args.domain_col,\n        category_col=args.category_col,\n        text_col=args.text_col,\n    )\n    if not rows:\n        raise RuntimeError(f\"No valid ArXiv-CLS records were loaded from metadata file: {meta_path}\")\n\n    domain_ids, category_ids = build_ontology(rows)\n\n    spans = build_spans(rows, domain_ids=domain_ids, category_ids=category_ids)\n\n    spans_out = Path(args.spans_out)\n    spans_out.parent.mkdir(parents=True, exist_ok=True)\n    write_spans_jsonl(spans, spans_out)\n\n    if args.nodes_out:\n        nodes_out = Path(args.nodes_out)\n        nodes_out.parent.mkdir(parents=True, exist_ok=True)\n        write_nodes_jsonl(nodes_out, domain_ids, category_ids)\n\n    if args.level_sizes_out:\n        ls_out = Path(args.level_sizes_out)\n        ls_out.parent.mkdir(parents=True, exist_ok=True)\n        write_level_sizes(domain_ids, category_ids, ls_out)\n\n\nif __name__ == \"__main__\":\n    main()\n\n\n","source_hash":"eef2318b47079f127398f996d922b9fd8f45972facc8ba3737540e1cc84ee77d","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.eval_retrieval","uri":"program://TOLBERT/module/scripts.eval_retrieval#L1-L454","kind":"module","name":"scripts.eval_retrieval","path":"scripts/eval_retrieval.py","language":"python","start_line":1,"end_line":454,"context_start_line":1,"context_end_line":454,"code":"\"\"\"\nEvaluate embeddings on retrieval-style tasks.\n\nThis script computes:\n  - MRR (Mean Reciprocal Rank)\n  - Precision@K\n\nfor a simple setup where:\n  - The index consists of spans from one spans_file (e.g., code files).\n  - The queries are spans from another spans_file (e.g., paper abstracts).\n  - \"Relevance\" is defined by sharing one or more levels in the hierarchy.\n\nBy default we use \"share at least level 2\" as the relevance criterion, but\nthis can be adjusted via flags.\n\nUsage (Paper2Code-style example):\n\n  python -m scripts.eval_retrieval \\\\\n      --config configs/codehierarchy_example.yaml \\\\\n      --checkpoint checkpoints/tolbert_epoch5.pt \\\\\n      --index-spans data/codehierarchy/spans_code.jsonl \\\\\n      --query-spans data/wos/spans_papers.jsonl \\\\\n      --relevant-min-level 2 \\\\\n      --k 5\n\"\"\"\n\nfrom __future__ import annotations\n\nimport argparse\nfrom pathlib import Path\nfrom typing import Any, Dict, List, Sequence, Tuple\n\nimport torch\nfrom torch.nn import functional as F\nfrom transformers import AutoModel, AutoTokenizer\nimport os\n\nfrom tolbert.config import load_tolbert_config\nfrom tolbert.data import TreeOfLifeDataset\nfrom tolbert.modeling import TOLBERT, TOLBERTConfig\n\n\ndef build_tolbert_model(cfg: Dict[str, Any], checkpoint: str, device: torch.device) -> TOLBERT:\n    model_cfg = TOLBERTConfig(\n        base_model_name=cfg[\"base_model_name\"],\n        level_sizes=cfg[\"level_sizes\"],\n        proj_dim=cfg.get(\"proj_dim\", 256),\n    )\n    model = TOLBERT(model_cfg)\n    state = torch.load(checkpoint, map_location=\"cpu\")\n    model.load_state_dict(state)\n    model.to(device)\n    model.eval()\n    return model\n\n\ndef encode_spans_tolbert(\n    model: TOLBERT,\n    tokenizer,\n    spans_file: str,\n    max_length: int,\n    device: torch.device,\n) -> Tuple[torch.Tensor, List[Dict[str, Any]]]:\n    \"\"\"\n    Encode all spans in `spans_file` into TOLBERT embeddings (proj head) and\n    return (emb_mat, raw_records).\n\n    This mirrors the logic in scripts/retrieval_sandbox.py but returns the full\n    embedding matrix for evaluation purposes.\n    \"\"\"\n    dataset = TreeOfLifeDataset(\n        spans_file=spans_file,\n        tokenizer=tokenizer,\n        max_length=max_length,\n    )\n\n    embs: List[torch.Tensor] = []\n    metas: List[Dict[str, Any]] = []\n\n    for rec in dataset._records:  # type: ignore[attr-defined]\n        tokens = tokenizer(\n            rec.text,\n            return_tensors=\"pt\",\n            truncation=True,\n            padding=\"max_length\",\n            max_length=max_length,\n        )\n        input_ids = tokens[\"input_ids\"].to(device)\n        attention_mask = tokens[\"attention_mask\"].to(device)\n        with torch.no_grad():\n            out = model(input_ids=input_ids, attention_mask=attention_mask)\n        embs.append(out[\"proj\"].squeeze(0).cpu())\n        metas.append(rec.raw)\n\n    if not embs:\n        return torch.empty(0), metas\n    return torch.stack(embs, dim=0), metas\n\n\ndef encode_spans_hf_encoder(\n    model: AutoModel,\n    tokenizer,\n    spans_file: str,\n    max_length: int,\n    device: torch.device,\n) -> Tuple[torch.Tensor, List[Dict[str, Any]]]:\n    \"\"\"\n    Encode all spans using a vanilla HF encoder (e.g., BERT / CodeBERT /\n    ModernBERT) and return CLS embeddings.\n\n    This is used for baseline retrieval comparisons where we do not have\n    TOLBERT's projection head and simply use the encoder's [CLS] representation.\n    \"\"\"\n    dataset = TreeOfLifeDataset(\n        spans_file=spans_file,\n        tokenizer=tokenizer,\n        max_length=max_length,\n    )\n\n    embs: List[torch.Tensor] = []\n    metas: List[Dict[str, Any]] = []\n\n    for rec in dataset._records:  # type: ignore[attr-defined]\n        tokens = tokenizer(\n            rec.text,\n            return_tensors=\"pt\",\n            truncation=True,\n            padding=\"max_length\",\n            max_length=max_length,\n        )\n        input_ids = tokens[\"input_ids\"].to(device)\n        attention_mask = tokens[\"attention_mask\"].to(device)\n        with torch.no_grad():\n            out = model(input_ids=input_ids, attention_mask=attention_mask)\n        # Standard HF encoder output: last_hidden_state[:, 0, :] is [CLS]\n        cls = out.last_hidden_state[:, 0, :]\n        embs.append(cls.squeeze(0).cpu())\n        metas.append(rec.raw)\n\n    if not embs:\n        return torch.empty(0), metas\n    return torch.stack(embs, dim=0), metas\n\n\ndef compute_relevance_mask(\n    query_paths: Sequence[Sequence[int]],\n    index_paths: Sequence[Sequence[int]],\n    min_level: int,\n) -> List[List[bool]]:\n    \"\"\"\n    Build a boolean matrix R where R[i][j] is True if query i and index j\n    share at least one node at depth >= min_level in their node_path.\n\n    Paths are lists of node ids [root, c1, c2, ...].\n    \"\"\"\n    rel: List[List[bool]] = []\n    for q_path in query_paths:\n        row: List[bool] = []\n        for idx_path in index_paths:\n            # shared depth = deepest k where q_path[k] == idx_path[k]\n            shared = False\n            max_shared_level = min(len(q_path), len(idx_path)) - 1\n            for lvl in range(min_level, max_shared_level + 1):\n                if q_path[lvl] == idx_path[lvl]:\n                    shared = True\n                    break\n            row.append(shared)\n        rel.append(row)\n    return rel\n\n\ndef eval_retrieval(\n    query_embs: torch.Tensor,\n    index_embs: torch.Tensor,\n    relevant: List[List[bool]],\n    k: int,\n) -> Tuple[float, float]:\n    \"\"\"\n    Compute MRR and Precision@k given:\n      - query_embs: (Q, D)\n      - index_embs: (N, D)\n      - relevant:   QxN boolean matrix (relevance marks)\n    \"\"\"\n    if query_embs.numel() == 0 or index_embs.numel() == 0:\n        return 0.0, 0.0\n\n    # Normalize embeddings for cosine similarity\n    query_embs = F.normalize(query_embs, dim=-1)\n    index_embs = F.normalize(index_embs, dim=-1)\n\n    # Similarity matrix (Q, N)\n    sims = torch.matmul(query_embs, index_embs.T)\n\n    Q, N = sims.shape\n    k = min(k, N)\n\n    mrr = 0.0\n    prec_at_k = 0.0\n\n    for i in range(Q):\n        rel_row = relevant[i]\n        if not any(rel_row):\n            continue  # skip queries with no relevant items\n\n        scores = sims[i]\n        topk_vals, topk_idx = torch.topk(scores, k=k)\n        topk_idx_list = topk_idx.tolist()\n\n        # MRR: find rank of first relevant\n        rr = 0.0\n        for rank, j in enumerate(topk_idx_list, start=1):\n            if rel_row[j]:\n                rr = 1.0 / rank\n                break\n        mrr += rr\n\n        # Precision@k: fraction of top-k that are relevant\n        num_rel_in_topk = sum(1 for j in topk_idx_list if rel_row[j])\n        prec_at_k += num_rel_in_topk / float(k)\n\n    # Normalize by number of queries that had at least one relevant item.\n    num_queries_with_rel = sum(1 for row in relevant if any(row))\n    if num_queries_with_rel == 0:\n        return 0.0, 0.0\n\n    mrr /= num_queries_with_rel\n    prec_at_k /= num_queries_with_rel\n    return mrr, prec_at_k\n\n\ndef compute_branch_consistency_at_k(\n    query_embs: torch.Tensor,\n    index_embs: torch.Tensor,\n    query_paths: Sequence[Sequence[int]],\n    index_paths: Sequence[Sequence[int]],\n    k: int,\n) -> Dict[int, float]:\n    \"\"\"\n    Compute branch-consistency@k per hierarchy depth.\n\n    For each query and each depth level ℓ (index in node_path, 0=root),\n    we measure the fraction of the top-k retrieved items whose node_path\n    matches the query's node at depth ℓ. Results are averaged over all\n    queries that have a node defined at that depth.\n    \"\"\"\n    if query_embs.numel() == 0 or index_embs.numel() == 0:\n        return {}\n\n    # Normalize embeddings for cosine similarity\n    query_embs = F.normalize(query_embs, dim=-1)\n    index_embs = F.normalize(index_embs, dim=-1)\n\n    sims = torch.matmul(query_embs, index_embs.T)  # (Q, N)\n    Q, N = sims.shape\n    k = min(k, N)\n\n    # Determine maximum depth observed across all paths (0-based index).\n    max_depth = 0\n    for p in list(query_paths) + list(index_paths):\n        if p:\n            max_depth = max(max_depth, len(p) - 1)\n\n    # Accumulators: depth -> (sum_fraction, num_queries_with_node)\n    num_levels = max_depth + 1\n    sum_frac: List[float] = [0.0 for _ in range(num_levels)]\n    count_q: List[int] = [0 for _ in range(num_levels)]\n\n    for qi in range(Q):\n        q_path = list(query_paths[qi]) if qi < len(query_paths) else []\n        if not q_path:\n            continue\n\n        scores = sims[qi]\n        topk_vals, topk_idx = torch.topk(scores, k=k)\n        topk_indices = topk_idx.tolist()\n\n        for depth in range(1, num_levels):  # skip depth 0 (root) by default\n            if len(q_path) <= depth:\n                continue\n            q_node = q_path[depth]\n            # Count how many of the top-k share the same node at this depth.\n            matches = 0\n            valid_cands = 0\n            for j in topk_indices:\n                if j >= len(index_paths):\n                    continue\n                idx_path = list(index_paths[j])\n                if len(idx_path) <= depth:\n                    continue\n                valid_cands += 1\n                if idx_path[depth] == q_node:\n                    matches += 1\n            if valid_cands == 0:\n                continue\n            frac = matches / float(valid_cands)\n            sum_frac[depth] += frac\n            count_q[depth] += 1\n\n    consistency: Dict[int, float] = {}\n    for depth in range(1, num_levels):\n        if count_q[depth] == 0:\n            continue\n        consistency[depth] = sum_frac[depth] / float(count_q[depth])\n    return consistency\n\n\ndef parse_args() -> argparse.Namespace:\n    ap = argparse.ArgumentParser(description=\"Evaluate retrieval (MRR, Precision@K, branch consistency).\")\n    ap.add_argument(\"--config\", type=str, required=True, help=\"Training config used for the model.\")\n    ap.add_argument(\n        \"--checkpoint\",\n        type=str,\n        required=True,\n        help=(\n            \"For mode=tolbert: path to .pt checkpoint (state_dict). \"\n            \"For mode=hf_encoder: HF model name or directory to load via AutoModel.\"\n        ),\n    )\n    ap.add_argument(\n        \"--index-spans\",\n        type=str,\n        required=True,\n        help=\"Spans JSONL file used as the retrieval index (e.g., code).\",\n    )\n    ap.add_argument(\n        \"--query-spans\",\n        type=str,\n        required=True,\n        help=\"Spans JSONL file used as queries (e.g., papers).\",\n    )\n    ap.add_argument(\n        \"--relevant-min-level\",\n        type=int,\n        default=2,\n        help=\"Minimum level depth (in node_path) that must match to count as relevant.\",\n    )\n    ap.add_argument(\n        \"--k\",\n        type=int,\n        default=5,\n        help=\"Top-k for Precision@K and MRR computation (default: 5).\",\n    )\n    ap.add_argument(\n        \"--device\",\n        type=str,\n        default=\"cuda\" if torch.cuda.is_available() else \"cpu\",\n        help=\"Device to use.\",\n    )\n    ap.add_argument(\n        \"--mode\",\n        type=str,\n        default=\"tolbert\",\n        choices=[\"tolbert\", \"hf_encoder\"],\n        help=(\n            \"Embedding backend: 'tolbert' (default, uses TOLBERT proj head) \"\n            \"or 'hf_encoder' (vanilla HF encoder CLS for baselines like BERT, \"\n            \"SciBERT, CodeBERT, ModernBERT).\"\n        ),\n    )\n    return ap.parse_args()\n\n\ndef main() -> None:\n    args = parse_args()\n    cfg = load_tolbert_config(args.config)\n    device = torch.device(args.device)\n\n    index_spans_path = Path(args.index_spans)\n    query_spans_path = Path(args.query_spans)\n    if not index_spans_path.exists():\n        raise FileNotFoundError(f\"index_spans not found: {index_spans_path}\")\n    if not query_spans_path.exists():\n        raise FileNotFoundError(f\"query_spans not found: {query_spans_path}\")\n\n    tokenizer = AutoTokenizer.from_pretrained(\n        cfg[\"base_model_name\"] if args.mode == \"tolbert\" else args.checkpoint,\n        cache_dir=\"/data/checkpoints/\",  # noqa: E501\n    )\n\n    if args.mode == \"tolbert\":\n        model = build_tolbert_model(cfg, checkpoint=args.checkpoint, device=device)\n        encode_fn = encode_spans_tolbert\n    else:\n        # Vanilla HF encoder baseline (BERT, SciBERT, CodeBERT, ModernBERT, etc.)\n        model = AutoModel.from_pretrained(\n            args.checkpoint,\n            cache_dir=\"/data/checkpoints/\",  # noqa: E501\n        )\n        model.to(device)\n        model.eval()\n        encode_fn = encode_spans_hf_encoder\n\n    print(f\"Encoding index spans from {index_spans_path} ...\")\n    index_embs, index_metas = encode_fn(\n        model=model,\n        tokenizer=tokenizer,\n        spans_file=str(index_spans_path),\n        max_length=cfg.get(\"max_length\", 256),\n        device=device,\n    )\n\n    print(f\"Encoding query spans from {query_spans_path} ...\")\n    query_embs, query_metas = encode_fn(\n        model=model,\n        tokenizer=tokenizer,\n        spans_file=str(query_spans_path),\n        max_length=cfg.get(\"max_length\", 256),\n        device=device,\n    )\n\n    # Extract node_path lists from metas.\n    index_paths: List[Sequence[int]] = [\n        rec.get(\"node_path\", []) for rec in index_metas  # type: ignore[assignment]\n    ]\n    query_paths: List[Sequence[int]] = [\n        rec.get(\"node_path\", []) for rec in query_metas  # type: ignore[assignment]\n    ]\n\n    relevant = compute_relevance_mask(\n        query_paths=query_paths,\n        index_paths=index_paths,\n        min_level=args.relevant_min_level,\n    )\n\n    mrr, p_at_k = eval_retrieval(\n        query_embs=query_embs,\n        index_embs=index_embs,\n        relevant=relevant,\n        k=args.k,\n    )\n\n    print(\"=== Retrieval Evaluation ===\")\n    print(f\"MRR:        {mrr:.4f}\")\n    print(f\"Precision@{args.k}: {p_at_k:.4f}\")\n\n    # Ontology-aware metric: branch-consistency@k per depth level.\n    branch_consistency = compute_branch_consistency_at_k(\n        query_embs=query_embs,\n        index_embs=index_embs,\n        query_paths=query_paths,\n        index_paths=index_paths,\n        k=args.k,\n    )\n    if branch_consistency:\n        print(\"\\nBranch-consistency@{k} by depth (node_path index):\".format(k=args.k))\n        for depth in sorted(branch_consistency.keys()):\n            # depth 0 is the root; depths >=1 correspond to actual hierarchy levels.\n            print(f\"  depth {depth}: {branch_consistency[depth]:.4f}\")\n\n\nif __name__ == \"__main__\":\n    main()\n\n","source_hash":"0618a8d31a4435c8ec1cfe19fb3dee05f16a905b73db22e3a3ea623292149c00","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.eval_retrieval.build_tolbert_model","uri":"program://TOLBERT/function/scripts.eval_retrieval.build_tolbert_model#L43-L54","kind":"function","name":"build_tolbert_model","path":"scripts/eval_retrieval.py","language":"python","start_line":43,"end_line":54,"context_start_line":23,"context_end_line":74,"code":"      --relevant-min-level 2 \\\\\n      --k 5\n\"\"\"\n\nfrom __future__ import annotations\n\nimport argparse\nfrom pathlib import Path\nfrom typing import Any, Dict, List, Sequence, Tuple\n\nimport torch\nfrom torch.nn import functional as F\nfrom transformers import AutoModel, AutoTokenizer\nimport os\n\nfrom tolbert.config import load_tolbert_config\nfrom tolbert.data import TreeOfLifeDataset\nfrom tolbert.modeling import TOLBERT, TOLBERTConfig\n\n\ndef build_tolbert_model(cfg: Dict[str, Any], checkpoint: str, device: torch.device) -> TOLBERT:\n    model_cfg = TOLBERTConfig(\n        base_model_name=cfg[\"base_model_name\"],\n        level_sizes=cfg[\"level_sizes\"],\n        proj_dim=cfg.get(\"proj_dim\", 256),\n    )\n    model = TOLBERT(model_cfg)\n    state = torch.load(checkpoint, map_location=\"cpu\")\n    model.load_state_dict(state)\n    model.to(device)\n    model.eval()\n    return model\n\n\ndef encode_spans_tolbert(\n    model: TOLBERT,\n    tokenizer,\n    spans_file: str,\n    max_length: int,\n    device: torch.device,\n) -> Tuple[torch.Tensor, List[Dict[str, Any]]]:\n    \"\"\"\n    Encode all spans in `spans_file` into TOLBERT embeddings (proj head) and\n    return (emb_mat, raw_records).\n\n    This mirrors the logic in scripts/retrieval_sandbox.py but returns the full\n    embedding matrix for evaluation purposes.\n    \"\"\"\n    dataset = TreeOfLifeDataset(\n        spans_file=spans_file,\n        tokenizer=tokenizer,\n        max_length=max_length,","source_hash":"0618a8d31a4435c8ec1cfe19fb3dee05f16a905b73db22e3a3ea623292149c00","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.eval_retrieval.encode_spans_tolbert","uri":"program://TOLBERT/function/scripts.eval_retrieval.encode_spans_tolbert#L57-L97","kind":"function","name":"encode_spans_tolbert","path":"scripts/eval_retrieval.py","language":"python","start_line":57,"end_line":97,"context_start_line":37,"context_end_line":117,"code":"\nfrom tolbert.config import load_tolbert_config\nfrom tolbert.data import TreeOfLifeDataset\nfrom tolbert.modeling import TOLBERT, TOLBERTConfig\n\n\ndef build_tolbert_model(cfg: Dict[str, Any], checkpoint: str, device: torch.device) -> TOLBERT:\n    model_cfg = TOLBERTConfig(\n        base_model_name=cfg[\"base_model_name\"],\n        level_sizes=cfg[\"level_sizes\"],\n        proj_dim=cfg.get(\"proj_dim\", 256),\n    )\n    model = TOLBERT(model_cfg)\n    state = torch.load(checkpoint, map_location=\"cpu\")\n    model.load_state_dict(state)\n    model.to(device)\n    model.eval()\n    return model\n\n\ndef encode_spans_tolbert(\n    model: TOLBERT,\n    tokenizer,\n    spans_file: str,\n    max_length: int,\n    device: torch.device,\n) -> Tuple[torch.Tensor, List[Dict[str, Any]]]:\n    \"\"\"\n    Encode all spans in `spans_file` into TOLBERT embeddings (proj head) and\n    return (emb_mat, raw_records).\n\n    This mirrors the logic in scripts/retrieval_sandbox.py but returns the full\n    embedding matrix for evaluation purposes.\n    \"\"\"\n    dataset = TreeOfLifeDataset(\n        spans_file=spans_file,\n        tokenizer=tokenizer,\n        max_length=max_length,\n    )\n\n    embs: List[torch.Tensor] = []\n    metas: List[Dict[str, Any]] = []\n\n    for rec in dataset._records:  # type: ignore[attr-defined]\n        tokens = tokenizer(\n            rec.text,\n            return_tensors=\"pt\",\n            truncation=True,\n            padding=\"max_length\",\n            max_length=max_length,\n        )\n        input_ids = tokens[\"input_ids\"].to(device)\n        attention_mask = tokens[\"attention_mask\"].to(device)\n        with torch.no_grad():\n            out = model(input_ids=input_ids, attention_mask=attention_mask)\n        embs.append(out[\"proj\"].squeeze(0).cpu())\n        metas.append(rec.raw)\n\n    if not embs:\n        return torch.empty(0), metas\n    return torch.stack(embs, dim=0), metas\n\n\ndef encode_spans_hf_encoder(\n    model: AutoModel,\n    tokenizer,\n    spans_file: str,\n    max_length: int,\n    device: torch.device,\n) -> Tuple[torch.Tensor, List[Dict[str, Any]]]:\n    \"\"\"\n    Encode all spans using a vanilla HF encoder (e.g., BERT / CodeBERT /\n    ModernBERT) and return CLS embeddings.\n\n    This is used for baseline retrieval comparisons where we do not have\n    TOLBERT's projection head and simply use the encoder's [CLS] representation.\n    \"\"\"\n    dataset = TreeOfLifeDataset(\n        spans_file=spans_file,\n        tokenizer=tokenizer,\n        max_length=max_length,","source_hash":"0618a8d31a4435c8ec1cfe19fb3dee05f16a905b73db22e3a3ea623292149c00","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.eval_retrieval.encode_spans_hf_encoder","uri":"program://TOLBERT/function/scripts.eval_retrieval.encode_spans_hf_encoder#L100-L142","kind":"function","name":"encode_spans_hf_encoder","path":"scripts/eval_retrieval.py","language":"python","start_line":100,"end_line":142,"context_start_line":80,"context_end_line":162,"code":"    for rec in dataset._records:  # type: ignore[attr-defined]\n        tokens = tokenizer(\n            rec.text,\n            return_tensors=\"pt\",\n            truncation=True,\n            padding=\"max_length\",\n            max_length=max_length,\n        )\n        input_ids = tokens[\"input_ids\"].to(device)\n        attention_mask = tokens[\"attention_mask\"].to(device)\n        with torch.no_grad():\n            out = model(input_ids=input_ids, attention_mask=attention_mask)\n        embs.append(out[\"proj\"].squeeze(0).cpu())\n        metas.append(rec.raw)\n\n    if not embs:\n        return torch.empty(0), metas\n    return torch.stack(embs, dim=0), metas\n\n\ndef encode_spans_hf_encoder(\n    model: AutoModel,\n    tokenizer,\n    spans_file: str,\n    max_length: int,\n    device: torch.device,\n) -> Tuple[torch.Tensor, List[Dict[str, Any]]]:\n    \"\"\"\n    Encode all spans using a vanilla HF encoder (e.g., BERT / CodeBERT /\n    ModernBERT) and return CLS embeddings.\n\n    This is used for baseline retrieval comparisons where we do not have\n    TOLBERT's projection head and simply use the encoder's [CLS] representation.\n    \"\"\"\n    dataset = TreeOfLifeDataset(\n        spans_file=spans_file,\n        tokenizer=tokenizer,\n        max_length=max_length,\n    )\n\n    embs: List[torch.Tensor] = []\n    metas: List[Dict[str, Any]] = []\n\n    for rec in dataset._records:  # type: ignore[attr-defined]\n        tokens = tokenizer(\n            rec.text,\n            return_tensors=\"pt\",\n            truncation=True,\n            padding=\"max_length\",\n            max_length=max_length,\n        )\n        input_ids = tokens[\"input_ids\"].to(device)\n        attention_mask = tokens[\"attention_mask\"].to(device)\n        with torch.no_grad():\n            out = model(input_ids=input_ids, attention_mask=attention_mask)\n        # Standard HF encoder output: last_hidden_state[:, 0, :] is [CLS]\n        cls = out.last_hidden_state[:, 0, :]\n        embs.append(cls.squeeze(0).cpu())\n        metas.append(rec.raw)\n\n    if not embs:\n        return torch.empty(0), metas\n    return torch.stack(embs, dim=0), metas\n\n\ndef compute_relevance_mask(\n    query_paths: Sequence[Sequence[int]],\n    index_paths: Sequence[Sequence[int]],\n    min_level: int,\n) -> List[List[bool]]:\n    \"\"\"\n    Build a boolean matrix R where R[i][j] is True if query i and index j\n    share at least one node at depth >= min_level in their node_path.\n\n    Paths are lists of node ids [root, c1, c2, ...].\n    \"\"\"\n    rel: List[List[bool]] = []\n    for q_path in query_paths:\n        row: List[bool] = []\n        for idx_path in index_paths:\n            # shared depth = deepest k where q_path[k] == idx_path[k]\n            shared = False\n            max_shared_level = min(len(q_path), len(idx_path)) - 1","source_hash":"0618a8d31a4435c8ec1cfe19fb3dee05f16a905b73db22e3a3ea623292149c00","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.eval_retrieval.compute_relevance_mask","uri":"program://TOLBERT/function/scripts.eval_retrieval.compute_relevance_mask#L145-L169","kind":"function","name":"compute_relevance_mask","path":"scripts/eval_retrieval.py","language":"python","start_line":145,"end_line":169,"context_start_line":125,"context_end_line":189,"code":"            rec.text,\n            return_tensors=\"pt\",\n            truncation=True,\n            padding=\"max_length\",\n            max_length=max_length,\n        )\n        input_ids = tokens[\"input_ids\"].to(device)\n        attention_mask = tokens[\"attention_mask\"].to(device)\n        with torch.no_grad():\n            out = model(input_ids=input_ids, attention_mask=attention_mask)\n        # Standard HF encoder output: last_hidden_state[:, 0, :] is [CLS]\n        cls = out.last_hidden_state[:, 0, :]\n        embs.append(cls.squeeze(0).cpu())\n        metas.append(rec.raw)\n\n    if not embs:\n        return torch.empty(0), metas\n    return torch.stack(embs, dim=0), metas\n\n\ndef compute_relevance_mask(\n    query_paths: Sequence[Sequence[int]],\n    index_paths: Sequence[Sequence[int]],\n    min_level: int,\n) -> List[List[bool]]:\n    \"\"\"\n    Build a boolean matrix R where R[i][j] is True if query i and index j\n    share at least one node at depth >= min_level in their node_path.\n\n    Paths are lists of node ids [root, c1, c2, ...].\n    \"\"\"\n    rel: List[List[bool]] = []\n    for q_path in query_paths:\n        row: List[bool] = []\n        for idx_path in index_paths:\n            # shared depth = deepest k where q_path[k] == idx_path[k]\n            shared = False\n            max_shared_level = min(len(q_path), len(idx_path)) - 1\n            for lvl in range(min_level, max_shared_level + 1):\n                if q_path[lvl] == idx_path[lvl]:\n                    shared = True\n                    break\n            row.append(shared)\n        rel.append(row)\n    return rel\n\n\ndef eval_retrieval(\n    query_embs: torch.Tensor,\n    index_embs: torch.Tensor,\n    relevant: List[List[bool]],\n    k: int,\n) -> Tuple[float, float]:\n    \"\"\"\n    Compute MRR and Precision@k given:\n      - query_embs: (Q, D)\n      - index_embs: (N, D)\n      - relevant:   QxN boolean matrix (relevance marks)\n    \"\"\"\n    if query_embs.numel() == 0 or index_embs.numel() == 0:\n        return 0.0, 0.0\n\n    # Normalize embeddings for cosine similarity\n    query_embs = F.normalize(query_embs, dim=-1)\n    index_embs = F.normalize(index_embs, dim=-1)","source_hash":"0618a8d31a4435c8ec1cfe19fb3dee05f16a905b73db22e3a3ea623292149c00","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.eval_retrieval.eval_retrieval","uri":"program://TOLBERT/function/scripts.eval_retrieval.eval_retrieval#L172-L228","kind":"function","name":"eval_retrieval","path":"scripts/eval_retrieval.py","language":"python","start_line":172,"end_line":228,"context_start_line":152,"context_end_line":248,"code":"    share at least one node at depth >= min_level in their node_path.\n\n    Paths are lists of node ids [root, c1, c2, ...].\n    \"\"\"\n    rel: List[List[bool]] = []\n    for q_path in query_paths:\n        row: List[bool] = []\n        for idx_path in index_paths:\n            # shared depth = deepest k where q_path[k] == idx_path[k]\n            shared = False\n            max_shared_level = min(len(q_path), len(idx_path)) - 1\n            for lvl in range(min_level, max_shared_level + 1):\n                if q_path[lvl] == idx_path[lvl]:\n                    shared = True\n                    break\n            row.append(shared)\n        rel.append(row)\n    return rel\n\n\ndef eval_retrieval(\n    query_embs: torch.Tensor,\n    index_embs: torch.Tensor,\n    relevant: List[List[bool]],\n    k: int,\n) -> Tuple[float, float]:\n    \"\"\"\n    Compute MRR and Precision@k given:\n      - query_embs: (Q, D)\n      - index_embs: (N, D)\n      - relevant:   QxN boolean matrix (relevance marks)\n    \"\"\"\n    if query_embs.numel() == 0 or index_embs.numel() == 0:\n        return 0.0, 0.0\n\n    # Normalize embeddings for cosine similarity\n    query_embs = F.normalize(query_embs, dim=-1)\n    index_embs = F.normalize(index_embs, dim=-1)\n\n    # Similarity matrix (Q, N)\n    sims = torch.matmul(query_embs, index_embs.T)\n\n    Q, N = sims.shape\n    k = min(k, N)\n\n    mrr = 0.0\n    prec_at_k = 0.0\n\n    for i in range(Q):\n        rel_row = relevant[i]\n        if not any(rel_row):\n            continue  # skip queries with no relevant items\n\n        scores = sims[i]\n        topk_vals, topk_idx = torch.topk(scores, k=k)\n        topk_idx_list = topk_idx.tolist()\n\n        # MRR: find rank of first relevant\n        rr = 0.0\n        for rank, j in enumerate(topk_idx_list, start=1):\n            if rel_row[j]:\n                rr = 1.0 / rank\n                break\n        mrr += rr\n\n        # Precision@k: fraction of top-k that are relevant\n        num_rel_in_topk = sum(1 for j in topk_idx_list if rel_row[j])\n        prec_at_k += num_rel_in_topk / float(k)\n\n    # Normalize by number of queries that had at least one relevant item.\n    num_queries_with_rel = sum(1 for row in relevant if any(row))\n    if num_queries_with_rel == 0:\n        return 0.0, 0.0\n\n    mrr /= num_queries_with_rel\n    prec_at_k /= num_queries_with_rel\n    return mrr, prec_at_k\n\n\ndef compute_branch_consistency_at_k(\n    query_embs: torch.Tensor,\n    index_embs: torch.Tensor,\n    query_paths: Sequence[Sequence[int]],\n    index_paths: Sequence[Sequence[int]],\n    k: int,\n) -> Dict[int, float]:\n    \"\"\"\n    Compute branch-consistency@k per hierarchy depth.\n\n    For each query and each depth level ℓ (index in node_path, 0=root),\n    we measure the fraction of the top-k retrieved items whose node_path\n    matches the query's node at depth ℓ. Results are averaged over all\n    queries that have a node defined at that depth.\n    \"\"\"\n    if query_embs.numel() == 0 or index_embs.numel() == 0:\n        return {}\n","source_hash":"0618a8d31a4435c8ec1cfe19fb3dee05f16a905b73db22e3a3ea623292149c00","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.eval_retrieval.compute_branch_consistency_at_k","uri":"program://TOLBERT/function/scripts.eval_retrieval.compute_branch_consistency_at_k#L231-L304","kind":"function","name":"compute_branch_consistency_at_k","path":"scripts/eval_retrieval.py","language":"python","start_line":231,"end_line":304,"context_start_line":211,"context_end_line":324,"code":"        for rank, j in enumerate(topk_idx_list, start=1):\n            if rel_row[j]:\n                rr = 1.0 / rank\n                break\n        mrr += rr\n\n        # Precision@k: fraction of top-k that are relevant\n        num_rel_in_topk = sum(1 for j in topk_idx_list if rel_row[j])\n        prec_at_k += num_rel_in_topk / float(k)\n\n    # Normalize by number of queries that had at least one relevant item.\n    num_queries_with_rel = sum(1 for row in relevant if any(row))\n    if num_queries_with_rel == 0:\n        return 0.0, 0.0\n\n    mrr /= num_queries_with_rel\n    prec_at_k /= num_queries_with_rel\n    return mrr, prec_at_k\n\n\ndef compute_branch_consistency_at_k(\n    query_embs: torch.Tensor,\n    index_embs: torch.Tensor,\n    query_paths: Sequence[Sequence[int]],\n    index_paths: Sequence[Sequence[int]],\n    k: int,\n) -> Dict[int, float]:\n    \"\"\"\n    Compute branch-consistency@k per hierarchy depth.\n\n    For each query and each depth level ℓ (index in node_path, 0=root),\n    we measure the fraction of the top-k retrieved items whose node_path\n    matches the query's node at depth ℓ. Results are averaged over all\n    queries that have a node defined at that depth.\n    \"\"\"\n    if query_embs.numel() == 0 or index_embs.numel() == 0:\n        return {}\n\n    # Normalize embeddings for cosine similarity\n    query_embs = F.normalize(query_embs, dim=-1)\n    index_embs = F.normalize(index_embs, dim=-1)\n\n    sims = torch.matmul(query_embs, index_embs.T)  # (Q, N)\n    Q, N = sims.shape\n    k = min(k, N)\n\n    # Determine maximum depth observed across all paths (0-based index).\n    max_depth = 0\n    for p in list(query_paths) + list(index_paths):\n        if p:\n            max_depth = max(max_depth, len(p) - 1)\n\n    # Accumulators: depth -> (sum_fraction, num_queries_with_node)\n    num_levels = max_depth + 1\n    sum_frac: List[float] = [0.0 for _ in range(num_levels)]\n    count_q: List[int] = [0 for _ in range(num_levels)]\n\n    for qi in range(Q):\n        q_path = list(query_paths[qi]) if qi < len(query_paths) else []\n        if not q_path:\n            continue\n\n        scores = sims[qi]\n        topk_vals, topk_idx = torch.topk(scores, k=k)\n        topk_indices = topk_idx.tolist()\n\n        for depth in range(1, num_levels):  # skip depth 0 (root) by default\n            if len(q_path) <= depth:\n                continue\n            q_node = q_path[depth]\n            # Count how many of the top-k share the same node at this depth.\n            matches = 0\n            valid_cands = 0\n            for j in topk_indices:\n                if j >= len(index_paths):\n                    continue\n                idx_path = list(index_paths[j])\n                if len(idx_path) <= depth:\n                    continue\n                valid_cands += 1\n                if idx_path[depth] == q_node:\n                    matches += 1\n            if valid_cands == 0:\n                continue\n            frac = matches / float(valid_cands)\n            sum_frac[depth] += frac\n            count_q[depth] += 1\n\n    consistency: Dict[int, float] = {}\n    for depth in range(1, num_levels):\n        if count_q[depth] == 0:\n            continue\n        consistency[depth] = sum_frac[depth] / float(count_q[depth])\n    return consistency\n\n\ndef parse_args() -> argparse.Namespace:\n    ap = argparse.ArgumentParser(description=\"Evaluate retrieval (MRR, Precision@K, branch consistency).\")\n    ap.add_argument(\"--config\", type=str, required=True, help=\"Training config used for the model.\")\n    ap.add_argument(\n        \"--checkpoint\",\n        type=str,\n        required=True,\n        help=(\n            \"For mode=tolbert: path to .pt checkpoint (state_dict). \"\n            \"For mode=hf_encoder: HF model name or directory to load via AutoModel.\"\n        ),\n    )\n    ap.add_argument(\n        \"--index-spans\",\n        type=str,\n        required=True,\n        help=\"Spans JSONL file used as the retrieval index (e.g., code).\",\n    )","source_hash":"0618a8d31a4435c8ec1cfe19fb3dee05f16a905b73db22e3a3ea623292149c00","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.eval_retrieval.parse_args","uri":"program://TOLBERT/function/scripts.eval_retrieval.parse_args#L307-L360","kind":"function","name":"parse_args","path":"scripts/eval_retrieval.py","language":"python","start_line":307,"end_line":360,"context_start_line":287,"context_end_line":380,"code":"                idx_path = list(index_paths[j])\n                if len(idx_path) <= depth:\n                    continue\n                valid_cands += 1\n                if idx_path[depth] == q_node:\n                    matches += 1\n            if valid_cands == 0:\n                continue\n            frac = matches / float(valid_cands)\n            sum_frac[depth] += frac\n            count_q[depth] += 1\n\n    consistency: Dict[int, float] = {}\n    for depth in range(1, num_levels):\n        if count_q[depth] == 0:\n            continue\n        consistency[depth] = sum_frac[depth] / float(count_q[depth])\n    return consistency\n\n\ndef parse_args() -> argparse.Namespace:\n    ap = argparse.ArgumentParser(description=\"Evaluate retrieval (MRR, Precision@K, branch consistency).\")\n    ap.add_argument(\"--config\", type=str, required=True, help=\"Training config used for the model.\")\n    ap.add_argument(\n        \"--checkpoint\",\n        type=str,\n        required=True,\n        help=(\n            \"For mode=tolbert: path to .pt checkpoint (state_dict). \"\n            \"For mode=hf_encoder: HF model name or directory to load via AutoModel.\"\n        ),\n    )\n    ap.add_argument(\n        \"--index-spans\",\n        type=str,\n        required=True,\n        help=\"Spans JSONL file used as the retrieval index (e.g., code).\",\n    )\n    ap.add_argument(\n        \"--query-spans\",\n        type=str,\n        required=True,\n        help=\"Spans JSONL file used as queries (e.g., papers).\",\n    )\n    ap.add_argument(\n        \"--relevant-min-level\",\n        type=int,\n        default=2,\n        help=\"Minimum level depth (in node_path) that must match to count as relevant.\",\n    )\n    ap.add_argument(\n        \"--k\",\n        type=int,\n        default=5,\n        help=\"Top-k for Precision@K and MRR computation (default: 5).\",\n    )\n    ap.add_argument(\n        \"--device\",\n        type=str,\n        default=\"cuda\" if torch.cuda.is_available() else \"cpu\",\n        help=\"Device to use.\",\n    )\n    ap.add_argument(\n        \"--mode\",\n        type=str,\n        default=\"tolbert\",\n        choices=[\"tolbert\", \"hf_encoder\"],\n        help=(\n            \"Embedding backend: 'tolbert' (default, uses TOLBERT proj head) \"\n            \"or 'hf_encoder' (vanilla HF encoder CLS for baselines like BERT, \"\n            \"SciBERT, CodeBERT, ModernBERT).\"\n        ),\n    )\n    return ap.parse_args()\n\n\ndef main() -> None:\n    args = parse_args()\n    cfg = load_tolbert_config(args.config)\n    device = torch.device(args.device)\n\n    index_spans_path = Path(args.index_spans)\n    query_spans_path = Path(args.query_spans)\n    if not index_spans_path.exists():\n        raise FileNotFoundError(f\"index_spans not found: {index_spans_path}\")\n    if not query_spans_path.exists():\n        raise FileNotFoundError(f\"query_spans not found: {query_spans_path}\")\n\n    tokenizer = AutoTokenizer.from_pretrained(\n        cfg[\"base_model_name\"] if args.mode == \"tolbert\" else args.checkpoint,\n        cache_dir=\"/data/checkpoints/\",  # noqa: E501\n    )\n\n    if args.mode == \"tolbert\":","source_hash":"0618a8d31a4435c8ec1cfe19fb3dee05f16a905b73db22e3a3ea623292149c00","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.eval_retrieval.main","uri":"program://TOLBERT/function/scripts.eval_retrieval.main#L363-L448","kind":"function","name":"main","path":"scripts/eval_retrieval.py","language":"python","start_line":363,"end_line":448,"context_start_line":343,"context_end_line":454,"code":"    ap.add_argument(\n        \"--device\",\n        type=str,\n        default=\"cuda\" if torch.cuda.is_available() else \"cpu\",\n        help=\"Device to use.\",\n    )\n    ap.add_argument(\n        \"--mode\",\n        type=str,\n        default=\"tolbert\",\n        choices=[\"tolbert\", \"hf_encoder\"],\n        help=(\n            \"Embedding backend: 'tolbert' (default, uses TOLBERT proj head) \"\n            \"or 'hf_encoder' (vanilla HF encoder CLS for baselines like BERT, \"\n            \"SciBERT, CodeBERT, ModernBERT).\"\n        ),\n    )\n    return ap.parse_args()\n\n\ndef main() -> None:\n    args = parse_args()\n    cfg = load_tolbert_config(args.config)\n    device = torch.device(args.device)\n\n    index_spans_path = Path(args.index_spans)\n    query_spans_path = Path(args.query_spans)\n    if not index_spans_path.exists():\n        raise FileNotFoundError(f\"index_spans not found: {index_spans_path}\")\n    if not query_spans_path.exists():\n        raise FileNotFoundError(f\"query_spans not found: {query_spans_path}\")\n\n    tokenizer = AutoTokenizer.from_pretrained(\n        cfg[\"base_model_name\"] if args.mode == \"tolbert\" else args.checkpoint,\n        cache_dir=\"/data/checkpoints/\",  # noqa: E501\n    )\n\n    if args.mode == \"tolbert\":\n        model = build_tolbert_model(cfg, checkpoint=args.checkpoint, device=device)\n        encode_fn = encode_spans_tolbert\n    else:\n        # Vanilla HF encoder baseline (BERT, SciBERT, CodeBERT, ModernBERT, etc.)\n        model = AutoModel.from_pretrained(\n            args.checkpoint,\n            cache_dir=\"/data/checkpoints/\",  # noqa: E501\n        )\n        model.to(device)\n        model.eval()\n        encode_fn = encode_spans_hf_encoder\n\n    print(f\"Encoding index spans from {index_spans_path} ...\")\n    index_embs, index_metas = encode_fn(\n        model=model,\n        tokenizer=tokenizer,\n        spans_file=str(index_spans_path),\n        max_length=cfg.get(\"max_length\", 256),\n        device=device,\n    )\n\n    print(f\"Encoding query spans from {query_spans_path} ...\")\n    query_embs, query_metas = encode_fn(\n        model=model,\n        tokenizer=tokenizer,\n        spans_file=str(query_spans_path),\n        max_length=cfg.get(\"max_length\", 256),\n        device=device,\n    )\n\n    # Extract node_path lists from metas.\n    index_paths: List[Sequence[int]] = [\n        rec.get(\"node_path\", []) for rec in index_metas  # type: ignore[assignment]\n    ]\n    query_paths: List[Sequence[int]] = [\n        rec.get(\"node_path\", []) for rec in query_metas  # type: ignore[assignment]\n    ]\n\n    relevant = compute_relevance_mask(\n        query_paths=query_paths,\n        index_paths=index_paths,\n        min_level=args.relevant_min_level,\n    )\n\n    mrr, p_at_k = eval_retrieval(\n        query_embs=query_embs,\n        index_embs=index_embs,\n        relevant=relevant,\n        k=args.k,\n    )\n\n    print(\"=== Retrieval Evaluation ===\")\n    print(f\"MRR:        {mrr:.4f}\")\n    print(f\"Precision@{args.k}: {p_at_k:.4f}\")\n\n    # Ontology-aware metric: branch-consistency@k per depth level.\n    branch_consistency = compute_branch_consistency_at_k(\n        query_embs=query_embs,\n        index_embs=index_embs,\n        query_paths=query_paths,\n        index_paths=index_paths,\n        k=args.k,\n    )\n    if branch_consistency:\n        print(\"\\nBranch-consistency@{k} by depth (node_path index):\".format(k=args.k))\n        for depth in sorted(branch_consistency.keys()):\n            # depth 0 is the root; depths >=1 correspond to actual hierarchy levels.\n            print(f\"  depth {depth}: {branch_consistency[depth]:.4f}\")\n\n\nif __name__ == \"__main__\":\n    main()\n\n","source_hash":"0618a8d31a4435c8ec1cfe19fb3dee05f16a905b73db22e3a3ea623292149c00","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.train_flat_baseline","uri":"program://TOLBERT/module/scripts.train_flat_baseline#L1-L247","kind":"module","name":"scripts.train_flat_baseline","path":"scripts/train_flat_baseline.py","language":"python","start_line":1,"end_line":247,"context_start_line":1,"context_end_line":247,"code":"\"\"\"\nTrain a flat (leaf-level) baseline classifier on spans_file.\n\nThis script is intended to reproduce the \"BERT-flat\" style baselines from\nSection 4 using standard HuggingFace models (e.g. BERT, SciBERT, CodeBERT,\nModernBERT) on the same JSONL spans files used for TOLBERT.\n\nKey characteristics:\n  - Single-label, flat classification on the *leaf* node of each path\n    (last element of `node_path`).\n  - Uses AutoModelForSequenceClassification with a single softmax head.\n  - Ignores intermediate hierarchy levels entirely.\n\nExample (CodeHierarchy, BERT-base flat):\n\n  python -m scripts.train_flat_baseline \\\\\n      --config configs/codehierarchy_example.yaml \\\\\n      --output-dir checkpoints/codehierarchy_bert_flat \\\\\n      --base-model-name bert-base-uncased\n\nExample (WOS, SciBERT flat):\n\n  python -m scripts.train_flat_baseline \\\\\n      --config configs/wos_example.yaml \\\\\n      --output-dir checkpoints/wos_scibert_flat \\\\\n      --base-model-name allenai/scibert_scivocab_uncased\n\nExample (CodeHierarchy, CodeBERT flat):\n\n  python -m scripts.train_flat_baseline \\\\\n      --config configs/codehierarchy_example.yaml \\\\\n      --output-dir checkpoints/codehierarchy_codebert_flat \\\\\n      --base-model-name microsoft/codebert-base\n\nExample (mixed-domain, ModernBERT flat):\n\n  python -m scripts.train_flat_baseline \\\\\n      --config configs/codehierarchy_example.yaml \\\\\n      --output-dir checkpoints/codehierarchy_modernbert_flat \\\\\n      --base-model-name answerdotai/ModernBERT-base\n\"\"\"\n\nfrom __future__ import annotations\n\nimport argparse\nimport json\nfrom pathlib import Path\nfrom typing import Any, Dict, List\n\nimport torch\nfrom torch.utils.data import DataLoader, Dataset\nfrom transformers import (\n    AutoModelForSequenceClassification,\n    AutoTokenizer,\n    PreTrainedTokenizerBase,\n)\nimport os\n\nfrom tolbert.config import load_tolbert_config\n\n\nclass FlatLeafDataset(Dataset):\n    \"\"\"\n    Minimal dataset for flat (leaf-level) classification.\n\n    Expects the same JSONL format as TreeOfLifeDataset, but uses only:\n      - \"text\": span text\n      - \"node_path\": [root_id, ..., leaf_id]\n\n    The label is taken to be the *last* element of node_path (leaf).\n    \"\"\"\n\n    def __init__(\n        self,\n        spans_file: str,\n        tokenizer: PreTrainedTokenizerBase,\n        max_length: int = 256,\n    ) -> None:\n        self.spans_file = spans_file\n        self.tokenizer = tokenizer\n        self.max_length = max_length\n\n        self._records: List[Dict[str, Any]] = []\n        with open(spans_file, \"r\", encoding=\"utf-8\") as f:\n            for line in f:\n                line = line.strip()\n                if not line:\n                    continue\n                obj = json.loads(line)\n                if \"text\" not in obj or \"node_path\" not in obj:\n                    # Skip spans that do not have both text and a path.\n                    continue\n                if not obj[\"node_path\"]:\n                    continue\n                self._records.append(obj)\n\n    def __len__(self) -> int:\n        return len(self._records)\n\n    def _tokenize(self, text: str) -> Dict[str, torch.Tensor]:\n        enc = self.tokenizer(\n            text,\n            return_tensors=\"pt\",\n            truncation=True,\n            padding=\"max_length\",\n            max_length=self.max_length,\n        )\n        return {k: v.squeeze(0) for k, v in enc.items()}\n\n    def __getitem__(self, idx: int) -> Dict[str, Any]:\n        rec = self._records[idx]\n        tokens = self._tokenize(rec[\"text\"])\n        input_ids = tokens[\"input_ids\"]\n        attention_mask = tokens.get(\"attention_mask\", torch.ones_like(input_ids))\n        # Leaf = last element of node_path\n        node_path: List[int] = rec[\"node_path\"]\n        label = int(node_path[-1])\n        return {\n            \"input_ids\": input_ids,\n            \"attention_mask\": attention_mask,\n            \"labels\": torch.tensor(label, dtype=torch.long),\n        }\n\n\ndef collate_flat_batch(batch: List[Dict[str, Any]]) -> Dict[str, Any]:\n    input_ids = torch.stack([b[\"input_ids\"] for b in batch], dim=0)\n    attention_mask = torch.stack([b[\"attention_mask\"] for b in batch], dim=0)\n    labels = torch.stack([b[\"labels\"] for b in batch], dim=0)\n    return {\n        \"input_ids\": input_ids,\n        \"attention_mask\": attention_mask,\n        \"labels\": labels,\n    }\n\n\ndef parse_args() -> argparse.Namespace:\n    ap = argparse.ArgumentParser(description=\"Train a flat (leaf-level) baseline classifier.\")\n    ap.add_argument(\n        \"--config\",\n        type=str,\n        required=True,\n        help=\"YAML/JSON config with at least spans_file, level_sizes, batch_size, num_epochs, lr.\",\n    )\n    ap.add_argument(\n        \"--output-dir\",\n        type=str,\n        required=True,\n        help=\"Directory to save the fine-tuned baseline model (HF save_pretrained format).\",\n    )\n    ap.add_argument(\n        \"--base-model-name\",\n        type=str,\n        required=True,\n        help=(\n            \"HF model name or path for the baseline backbone \"\n            \"(e.g., bert-base-uncased, allenai/scibert_scivocab_uncased, \"\n            \"microsoft/codebert-base, answerdotai/ModernBERT-base).\"\n        ),\n    )\n    ap.add_argument(\n        \"--device\",\n        type=str,\n        default=\"cuda\" if torch.cuda.is_available() else \"cpu\",\n        help=\"Device to use (default: cuda if available, else cpu).\",\n    )\n    return ap.parse_args()\n\n\ndef main() -> None:\n    args = parse_args()\n    cfg = load_tolbert_config(args.config)\n\n    device = torch.device(args.device)\n\n    spans_file = cfg[\"spans_file\"]\n    if not Path(spans_file).exists():\n        raise FileNotFoundError(f\"spans_file not found: {spans_file}\")\n\n    # Determine number of leaf classes from level_sizes: leaf = max level index.\n    level_sizes: Dict[int, int] = cfg[\"level_sizes\"]\n    leaf_level = max(level_sizes.keys())\n    num_labels = level_sizes[leaf_level]\n\n    tokenizer = AutoTokenizer.from_pretrained(\n        args.base_model_name,\n        cache_dir=\"/data/checkpoints/\",  # noqa: E501\n    )\n    dataset = FlatLeafDataset(\n        spans_file=spans_file,\n        tokenizer=tokenizer,\n        max_length=cfg.get(\"max_length\", 256),\n    )\n\n    dataloader = DataLoader(\n        dataset,\n        batch_size=cfg.get(\"batch_size\", 64),\n        shuffle=True,\n        num_workers=cfg.get(\"num_workers\", 0),\n        collate_fn=collate_flat_batch,\n    )\n\n    model = AutoModelForSequenceClassification.from_pretrained(\n        args.base_model_name,\n        num_labels=num_labels,\n        cache_dir=\"/data/checkpoints/\",  # noqa: E501\n    )\n    model.to(device)\n    model.train()\n\n    optimizer = torch.optim.AdamW(model.parameters(), lr=cfg.get(\"lr\", 1e-4))\n    num_epochs = cfg.get(\"num_epochs\", 1)\n    log_every = cfg.get(\"log_every\", 50)\n\n    global_step = 0\n    for epoch in range(num_epochs):\n        for batch in dataloader:\n            global_step += 1\n            optimizer.zero_grad()\n\n            input_ids = batch[\"input_ids\"].to(device)\n            attention_mask = batch[\"attention_mask\"].to(device)\n            labels = batch[\"labels\"].to(device)\n\n            outputs = model(\n                input_ids=input_ids,\n                attention_mask=attention_mask,\n                labels=labels,\n            )\n            loss = outputs.loss\n            loss.backward()\n            torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=cfg.get(\"grad_clip\", 1.0))\n            optimizer.step()\n\n            if global_step % log_every == 0:\n                print(f\"[epoch {epoch+1} step {global_step}] loss={loss.item():.4f}\")\n\n    out_dir = Path(args.output_dir)\n    out_dir.mkdir(parents=True, exist_ok=True)\n    model.save_pretrained(out_dir)\n    tokenizer.save_pretrained(out_dir)\n    print(f\"Saved flat baseline model to {out_dir}\")\n\n\nif __name__ == \"__main__\":\n    main()\n\n","source_hash":"d6f993cb8736e408b149d004ed642cf41238027e2fdfa82112b52974dee32112","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.train_flat_baseline.FlatLeafDataset","uri":"program://TOLBERT/class/scripts.train_flat_baseline.FlatLeafDataset#L62-L122","kind":"class","name":"FlatLeafDataset","path":"scripts/train_flat_baseline.py","language":"python","start_line":62,"end_line":122,"context_start_line":42,"context_end_line":142,"code":"\nfrom __future__ import annotations\n\nimport argparse\nimport json\nfrom pathlib import Path\nfrom typing import Any, Dict, List\n\nimport torch\nfrom torch.utils.data import DataLoader, Dataset\nfrom transformers import (\n    AutoModelForSequenceClassification,\n    AutoTokenizer,\n    PreTrainedTokenizerBase,\n)\nimport os\n\nfrom tolbert.config import load_tolbert_config\n\n\nclass FlatLeafDataset(Dataset):\n    \"\"\"\n    Minimal dataset for flat (leaf-level) classification.\n\n    Expects the same JSONL format as TreeOfLifeDataset, but uses only:\n      - \"text\": span text\n      - \"node_path\": [root_id, ..., leaf_id]\n\n    The label is taken to be the *last* element of node_path (leaf).\n    \"\"\"\n\n    def __init__(\n        self,\n        spans_file: str,\n        tokenizer: PreTrainedTokenizerBase,\n        max_length: int = 256,\n    ) -> None:\n        self.spans_file = spans_file\n        self.tokenizer = tokenizer\n        self.max_length = max_length\n\n        self._records: List[Dict[str, Any]] = []\n        with open(spans_file, \"r\", encoding=\"utf-8\") as f:\n            for line in f:\n                line = line.strip()\n                if not line:\n                    continue\n                obj = json.loads(line)\n                if \"text\" not in obj or \"node_path\" not in obj:\n                    # Skip spans that do not have both text and a path.\n                    continue\n                if not obj[\"node_path\"]:\n                    continue\n                self._records.append(obj)\n\n    def __len__(self) -> int:\n        return len(self._records)\n\n    def _tokenize(self, text: str) -> Dict[str, torch.Tensor]:\n        enc = self.tokenizer(\n            text,\n            return_tensors=\"pt\",\n            truncation=True,\n            padding=\"max_length\",\n            max_length=self.max_length,\n        )\n        return {k: v.squeeze(0) for k, v in enc.items()}\n\n    def __getitem__(self, idx: int) -> Dict[str, Any]:\n        rec = self._records[idx]\n        tokens = self._tokenize(rec[\"text\"])\n        input_ids = tokens[\"input_ids\"]\n        attention_mask = tokens.get(\"attention_mask\", torch.ones_like(input_ids))\n        # Leaf = last element of node_path\n        node_path: List[int] = rec[\"node_path\"]\n        label = int(node_path[-1])\n        return {\n            \"input_ids\": input_ids,\n            \"attention_mask\": attention_mask,\n            \"labels\": torch.tensor(label, dtype=torch.long),\n        }\n\n\ndef collate_flat_batch(batch: List[Dict[str, Any]]) -> Dict[str, Any]:\n    input_ids = torch.stack([b[\"input_ids\"] for b in batch], dim=0)\n    attention_mask = torch.stack([b[\"attention_mask\"] for b in batch], dim=0)\n    labels = torch.stack([b[\"labels\"] for b in batch], dim=0)\n    return {\n        \"input_ids\": input_ids,\n        \"attention_mask\": attention_mask,\n        \"labels\": labels,\n    }\n\n\ndef parse_args() -> argparse.Namespace:\n    ap = argparse.ArgumentParser(description=\"Train a flat (leaf-level) baseline classifier.\")\n    ap.add_argument(\n        \"--config\",\n        type=str,\n        required=True,\n        help=\"YAML/JSON config with at least spans_file, level_sizes, batch_size, num_epochs, lr.\",","source_hash":"d6f993cb8736e408b149d004ed642cf41238027e2fdfa82112b52974dee32112","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.train_flat_baseline.collate_flat_batch","uri":"program://TOLBERT/function/scripts.train_flat_baseline.collate_flat_batch#L125-L133","kind":"function","name":"collate_flat_batch","path":"scripts/train_flat_baseline.py","language":"python","start_line":125,"end_line":133,"context_start_line":105,"context_end_line":153,"code":"            padding=\"max_length\",\n            max_length=self.max_length,\n        )\n        return {k: v.squeeze(0) for k, v in enc.items()}\n\n    def __getitem__(self, idx: int) -> Dict[str, Any]:\n        rec = self._records[idx]\n        tokens = self._tokenize(rec[\"text\"])\n        input_ids = tokens[\"input_ids\"]\n        attention_mask = tokens.get(\"attention_mask\", torch.ones_like(input_ids))\n        # Leaf = last element of node_path\n        node_path: List[int] = rec[\"node_path\"]\n        label = int(node_path[-1])\n        return {\n            \"input_ids\": input_ids,\n            \"attention_mask\": attention_mask,\n            \"labels\": torch.tensor(label, dtype=torch.long),\n        }\n\n\ndef collate_flat_batch(batch: List[Dict[str, Any]]) -> Dict[str, Any]:\n    input_ids = torch.stack([b[\"input_ids\"] for b in batch], dim=0)\n    attention_mask = torch.stack([b[\"attention_mask\"] for b in batch], dim=0)\n    labels = torch.stack([b[\"labels\"] for b in batch], dim=0)\n    return {\n        \"input_ids\": input_ids,\n        \"attention_mask\": attention_mask,\n        \"labels\": labels,\n    }\n\n\ndef parse_args() -> argparse.Namespace:\n    ap = argparse.ArgumentParser(description=\"Train a flat (leaf-level) baseline classifier.\")\n    ap.add_argument(\n        \"--config\",\n        type=str,\n        required=True,\n        help=\"YAML/JSON config with at least spans_file, level_sizes, batch_size, num_epochs, lr.\",\n    )\n    ap.add_argument(\n        \"--output-dir\",\n        type=str,\n        required=True,\n        help=\"Directory to save the fine-tuned baseline model (HF save_pretrained format).\",\n    )\n    ap.add_argument(\n        \"--base-model-name\",\n        type=str,\n        required=True,","source_hash":"d6f993cb8736e408b149d004ed642cf41238027e2fdfa82112b52974dee32112","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.train_flat_baseline.parse_args","uri":"program://TOLBERT/function/scripts.train_flat_baseline.parse_args#L136-L166","kind":"function","name":"parse_args","path":"scripts/train_flat_baseline.py","language":"python","start_line":136,"end_line":166,"context_start_line":116,"context_end_line":186,"code":"        node_path: List[int] = rec[\"node_path\"]\n        label = int(node_path[-1])\n        return {\n            \"input_ids\": input_ids,\n            \"attention_mask\": attention_mask,\n            \"labels\": torch.tensor(label, dtype=torch.long),\n        }\n\n\ndef collate_flat_batch(batch: List[Dict[str, Any]]) -> Dict[str, Any]:\n    input_ids = torch.stack([b[\"input_ids\"] for b in batch], dim=0)\n    attention_mask = torch.stack([b[\"attention_mask\"] for b in batch], dim=0)\n    labels = torch.stack([b[\"labels\"] for b in batch], dim=0)\n    return {\n        \"input_ids\": input_ids,\n        \"attention_mask\": attention_mask,\n        \"labels\": labels,\n    }\n\n\ndef parse_args() -> argparse.Namespace:\n    ap = argparse.ArgumentParser(description=\"Train a flat (leaf-level) baseline classifier.\")\n    ap.add_argument(\n        \"--config\",\n        type=str,\n        required=True,\n        help=\"YAML/JSON config with at least spans_file, level_sizes, batch_size, num_epochs, lr.\",\n    )\n    ap.add_argument(\n        \"--output-dir\",\n        type=str,\n        required=True,\n        help=\"Directory to save the fine-tuned baseline model (HF save_pretrained format).\",\n    )\n    ap.add_argument(\n        \"--base-model-name\",\n        type=str,\n        required=True,\n        help=(\n            \"HF model name or path for the baseline backbone \"\n            \"(e.g., bert-base-uncased, allenai/scibert_scivocab_uncased, \"\n            \"microsoft/codebert-base, answerdotai/ModernBERT-base).\"\n        ),\n    )\n    ap.add_argument(\n        \"--device\",\n        type=str,\n        default=\"cuda\" if torch.cuda.is_available() else \"cpu\",\n        help=\"Device to use (default: cuda if available, else cpu).\",\n    )\n    return ap.parse_args()\n\n\ndef main() -> None:\n    args = parse_args()\n    cfg = load_tolbert_config(args.config)\n\n    device = torch.device(args.device)\n\n    spans_file = cfg[\"spans_file\"]\n    if not Path(spans_file).exists():\n        raise FileNotFoundError(f\"spans_file not found: {spans_file}\")\n\n    # Determine number of leaf classes from level_sizes: leaf = max level index.\n    level_sizes: Dict[int, int] = cfg[\"level_sizes\"]\n    leaf_level = max(level_sizes.keys())\n    num_labels = level_sizes[leaf_level]\n\n    tokenizer = AutoTokenizer.from_pretrained(\n        args.base_model_name,\n        cache_dir=\"/data/checkpoints/\",  # noqa: E501","source_hash":"d6f993cb8736e408b149d004ed642cf41238027e2fdfa82112b52974dee32112","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.train_flat_baseline.main","uri":"program://TOLBERT/function/scripts.train_flat_baseline.main#L169-L241","kind":"function","name":"main","path":"scripts/train_flat_baseline.py","language":"python","start_line":169,"end_line":241,"context_start_line":149,"context_end_line":247,"code":"    )\n    ap.add_argument(\n        \"--base-model-name\",\n        type=str,\n        required=True,\n        help=(\n            \"HF model name or path for the baseline backbone \"\n            \"(e.g., bert-base-uncased, allenai/scibert_scivocab_uncased, \"\n            \"microsoft/codebert-base, answerdotai/ModernBERT-base).\"\n        ),\n    )\n    ap.add_argument(\n        \"--device\",\n        type=str,\n        default=\"cuda\" if torch.cuda.is_available() else \"cpu\",\n        help=\"Device to use (default: cuda if available, else cpu).\",\n    )\n    return ap.parse_args()\n\n\ndef main() -> None:\n    args = parse_args()\n    cfg = load_tolbert_config(args.config)\n\n    device = torch.device(args.device)\n\n    spans_file = cfg[\"spans_file\"]\n    if not Path(spans_file).exists():\n        raise FileNotFoundError(f\"spans_file not found: {spans_file}\")\n\n    # Determine number of leaf classes from level_sizes: leaf = max level index.\n    level_sizes: Dict[int, int] = cfg[\"level_sizes\"]\n    leaf_level = max(level_sizes.keys())\n    num_labels = level_sizes[leaf_level]\n\n    tokenizer = AutoTokenizer.from_pretrained(\n        args.base_model_name,\n        cache_dir=\"/data/checkpoints/\",  # noqa: E501\n    )\n    dataset = FlatLeafDataset(\n        spans_file=spans_file,\n        tokenizer=tokenizer,\n        max_length=cfg.get(\"max_length\", 256),\n    )\n\n    dataloader = DataLoader(\n        dataset,\n        batch_size=cfg.get(\"batch_size\", 64),\n        shuffle=True,\n        num_workers=cfg.get(\"num_workers\", 0),\n        collate_fn=collate_flat_batch,\n    )\n\n    model = AutoModelForSequenceClassification.from_pretrained(\n        args.base_model_name,\n        num_labels=num_labels,\n        cache_dir=\"/data/checkpoints/\",  # noqa: E501\n    )\n    model.to(device)\n    model.train()\n\n    optimizer = torch.optim.AdamW(model.parameters(), lr=cfg.get(\"lr\", 1e-4))\n    num_epochs = cfg.get(\"num_epochs\", 1)\n    log_every = cfg.get(\"log_every\", 50)\n\n    global_step = 0\n    for epoch in range(num_epochs):\n        for batch in dataloader:\n            global_step += 1\n            optimizer.zero_grad()\n\n            input_ids = batch[\"input_ids\"].to(device)\n            attention_mask = batch[\"attention_mask\"].to(device)\n            labels = batch[\"labels\"].to(device)\n\n            outputs = model(\n                input_ids=input_ids,\n                attention_mask=attention_mask,\n                labels=labels,\n            )\n            loss = outputs.loss\n            loss.backward()\n            torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=cfg.get(\"grad_clip\", 1.0))\n            optimizer.step()\n\n            if global_step % log_every == 0:\n                print(f\"[epoch {epoch+1} step {global_step}] loss={loss.item():.4f}\")\n\n    out_dir = Path(args.output_dir)\n    out_dir.mkdir(parents=True, exist_ok=True)\n    model.save_pretrained(out_dir)\n    tokenizer.save_pretrained(out_dir)\n    print(f\"Saved flat baseline model to {out_dir}\")\n\n\nif __name__ == \"__main__\":\n    main()\n\n","source_hash":"d6f993cb8736e408b149d004ed642cf41238027e2fdfa82112b52974dee32112","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.train_flat_baseline.__init__","uri":"program://TOLBERT/function/scripts.train_flat_baseline.__init__#L73-L95","kind":"function","name":"__init__","path":"scripts/train_flat_baseline.py","language":"python","start_line":73,"end_line":95,"context_start_line":53,"context_end_line":115,"code":"    AutoModelForSequenceClassification,\n    AutoTokenizer,\n    PreTrainedTokenizerBase,\n)\nimport os\n\nfrom tolbert.config import load_tolbert_config\n\n\nclass FlatLeafDataset(Dataset):\n    \"\"\"\n    Minimal dataset for flat (leaf-level) classification.\n\n    Expects the same JSONL format as TreeOfLifeDataset, but uses only:\n      - \"text\": span text\n      - \"node_path\": [root_id, ..., leaf_id]\n\n    The label is taken to be the *last* element of node_path (leaf).\n    \"\"\"\n\n    def __init__(\n        self,\n        spans_file: str,\n        tokenizer: PreTrainedTokenizerBase,\n        max_length: int = 256,\n    ) -> None:\n        self.spans_file = spans_file\n        self.tokenizer = tokenizer\n        self.max_length = max_length\n\n        self._records: List[Dict[str, Any]] = []\n        with open(spans_file, \"r\", encoding=\"utf-8\") as f:\n            for line in f:\n                line = line.strip()\n                if not line:\n                    continue\n                obj = json.loads(line)\n                if \"text\" not in obj or \"node_path\" not in obj:\n                    # Skip spans that do not have both text and a path.\n                    continue\n                if not obj[\"node_path\"]:\n                    continue\n                self._records.append(obj)\n\n    def __len__(self) -> int:\n        return len(self._records)\n\n    def _tokenize(self, text: str) -> Dict[str, torch.Tensor]:\n        enc = self.tokenizer(\n            text,\n            return_tensors=\"pt\",\n            truncation=True,\n            padding=\"max_length\",\n            max_length=self.max_length,\n        )\n        return {k: v.squeeze(0) for k, v in enc.items()}\n\n    def __getitem__(self, idx: int) -> Dict[str, Any]:\n        rec = self._records[idx]\n        tokens = self._tokenize(rec[\"text\"])\n        input_ids = tokens[\"input_ids\"]\n        attention_mask = tokens.get(\"attention_mask\", torch.ones_like(input_ids))\n        # Leaf = last element of node_path","source_hash":"d6f993cb8736e408b149d004ed642cf41238027e2fdfa82112b52974dee32112","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.train_flat_baseline.__len__","uri":"program://TOLBERT/function/scripts.train_flat_baseline.__len__#L97-L98","kind":"function","name":"__len__","path":"scripts/train_flat_baseline.py","language":"python","start_line":97,"end_line":98,"context_start_line":77,"context_end_line":118,"code":"        max_length: int = 256,\n    ) -> None:\n        self.spans_file = spans_file\n        self.tokenizer = tokenizer\n        self.max_length = max_length\n\n        self._records: List[Dict[str, Any]] = []\n        with open(spans_file, \"r\", encoding=\"utf-8\") as f:\n            for line in f:\n                line = line.strip()\n                if not line:\n                    continue\n                obj = json.loads(line)\n                if \"text\" not in obj or \"node_path\" not in obj:\n                    # Skip spans that do not have both text and a path.\n                    continue\n                if not obj[\"node_path\"]:\n                    continue\n                self._records.append(obj)\n\n    def __len__(self) -> int:\n        return len(self._records)\n\n    def _tokenize(self, text: str) -> Dict[str, torch.Tensor]:\n        enc = self.tokenizer(\n            text,\n            return_tensors=\"pt\",\n            truncation=True,\n            padding=\"max_length\",\n            max_length=self.max_length,\n        )\n        return {k: v.squeeze(0) for k, v in enc.items()}\n\n    def __getitem__(self, idx: int) -> Dict[str, Any]:\n        rec = self._records[idx]\n        tokens = self._tokenize(rec[\"text\"])\n        input_ids = tokens[\"input_ids\"]\n        attention_mask = tokens.get(\"attention_mask\", torch.ones_like(input_ids))\n        # Leaf = last element of node_path\n        node_path: List[int] = rec[\"node_path\"]\n        label = int(node_path[-1])\n        return {","source_hash":"d6f993cb8736e408b149d004ed642cf41238027e2fdfa82112b52974dee32112","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.train_flat_baseline._tokenize","uri":"program://TOLBERT/function/scripts.train_flat_baseline._tokenize#L100-L108","kind":"function","name":"_tokenize","path":"scripts/train_flat_baseline.py","language":"python","start_line":100,"end_line":108,"context_start_line":80,"context_end_line":128,"code":"        self.tokenizer = tokenizer\n        self.max_length = max_length\n\n        self._records: List[Dict[str, Any]] = []\n        with open(spans_file, \"r\", encoding=\"utf-8\") as f:\n            for line in f:\n                line = line.strip()\n                if not line:\n                    continue\n                obj = json.loads(line)\n                if \"text\" not in obj or \"node_path\" not in obj:\n                    # Skip spans that do not have both text and a path.\n                    continue\n                if not obj[\"node_path\"]:\n                    continue\n                self._records.append(obj)\n\n    def __len__(self) -> int:\n        return len(self._records)\n\n    def _tokenize(self, text: str) -> Dict[str, torch.Tensor]:\n        enc = self.tokenizer(\n            text,\n            return_tensors=\"pt\",\n            truncation=True,\n            padding=\"max_length\",\n            max_length=self.max_length,\n        )\n        return {k: v.squeeze(0) for k, v in enc.items()}\n\n    def __getitem__(self, idx: int) -> Dict[str, Any]:\n        rec = self._records[idx]\n        tokens = self._tokenize(rec[\"text\"])\n        input_ids = tokens[\"input_ids\"]\n        attention_mask = tokens.get(\"attention_mask\", torch.ones_like(input_ids))\n        # Leaf = last element of node_path\n        node_path: List[int] = rec[\"node_path\"]\n        label = int(node_path[-1])\n        return {\n            \"input_ids\": input_ids,\n            \"attention_mask\": attention_mask,\n            \"labels\": torch.tensor(label, dtype=torch.long),\n        }\n\n\ndef collate_flat_batch(batch: List[Dict[str, Any]]) -> Dict[str, Any]:\n    input_ids = torch.stack([b[\"input_ids\"] for b in batch], dim=0)\n    attention_mask = torch.stack([b[\"attention_mask\"] for b in batch], dim=0)\n    labels = torch.stack([b[\"labels\"] for b in batch], dim=0)","source_hash":"d6f993cb8736e408b149d004ed642cf41238027e2fdfa82112b52974dee32112","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.train_flat_baseline.__getitem__","uri":"program://TOLBERT/function/scripts.train_flat_baseline.__getitem__#L110-L122","kind":"function","name":"__getitem__","path":"scripts/train_flat_baseline.py","language":"python","start_line":110,"end_line":122,"context_start_line":90,"context_end_line":142,"code":"                if \"text\" not in obj or \"node_path\" not in obj:\n                    # Skip spans that do not have both text and a path.\n                    continue\n                if not obj[\"node_path\"]:\n                    continue\n                self._records.append(obj)\n\n    def __len__(self) -> int:\n        return len(self._records)\n\n    def _tokenize(self, text: str) -> Dict[str, torch.Tensor]:\n        enc = self.tokenizer(\n            text,\n            return_tensors=\"pt\",\n            truncation=True,\n            padding=\"max_length\",\n            max_length=self.max_length,\n        )\n        return {k: v.squeeze(0) for k, v in enc.items()}\n\n    def __getitem__(self, idx: int) -> Dict[str, Any]:\n        rec = self._records[idx]\n        tokens = self._tokenize(rec[\"text\"])\n        input_ids = tokens[\"input_ids\"]\n        attention_mask = tokens.get(\"attention_mask\", torch.ones_like(input_ids))\n        # Leaf = last element of node_path\n        node_path: List[int] = rec[\"node_path\"]\n        label = int(node_path[-1])\n        return {\n            \"input_ids\": input_ids,\n            \"attention_mask\": attention_mask,\n            \"labels\": torch.tensor(label, dtype=torch.long),\n        }\n\n\ndef collate_flat_batch(batch: List[Dict[str, Any]]) -> Dict[str, Any]:\n    input_ids = torch.stack([b[\"input_ids\"] for b in batch], dim=0)\n    attention_mask = torch.stack([b[\"attention_mask\"] for b in batch], dim=0)\n    labels = torch.stack([b[\"labels\"] for b in batch], dim=0)\n    return {\n        \"input_ids\": input_ids,\n        \"attention_mask\": attention_mask,\n        \"labels\": labels,\n    }\n\n\ndef parse_args() -> argparse.Namespace:\n    ap = argparse.ArgumentParser(description=\"Train a flat (leaf-level) baseline classifier.\")\n    ap.add_argument(\n        \"--config\",\n        type=str,\n        required=True,\n        help=\"YAML/JSON config with at least spans_file, level_sizes, batch_size, num_epochs, lr.\",","source_hash":"d6f993cb8736e408b149d004ed642cf41238027e2fdfa82112b52974dee32112","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.retrieval_sandbox","uri":"program://TOLBERT/module/scripts.retrieval_sandbox#L1-L188","kind":"module","name":"scripts.retrieval_sandbox","path":"scripts/retrieval_sandbox.py","language":"python","start_line":1,"end_line":188,"context_start_line":1,"context_end_line":188,"code":"\"\"\"\nSimple retrieval sandbox for TOLBERT.\n\nThis script:\n  - loads a trained TOLBERT checkpoint and tokenizer,\n  - encodes spans from a `spans_file`,\n  - builds an in-memory index of embeddings,\n  - lets you run ad-hoc queries over that index from the command line.\n\nIt is intended for small-scale experimentation and debugging, not production.\n\"\"\"\n\nimport argparse\nfrom pathlib import Path\nfrom typing import Any, Dict, List, Tuple\n\nimport torch\nfrom torch.nn import functional as F\nfrom transformers import AutoTokenizer\nimport os\n\nfrom tolbert.config import load_tolbert_config\nfrom tolbert.data import TreeOfLifeDataset\nfrom tolbert.modeling import TOLBERT, TOLBERTConfig\n\n\ndef build_model(cfg: Dict[str, Any], checkpoint: str, device: torch.device) -> TOLBERT:\n    model_cfg = TOLBERTConfig(\n        base_model_name=cfg[\"base_model_name\"],\n        level_sizes=cfg[\"level_sizes\"],\n        proj_dim=cfg.get(\"proj_dim\", 256),\n    )\n    model = TOLBERT(model_cfg)\n    state = torch.load(checkpoint, map_location=\"cpu\")\n    model.load_state_dict(state)\n    model.to(device)\n    model.eval()\n    return model\n\n\ndef encode_all_spans(\n    model: TOLBERT,\n    tokenizer,\n    spans_file: str,\n    max_length: int,\n    device: torch.device,\n) -> Tuple[torch.Tensor, List[Dict[str, Any]]]:\n    \"\"\"\n    Encode all spans in `spans_file` into a single tensor of embeddings,\n    plus a parallel list of raw records.\n    \"\"\"\n    dataset = TreeOfLifeDataset(\n        spans_file=spans_file,\n        tokenizer=tokenizer,\n        max_length=max_length,\n    )\n\n    embs: List[torch.Tensor] = []\n    metas: List[Dict[str, Any]] = []\n\n    for rec in dataset._records:  # type: ignore[attr-defined]\n        # Directly reuse dataset internals to avoid extra tokenization logic.\n        tokens = tokenizer(\n            rec.text,\n            return_tensors=\"pt\",\n            truncation=True,\n            padding=\"max_length\",\n            max_length=max_length,\n        )\n        input_ids = tokens[\"input_ids\"].to(device)\n        attention_mask = tokens[\"attention_mask\"].to(device)\n        with torch.no_grad():\n            out = model(input_ids=input_ids, attention_mask=attention_mask)\n        embs.append(out[\"proj\"].squeeze(0).cpu())\n\n        metas.append(rec.raw)\n\n    emb_mat = torch.stack(embs, dim=0) if embs else torch.empty(0)\n    return emb_mat, metas\n\n\ndef retrieve(\n    query_emb: torch.Tensor,\n    index_embs: torch.Tensor,\n    k: int = 5,\n) -> List[int]:\n    \"\"\"\n    Return indices of top-k most similar embeddings using cosine similarity.\n    \"\"\"\n    if index_embs.numel() == 0:\n        return []\n    sims = F.cosine_similarity(query_emb.unsqueeze(0), index_embs, dim=1)\n    topk = torch.topk(sims, k=min(k, sims.numel()))\n    return topk.indices.tolist()\n\n\ndef interactive_loop(\n    model: TOLBERT,\n    tokenizer,\n    index_embs: torch.Tensor,\n    metas: List[Dict[str, Any]],\n    max_length: int,\n    device: torch.device,\n) -> None:\n    print(\"Entering interactive retrieval loop. Type 'exit' to quit.\")\n    while True:\n        text = input(\"Query> \")\n        if not text or text.strip().lower() in {\"exit\", \"quit\"}:\n            break\n        tokens = tokenizer(\n            text,\n            return_tensors=\"pt\",\n            truncation=True,\n            padding=\"max_length\",\n            max_length=max_length,\n        )\n        with torch.no_grad():\n            out = model(\n                input_ids=tokens[\"input_ids\"].to(device),\n                attention_mask=tokens[\"attention_mask\"].to(device),\n            )\n        q_emb = out[\"proj\"].squeeze(0).cpu()\n        idxs = retrieve(q_emb, index_embs, k=5)\n        for i in idxs:\n            meta = metas[i]\n            snippet = meta.get(\"text\", \"\")[:200].replace(\"\\n\", \" \")\n            print(f\"- span_id={meta.get('span_id')} text={snippet!r}\")\n\n\ndef parse_args() -> argparse.Namespace:\n    ap = argparse.ArgumentParser(description=\"TOLBERT retrieval sandbox.\")\n    ap.add_argument(\"--config\", type=str, required=True, help=\"Path to training config.\")\n    ap.add_argument(\"--checkpoint\", type=str, required=True, help=\"Path to model .pt file.\")\n    ap.add_argument(\n        \"--spans_file\",\n        type=str,\n        required=True,\n        help=\"Spans JSONL file to index (e.g., code spans or paper spans).\",\n    )\n    ap.add_argument(\n        \"--device\",\n        type=str,\n        default=\"cuda\" if torch.cuda.is_available() else \"cpu\",\n        help=\"Device to use.\",\n    )\n    return ap.parse_args()\n\n\ndef main() -> None:\n    args = parse_args()\n    cfg = load_tolbert_config(args.config)\n    device = torch.device(args.device)\n\n    tokenizer = AutoTokenizer.from_pretrained(\n        cfg[\"base_model_name\"],\n        cache_dir=\"/data/checkpoints/\",  # noqa: E501\n    )\n\n    checkpoint_path = Path(args.checkpoint)\n    if not checkpoint_path.exists():\n        raise FileNotFoundError(f\"Checkpoint not found: {checkpoint_path}\")\n\n    model = build_model(cfg, str(checkpoint_path), device=device)\n\n    print(\"Encoding index spans...\")\n    index_embs, metas = encode_all_spans(\n        model=model,\n        tokenizer=tokenizer,\n        spans_file=args.spans_file,\n        max_length=cfg.get(\"max_length\", 256),\n        device=device,\n    )\n    print(f\"Indexed {index_embs.size(0)} spans.\")\n\n    interactive_loop(\n        model=model,\n        tokenizer=tokenizer,\n        index_embs=index_embs,\n        metas=metas,\n        max_length=cfg.get(\"max_length\", 256),\n        device=device,\n    )\n\n\nif __name__ == \"__main__\":\n    main()\n\n","source_hash":"45d7644b52ea2f46e0a00c129acd5d4c49a097e3ab56203649d3976759b35261","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.retrieval_sandbox.build_model","uri":"program://TOLBERT/function/scripts.retrieval_sandbox.build_model#L27-L38","kind":"function","name":"build_model","path":"scripts/retrieval_sandbox.py","language":"python","start_line":27,"end_line":38,"context_start_line":7,"context_end_line":58,"code":"  - builds an in-memory index of embeddings,\n  - lets you run ad-hoc queries over that index from the command line.\n\nIt is intended for small-scale experimentation and debugging, not production.\n\"\"\"\n\nimport argparse\nfrom pathlib import Path\nfrom typing import Any, Dict, List, Tuple\n\nimport torch\nfrom torch.nn import functional as F\nfrom transformers import AutoTokenizer\nimport os\n\nfrom tolbert.config import load_tolbert_config\nfrom tolbert.data import TreeOfLifeDataset\nfrom tolbert.modeling import TOLBERT, TOLBERTConfig\n\n\ndef build_model(cfg: Dict[str, Any], checkpoint: str, device: torch.device) -> TOLBERT:\n    model_cfg = TOLBERTConfig(\n        base_model_name=cfg[\"base_model_name\"],\n        level_sizes=cfg[\"level_sizes\"],\n        proj_dim=cfg.get(\"proj_dim\", 256),\n    )\n    model = TOLBERT(model_cfg)\n    state = torch.load(checkpoint, map_location=\"cpu\")\n    model.load_state_dict(state)\n    model.to(device)\n    model.eval()\n    return model\n\n\ndef encode_all_spans(\n    model: TOLBERT,\n    tokenizer,\n    spans_file: str,\n    max_length: int,\n    device: torch.device,\n) -> Tuple[torch.Tensor, List[Dict[str, Any]]]:\n    \"\"\"\n    Encode all spans in `spans_file` into a single tensor of embeddings,\n    plus a parallel list of raw records.\n    \"\"\"\n    dataset = TreeOfLifeDataset(\n        spans_file=spans_file,\n        tokenizer=tokenizer,\n        max_length=max_length,\n    )\n\n    embs: List[torch.Tensor] = []","source_hash":"45d7644b52ea2f46e0a00c129acd5d4c49a097e3ab56203649d3976759b35261","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.retrieval_sandbox.encode_all_spans","uri":"program://TOLBERT/function/scripts.retrieval_sandbox.encode_all_spans#L41-L79","kind":"function","name":"encode_all_spans","path":"scripts/retrieval_sandbox.py","language":"python","start_line":41,"end_line":79,"context_start_line":21,"context_end_line":99,"code":"\nfrom tolbert.config import load_tolbert_config\nfrom tolbert.data import TreeOfLifeDataset\nfrom tolbert.modeling import TOLBERT, TOLBERTConfig\n\n\ndef build_model(cfg: Dict[str, Any], checkpoint: str, device: torch.device) -> TOLBERT:\n    model_cfg = TOLBERTConfig(\n        base_model_name=cfg[\"base_model_name\"],\n        level_sizes=cfg[\"level_sizes\"],\n        proj_dim=cfg.get(\"proj_dim\", 256),\n    )\n    model = TOLBERT(model_cfg)\n    state = torch.load(checkpoint, map_location=\"cpu\")\n    model.load_state_dict(state)\n    model.to(device)\n    model.eval()\n    return model\n\n\ndef encode_all_spans(\n    model: TOLBERT,\n    tokenizer,\n    spans_file: str,\n    max_length: int,\n    device: torch.device,\n) -> Tuple[torch.Tensor, List[Dict[str, Any]]]:\n    \"\"\"\n    Encode all spans in `spans_file` into a single tensor of embeddings,\n    plus a parallel list of raw records.\n    \"\"\"\n    dataset = TreeOfLifeDataset(\n        spans_file=spans_file,\n        tokenizer=tokenizer,\n        max_length=max_length,\n    )\n\n    embs: List[torch.Tensor] = []\n    metas: List[Dict[str, Any]] = []\n\n    for rec in dataset._records:  # type: ignore[attr-defined]\n        # Directly reuse dataset internals to avoid extra tokenization logic.\n        tokens = tokenizer(\n            rec.text,\n            return_tensors=\"pt\",\n            truncation=True,\n            padding=\"max_length\",\n            max_length=max_length,\n        )\n        input_ids = tokens[\"input_ids\"].to(device)\n        attention_mask = tokens[\"attention_mask\"].to(device)\n        with torch.no_grad():\n            out = model(input_ids=input_ids, attention_mask=attention_mask)\n        embs.append(out[\"proj\"].squeeze(0).cpu())\n\n        metas.append(rec.raw)\n\n    emb_mat = torch.stack(embs, dim=0) if embs else torch.empty(0)\n    return emb_mat, metas\n\n\ndef retrieve(\n    query_emb: torch.Tensor,\n    index_embs: torch.Tensor,\n    k: int = 5,\n) -> List[int]:\n    \"\"\"\n    Return indices of top-k most similar embeddings using cosine similarity.\n    \"\"\"\n    if index_embs.numel() == 0:\n        return []\n    sims = F.cosine_similarity(query_emb.unsqueeze(0), index_embs, dim=1)\n    topk = torch.topk(sims, k=min(k, sims.numel()))\n    return topk.indices.tolist()\n\n\ndef interactive_loop(\n    model: TOLBERT,\n    tokenizer,","source_hash":"45d7644b52ea2f46e0a00c129acd5d4c49a097e3ab56203649d3976759b35261","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.retrieval_sandbox.retrieve","uri":"program://TOLBERT/function/scripts.retrieval_sandbox.retrieve#L82-L94","kind":"function","name":"retrieve","path":"scripts/retrieval_sandbox.py","language":"python","start_line":82,"end_line":94,"context_start_line":62,"context_end_line":114,"code":"        # Directly reuse dataset internals to avoid extra tokenization logic.\n        tokens = tokenizer(\n            rec.text,\n            return_tensors=\"pt\",\n            truncation=True,\n            padding=\"max_length\",\n            max_length=max_length,\n        )\n        input_ids = tokens[\"input_ids\"].to(device)\n        attention_mask = tokens[\"attention_mask\"].to(device)\n        with torch.no_grad():\n            out = model(input_ids=input_ids, attention_mask=attention_mask)\n        embs.append(out[\"proj\"].squeeze(0).cpu())\n\n        metas.append(rec.raw)\n\n    emb_mat = torch.stack(embs, dim=0) if embs else torch.empty(0)\n    return emb_mat, metas\n\n\ndef retrieve(\n    query_emb: torch.Tensor,\n    index_embs: torch.Tensor,\n    k: int = 5,\n) -> List[int]:\n    \"\"\"\n    Return indices of top-k most similar embeddings using cosine similarity.\n    \"\"\"\n    if index_embs.numel() == 0:\n        return []\n    sims = F.cosine_similarity(query_emb.unsqueeze(0), index_embs, dim=1)\n    topk = torch.topk(sims, k=min(k, sims.numel()))\n    return topk.indices.tolist()\n\n\ndef interactive_loop(\n    model: TOLBERT,\n    tokenizer,\n    index_embs: torch.Tensor,\n    metas: List[Dict[str, Any]],\n    max_length: int,\n    device: torch.device,\n) -> None:\n    print(\"Entering interactive retrieval loop. Type 'exit' to quit.\")\n    while True:\n        text = input(\"Query> \")\n        if not text or text.strip().lower() in {\"exit\", \"quit\"}:\n            break\n        tokens = tokenizer(\n            text,\n            return_tensors=\"pt\",\n            truncation=True,\n            padding=\"max_length\",","source_hash":"45d7644b52ea2f46e0a00c129acd5d4c49a097e3ab56203649d3976759b35261","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.retrieval_sandbox.interactive_loop","uri":"program://TOLBERT/function/scripts.retrieval_sandbox.interactive_loop#L97-L127","kind":"function","name":"interactive_loop","path":"scripts/retrieval_sandbox.py","language":"python","start_line":97,"end_line":127,"context_start_line":77,"context_end_line":147,"code":"\n    emb_mat = torch.stack(embs, dim=0) if embs else torch.empty(0)\n    return emb_mat, metas\n\n\ndef retrieve(\n    query_emb: torch.Tensor,\n    index_embs: torch.Tensor,\n    k: int = 5,\n) -> List[int]:\n    \"\"\"\n    Return indices of top-k most similar embeddings using cosine similarity.\n    \"\"\"\n    if index_embs.numel() == 0:\n        return []\n    sims = F.cosine_similarity(query_emb.unsqueeze(0), index_embs, dim=1)\n    topk = torch.topk(sims, k=min(k, sims.numel()))\n    return topk.indices.tolist()\n\n\ndef interactive_loop(\n    model: TOLBERT,\n    tokenizer,\n    index_embs: torch.Tensor,\n    metas: List[Dict[str, Any]],\n    max_length: int,\n    device: torch.device,\n) -> None:\n    print(\"Entering interactive retrieval loop. Type 'exit' to quit.\")\n    while True:\n        text = input(\"Query> \")\n        if not text or text.strip().lower() in {\"exit\", \"quit\"}:\n            break\n        tokens = tokenizer(\n            text,\n            return_tensors=\"pt\",\n            truncation=True,\n            padding=\"max_length\",\n            max_length=max_length,\n        )\n        with torch.no_grad():\n            out = model(\n                input_ids=tokens[\"input_ids\"].to(device),\n                attention_mask=tokens[\"attention_mask\"].to(device),\n            )\n        q_emb = out[\"proj\"].squeeze(0).cpu()\n        idxs = retrieve(q_emb, index_embs, k=5)\n        for i in idxs:\n            meta = metas[i]\n            snippet = meta.get(\"text\", \"\")[:200].replace(\"\\n\", \" \")\n            print(f\"- span_id={meta.get('span_id')} text={snippet!r}\")\n\n\ndef parse_args() -> argparse.Namespace:\n    ap = argparse.ArgumentParser(description=\"TOLBERT retrieval sandbox.\")\n    ap.add_argument(\"--config\", type=str, required=True, help=\"Path to training config.\")\n    ap.add_argument(\"--checkpoint\", type=str, required=True, help=\"Path to model .pt file.\")\n    ap.add_argument(\n        \"--spans_file\",\n        type=str,\n        required=True,\n        help=\"Spans JSONL file to index (e.g., code spans or paper spans).\",\n    )\n    ap.add_argument(\n        \"--device\",\n        type=str,\n        default=\"cuda\" if torch.cuda.is_available() else \"cpu\",\n        help=\"Device to use.\",\n    )\n    return ap.parse_args()\n","source_hash":"45d7644b52ea2f46e0a00c129acd5d4c49a097e3ab56203649d3976759b35261","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.retrieval_sandbox.parse_args","uri":"program://TOLBERT/function/scripts.retrieval_sandbox.parse_args#L130-L146","kind":"function","name":"parse_args","path":"scripts/retrieval_sandbox.py","language":"python","start_line":130,"end_line":146,"context_start_line":110,"context_end_line":166,"code":"        tokens = tokenizer(\n            text,\n            return_tensors=\"pt\",\n            truncation=True,\n            padding=\"max_length\",\n            max_length=max_length,\n        )\n        with torch.no_grad():\n            out = model(\n                input_ids=tokens[\"input_ids\"].to(device),\n                attention_mask=tokens[\"attention_mask\"].to(device),\n            )\n        q_emb = out[\"proj\"].squeeze(0).cpu()\n        idxs = retrieve(q_emb, index_embs, k=5)\n        for i in idxs:\n            meta = metas[i]\n            snippet = meta.get(\"text\", \"\")[:200].replace(\"\\n\", \" \")\n            print(f\"- span_id={meta.get('span_id')} text={snippet!r}\")\n\n\ndef parse_args() -> argparse.Namespace:\n    ap = argparse.ArgumentParser(description=\"TOLBERT retrieval sandbox.\")\n    ap.add_argument(\"--config\", type=str, required=True, help=\"Path to training config.\")\n    ap.add_argument(\"--checkpoint\", type=str, required=True, help=\"Path to model .pt file.\")\n    ap.add_argument(\n        \"--spans_file\",\n        type=str,\n        required=True,\n        help=\"Spans JSONL file to index (e.g., code spans or paper spans).\",\n    )\n    ap.add_argument(\n        \"--device\",\n        type=str,\n        default=\"cuda\" if torch.cuda.is_available() else \"cpu\",\n        help=\"Device to use.\",\n    )\n    return ap.parse_args()\n\n\ndef main() -> None:\n    args = parse_args()\n    cfg = load_tolbert_config(args.config)\n    device = torch.device(args.device)\n\n    tokenizer = AutoTokenizer.from_pretrained(\n        cfg[\"base_model_name\"],\n        cache_dir=\"/data/checkpoints/\",  # noqa: E501\n    )\n\n    checkpoint_path = Path(args.checkpoint)\n    if not checkpoint_path.exists():\n        raise FileNotFoundError(f\"Checkpoint not found: {checkpoint_path}\")\n\n    model = build_model(cfg, str(checkpoint_path), device=device)\n\n    print(\"Encoding index spans...\")\n    index_embs, metas = encode_all_spans(","source_hash":"45d7644b52ea2f46e0a00c129acd5d4c49a097e3ab56203649d3976759b35261","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.retrieval_sandbox.main","uri":"program://TOLBERT/function/scripts.retrieval_sandbox.main#L149-L182","kind":"function","name":"main","path":"scripts/retrieval_sandbox.py","language":"python","start_line":149,"end_line":182,"context_start_line":129,"context_end_line":188,"code":"\ndef parse_args() -> argparse.Namespace:\n    ap = argparse.ArgumentParser(description=\"TOLBERT retrieval sandbox.\")\n    ap.add_argument(\"--config\", type=str, required=True, help=\"Path to training config.\")\n    ap.add_argument(\"--checkpoint\", type=str, required=True, help=\"Path to model .pt file.\")\n    ap.add_argument(\n        \"--spans_file\",\n        type=str,\n        required=True,\n        help=\"Spans JSONL file to index (e.g., code spans or paper spans).\",\n    )\n    ap.add_argument(\n        \"--device\",\n        type=str,\n        default=\"cuda\" if torch.cuda.is_available() else \"cpu\",\n        help=\"Device to use.\",\n    )\n    return ap.parse_args()\n\n\ndef main() -> None:\n    args = parse_args()\n    cfg = load_tolbert_config(args.config)\n    device = torch.device(args.device)\n\n    tokenizer = AutoTokenizer.from_pretrained(\n        cfg[\"base_model_name\"],\n        cache_dir=\"/data/checkpoints/\",  # noqa: E501\n    )\n\n    checkpoint_path = Path(args.checkpoint)\n    if not checkpoint_path.exists():\n        raise FileNotFoundError(f\"Checkpoint not found: {checkpoint_path}\")\n\n    model = build_model(cfg, str(checkpoint_path), device=device)\n\n    print(\"Encoding index spans...\")\n    index_embs, metas = encode_all_spans(\n        model=model,\n        tokenizer=tokenizer,\n        spans_file=args.spans_file,\n        max_length=cfg.get(\"max_length\", 256),\n        device=device,\n    )\n    print(f\"Indexed {index_embs.size(0)} spans.\")\n\n    interactive_loop(\n        model=model,\n        tokenizer=tokenizer,\n        index_embs=index_embs,\n        metas=metas,\n        max_length=cfg.get(\"max_length\", 256),\n        device=device,\n    )\n\n\nif __name__ == \"__main__\":\n    main()\n\n","source_hash":"45d7644b52ea2f46e0a00c129acd5d4c49a097e3ab56203649d3976759b35261","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.code_graph","uri":"program://TOLBERT/module/scripts.code_graph#L1-L1197","kind":"module","name":"scripts.code_graph","path":"scripts/code_graph.py","language":"python","start_line":1,"end_line":1197,"context_start_line":1,"context_end_line":1197,"code":"import os\nimport ast\nimport re\nimport json\nimport time  # noqa: F401\nfrom dataclasses import dataclass, field\nfrom typing import Any, Dict, List, Tuple, Optional\ntry:\n    import pathspec  # type: ignore\nexcept Exception:  # pragma: no cover\n    pathspec = None  # type: ignore\n\n\n@dataclass\nclass Symbol:\n    fqn: str\n    name: str\n    qualname: str\n    kind: str  # module|class|function|variable\n    module: str\n    file: str\n    line: int\n    end_line: int\n    doc: Optional[str] = None\n    signature: Optional[str] = None\n    returns: Optional[str] = None\n\n\n@dataclass\nclass ModuleInfo:\n    module: str\n    file: str\n    is_test: bool = False\n    imports: Dict[str, str] = field(\n        default_factory=dict\n    )  # alias -> target (module or module.symbol)\n    defs: List[str] = field(default_factory=list)  # list of symbol FQNs\n    exports: List[str] = field(default_factory=list)  # names from __all__\n\n\nclass CodeGraph:\n    def __init__(self, root: str, *, ignore: Optional[List[str]] = None) -> None:\n        self.root = os.path.abspath(root)\n        # Ignore patterns (relative to root) or glob-like; simple prefix/glob matching\n        self._ignore: List[str] = []\n        if ignore:\n            # normalize to forward-slash relative prefixes for matching\n            for pat in ignore:\n                if not pat:\n                    continue\n                p = os.path.normpath(pat)\n                # store both relative and absolute forms for convenience\n                self._ignore.append(p)\n        # Load .gitignore as pathspec if available\n        self._pspec = None\n        try:\n            gi = os.path.join(self.root, \".gitignore\")\n            if pathspec is not None and os.path.exists(gi):\n                with open(gi, \"r\", encoding=\"utf-8\", errors=\"ignore\") as fh:\n                    lines = [ln.rstrip(\"\\n\") for ln in fh]\n                self._pspec = pathspec.PathSpec.from_lines(\"gitwildmatch\", lines)\n        except Exception:\n            self._pspec = None\n        self.symbols_by_fqn: Dict[str, Symbol] = {}\n        self.symbols_by_name: Dict[str, List[str]] = {}\n        self.modules: Dict[str, ModuleInfo] = {}\n        self.indexed_files: List[str] = []\n        self.calls: List[Tuple[str, str]] = []  # (caller_fqn, callee_fqn_or_key)\n        self.module_to_tests: Dict[str, List[str]] = {}\n        self.coverage_files: Dict[str, set[int]] = {}\n        self.symbol_coverage: Dict[str, float] = {}\n        self.module_imports: Dict[str, List[str]] = {}\n        self.module_star_imports: Dict[str, List[str]] = {}\n        self.pytest_nodes_by_module: Dict[str, List[str]] = {}\n        self._cached_mtimes: Dict[str, int] = {}\n        self._cached_hashes: Dict[str, str] = {}\n\n    def _is_ignored(self, rel: str) -> bool:\n        try:\n            r = rel.replace(os.sep, \"/\")\n            # pathspec first\n            if self._pspec is not None:\n                if self._pspec.match_file(r):\n                    return True\n            # fallback: prefix match\n            for pat in self._ignore:\n                pp = pat.replace(os.sep, \"/\")\n                if r == pp or r.startswith(pp + \"/\"):\n                    return True\n            return False\n        except Exception:\n            return False\n\n    @classmethod\n    def load_or_build(cls, root: str, *, ignore_cache: bool = False, ignore: Optional[List[str]] = None) -> \"CodeGraph\":\n        g = cls(root=root, ignore=ignore)\n        g.build(ignore_cache=ignore_cache)\n        return g\n\n    def build(self, ignore_cache: bool = False) -> None:\n        cache_path = os.path.join(self.root, \".codegraph.json\")\n        if (not ignore_cache) and self._load_cache_relaxed(cache_path):\n            # Incremental: reindex changed and dependents\n            changed, removed = self._detect_changed_files(\n                self._cached_mtimes, self._cached_hashes\n            )\n            if not changed and not removed:\n                return\n            self._incremental_reindex(changed, removed)\n            self._expand_star_imports()\n            self._post_resolve_calls()\n            self._save_cache(cache_path)\n            return\n        for dirpath, dirnames, filenames in os.walk(self.root):\n            # prune ignored directories in-place\n            dir_rel = os.path.relpath(dirpath, self.root)\n            # remove child dirs that are ignored\n            dirnames[:] = [d for d in dirnames if not self._is_ignored(os.path.join(dir_rel, d))]\n            if self._is_ignored(dir_rel):\n                continue\n            for fn in filenames:\n                if not fn.endswith(\".py\"):\n                    continue\n                fpath = os.path.join(dirpath, fn)\n                if self._is_ignored(os.path.relpath(fpath, self.root)):\n                    continue\n                try:\n                    src = open(fpath, \"r\", encoding=\"utf-8\").read()\n                except Exception:\n                    continue\n                try:\n                    tree = ast.parse(src)\n                except Exception:\n                    continue\n                self.indexed_files.append(fpath)\n                self._index_module(fpath, tree)\n        # Build test mapping from imports in test modules\n        self._build_test_mapping()\n        # Expand star imports and post-resolve call targets\n        self._expand_star_imports()\n        self._post_resolve_calls()\n        self._save_cache(cache_path)\n\n    def _add_symbol(self, sym: Symbol) -> None:\n        self.symbols_by_fqn[sym.fqn] = sym\n        self.symbols_by_name.setdefault(sym.name, []).append(sym.fqn)\n        mi = self.modules.setdefault(\n            sym.module, ModuleInfo(module=sym.module, file=sym.file)\n        )\n        if sym.fqn not in mi.defs:\n            mi.defs.append(sym.fqn)\n\n    def _index_module(self, path: str, tree: ast.AST) -> None:\n        module = self._module_name_for_path(path)\n        is_test = (\"/tests/\" in path) or (os.path.basename(path).startswith(\"test_\"))\n        self.modules.setdefault(\n            module, ModuleInfo(module=module, file=path, is_test=is_test)\n        )\n        # Add module symbol\n        mod_fqn = module\n        mod_name = module.split(\".\")[-1]\n        self._add_symbol(\n            Symbol(\n                fqn=mod_fqn,\n                name=mod_name,\n                qualname=\"\",\n                kind=\"module\",\n                module=module,\n                file=path,\n                line=1,\n                end_line=1,\n            )\n        )\n        # Visit\n        visitor = _ModuleVisitor(module, path)\n        visitor.visit(tree)\n        # Register imports\n        self.modules[module].imports.update(visitor.imports)\n        # Module dependency edges\n        self.module_imports[module] = sorted(visitor.import_modules)\n        # Record star imports for later expansion\n        self.module_star_imports[module] = list(getattr(visitor, \"star_imports\", []))\n        # Record __all__ exports\n        self.modules[module].exports = list(getattr(visitor, \"exports\", []))\n        # Register defs\n        for sym in visitor.symbols:\n            self._add_symbol(sym)\n        # Register calls\n        for caller, callee_key in visitor.calls:\n            callee_fqn = self._resolve_callee(module, callee_key, visitor)\n            self.calls.append((caller, callee_fqn or callee_key))\n        # Collect pytest nodes if test module\n        if is_test:\n            rel = os.path.relpath(path, self.root)\n            self.pytest_nodes_by_module[module] = self._collect_pytest_nodes(tree, rel)\n\n    def owners_of(self, symbol: str) -> List[str]:\n        fqns = self.symbols_by_name.get(symbol, [])\n        return sorted(\n            {os.path.relpath(self.symbols_by_fqn[f].file, self.root) for f in fqns}\n        )\n\n    def find_symbol(self, name: str) -> List[Symbol]:\n        return [self.symbols_by_fqn[f] for f in self.symbols_by_name.get(name, [])]\n\n    def defs_in(self, module: str) -> List[str]:\n        mi = self.modules.get(module)\n        return list(mi.defs) if mi else []\n\n    def calls_of(self, fqn: str) -> List[str]:\n        return [c for (caller, c) in self.calls if caller == fqn]\n\n    def who_calls(self, fqn: str) -> List[str]:\n        target_short = fqn.split(\".\")[-1]\n        out: List[str] = []\n        for caller, callee in self.calls:\n            if callee == fqn or callee.split(\".\")[-1] == target_short:\n                out.append(caller)\n        return out\n\n    def search_refs(self, pattern: str) -> List[Tuple[str, int, str]]:\n        \"\"\"Ripgrep-based raw reference search (file, line_no, text).\"\"\"\n        try:\n            import subprocess\n\n            out = subprocess.check_output([\"rg\", \"-n\", pattern, self.root], text=True)\n            rows: List[Tuple[str, int, str]] = []\n            for line in out.splitlines():\n                try:\n                    fp, ln, txt = line.split(\":\", 2)\n                    rows.append((os.path.relpath(fp, self.root), int(ln), txt))\n                except Exception:\n                    continue\n            return rows\n        except Exception:\n            # Fallback: simple Python regex over indexed .py files\n            rows: List[Tuple[str, int, str]] = []\n            try:\n                rx = re.compile(pattern)\n            except Exception:\n                # If pattern is not a valid regex, escape it\n                rx = re.compile(re.escape(pattern))\n            for fpath in self.indexed_files:\n                rel = os.path.relpath(fpath, self.root)\n                try:\n                    with open(fpath, \"r\", encoding=\"utf-8\", errors=\"ignore\") as rf:\n                        for i, ln in enumerate(rf, start=1):\n                            if rx.search(ln):\n                                rows.append((rel, i, ln.rstrip(\"\\n\")))\n                except Exception:\n                    continue\n            return rows\n\n    # --- Helpers --- #\n\n    def module_for_file(self, path: str) -> Optional[str]:\n        p = path\n        if not os.path.isabs(p):\n            p = os.path.abspath(os.path.join(self.root, path))\n        for mod, mi in self.modules.items():\n            if os.path.abspath(mi.file) == p:\n                return mod\n        return None\n\n    def file_for_module(self, module: str) -> Optional[str]:\n        mi = self.modules.get(module)\n        return mi.file if mi else None\n\n    def tests_for_module(self, module: str) -> List[str]:\n        base = module.split(\".\")[0]\n        out = set(self.module_to_tests.get(base, []))\n        # include direct module key if present\n        out.update(self.module_to_tests.get(module, []))\n        return sorted(out)\n\n    def tests_for_symbol(self, fqn: str) -> List[str]:\n        mod = fqn.rsplit(\".\", 1)[0] if \".\" in fqn else fqn\n        return self.tests_for_module(mod)\n\n    def refs_of(self, fqn: str) -> List[Tuple[str, str]]:\n        \"\"\"Return (caller_fqn, callee_match) entries that reference fqn or its short name.\"\"\"\n        target_short = fqn.split(\".\")[-1]\n        out: List[Tuple[str, str]] = []\n        for caller, callee in self.calls:\n            if callee == fqn or callee.split(\".\")[-1] == target_short:\n                out.append((caller, callee))\n        return out\n\n    def export_json(self) -> Dict[str, Any]:\n        return {\n            \"root\": self.root,\n            \"files\": [os.path.relpath(p, self.root) for p in self.indexed_files],\n            \"symbols\": [self._sym_to_dict(s) for s in self.symbols_by_fqn.values()],\n            \"modules\": {k: self._mi_to_dict(v) for k, v in self.modules.items()},\n            \"calls\": self.calls,\n            \"module_to_tests\": self.module_to_tests,\n            \"coverage_files\": {\n                os.path.relpath(k, self.root): sorted(list(v))\n                for k, v in self.coverage_files.items()\n            },\n            \"symbol_coverage\": self.symbol_coverage,\n            \"module_imports\": self.module_imports,\n        }\n\n    def export_sqlite(self, db_path: str) -> None:\n        import sqlite3\n\n        conn = sqlite3.connect(db_path)\n        cur = conn.cursor()\n        cur.executescript(\n            \"\"\"\n            PRAGMA journal_mode=WAL;\n            CREATE TABLE IF NOT EXISTS files(path TEXT PRIMARY KEY);\n            CREATE TABLE IF NOT EXISTS modules(module TEXT PRIMARY KEY, file TEXT, is_test INT);\n            CREATE TABLE IF NOT EXISTS symbols(\n              fqn TEXT PRIMARY KEY, name TEXT, qualname TEXT, kind TEXT, module TEXT,\n              file TEXT, line INT, end_line INT, doc TEXT, signature TEXT, returns TEXT\n            );\n            CREATE TABLE IF NOT EXISTS calls(caller TEXT, callee TEXT);\n            CREATE TABLE IF NOT EXISTS tests_map(module TEXT, test_module TEXT);\n            CREATE TABLE IF NOT EXISTS coverage(file TEXT, line INT);\n            CREATE TABLE IF NOT EXISTS mod_deps(module TEXT, dep TEXT);\n            \"\"\"\n        )\n        cur.executemany(\n            \"INSERT OR IGNORE INTO files(path) VALUES(?)\",\n            [(os.path.relpath(f, self.root),) for f in self.indexed_files],\n        )\n        cur.executemany(\n            \"INSERT OR REPLACE INTO modules(module,file,is_test) VALUES(?,?,?)\",\n            [\n                (m, os.path.relpath(mi.file, self.root), 1 if mi.is_test else 0)\n                for m, mi in self.modules.items()\n            ],\n        )\n        cur.executemany(\n            \"INSERT OR REPLACE INTO symbols VALUES(?,?,?,?,?,?,?,?,?,?,?)\",\n            [\n                (\n                    s.fqn,\n                    s.name,\n                    s.qualname,\n                    s.kind,\n                    s.module,\n                    os.path.relpath(s.file, self.root),\n                    int(s.line),\n                    int(s.end_line),\n                    s.doc or \"\",\n                    s.signature or \"\",\n                    s.returns or \"\",\n                )\n                for s in self.symbols_by_fqn.values()\n            ],\n        )\n        if self.calls:\n            cur.executemany(\n                \"INSERT INTO calls(caller,callee) VALUES(?,?)\", list(self.calls)\n            )\n        rows = []\n        for mod, tests in self.module_to_tests.items():\n            for t in tests:\n                rows.append((mod, t))\n        if rows:\n            cur.executemany(\n                \"INSERT INTO tests_map(module,test_module) VALUES(?,?)\", rows\n            )\n        cov_rows = []\n        for f, lines in self.coverage_files.items():\n            rel = os.path.relpath(f, self.root)\n            cov_rows.extend([(rel, int(n)) for n in lines])\n        if cov_rows:\n            cur.executemany(\"INSERT INTO coverage(file,line) VALUES(?,?)\", cov_rows)\n        dep_rows = []\n        for m, deps in self.module_imports.items():\n            for d in deps:\n                dep_rows.append((m, d))\n        if dep_rows:\n            cur.executemany(\"INSERT INTO mod_deps(module,dep) VALUES(?,?)\", dep_rows)\n        conn.commit()\n        conn.close()\n\n    def _module_name_for_path(self, path: str) -> str:\n        rel = os.path.relpath(path, self.root)\n        no_ext = rel[:-3] if rel.endswith(\".py\") else rel\n        parts = no_ext.split(os.sep)\n        if parts[-1] == \"__init__\":\n            parts = parts[:-1]\n        return \".\".join(p for p in parts if p)\n\n    def _resolve_callee(\n        self, module: str, callee_key: str, visitor: \"_ModuleVisitor\"\n    ) -> Optional[str]:\n        if \".\" in callee_key and \":\" not in callee_key:\n            return callee_key\n\n        if \":\" in callee_key:\n            mod_alias, name = callee_key.split(\":\", 1)\n            target = visitor.imports.get(mod_alias)\n            if target:\n                return f\"{target}.{name}\" if not target.endswith(f\".{name}\") else target\n\n        mi = self.modules.get(module)\n        if mi:\n            # Prefer any def with same suffix name (matches within class or function)\n            for f in mi.defs:\n                if f.split(\".\")[-1] == callee_key:\n                    return f\n\n        tgt = visitor.imports.get(callee_key)\n        if tgt:\n            return tgt\n        return None\n\n    def _build_test_mapping(self) -> None:\n        for mod, mi in self.modules.items():\n            if not mi.is_test:\n                continue\n            for alias, target in mi.imports.items():\n                # target may be module or module.symbol\n                m = target.split(\".\")[0]\n                self.module_to_tests.setdefault(m, []).append(mod)\n\n    def _expand_star_imports(self) -> None:\n        for mod, stars in self.module_star_imports.items():\n            mi = self.modules.get(mod)\n            if not mi:\n                continue\n            for star_mod in stars:\n                defs = [\n                    f\n                    for f in self.modules.get(\n                        star_mod, ModuleInfo(module=star_mod, file=\"\")\n                    ).defs\n                ]\n                exports = set(\n                    self.modules.get(\n                        star_mod, ModuleInfo(module=star_mod, file=\"\")\n                    ).exports\n                    or []\n                )\n                for fqn in defs:\n                    name = fqn.split(\".\")[-1]\n                    if exports:\n                        if name not in exports:\n                            continue\n                    elif name.startswith(\"_\"):\n                        continue\n                    if name not in mi.imports:\n                        mi.imports[name] = f\"{star_mod}.{name}\"\n\n    def _post_resolve_calls(self) -> None:\n        # After imports expanded, try to resolve unresolved simple names\n        new_calls: List[Tuple[str, str]] = []\n        for caller, callee in self.calls:\n            if \".\" in callee:\n                new_calls.append((caller, callee))\n                continue\n            # Find caller module\n            caller_mod = caller.rsplit(\".\", 1)[0] if \".\" in caller else caller\n            imports = self.modules.get(\n                caller_mod, ModuleInfo(module=caller_mod, file=\"\")\n            ).imports\n            tgt = imports.get(callee)\n            if tgt:\n                new_calls.append((caller, tgt))\n            else:\n                # leave as-is\n                new_calls.append((caller, callee))\n        self.calls = new_calls\n\n    def unresolved_calls(self) -> List[Tuple[str, str]]:\n        return [\n            (a, c)\n            for (a, c) in self.calls\n            if \".\" not in c and not self._is_builtin_name(c)\n        ]\n\n    def _collect_pytest_nodes(self, tree: ast.AST, rel_path: str) -> List[str]:\n        nodes: List[str] = []\n        # top-level test_* functions\n        for n in getattr(tree, \"body\", []) or []:\n            if isinstance(n, ast.FunctionDef) and n.name.startswith(\"test_\"):\n                nodes.extend(self._expand_parametrize(rel_path, None, n))\n            if isinstance(n, ast.ClassDef) and n.name.startswith(\"Test\"):\n                cls = n.name\n                for m in getattr(n, \"body\", []) or []:\n                    if isinstance(m, ast.FunctionDef) and m.name.startswith(\"test_\"):\n                        nodes.extend(self._expand_parametrize(rel_path, cls, m))\n        return nodes\n\n    def _expand_parametrize(\n        self, rel_path: str, cls: Optional[str], fn: ast.FunctionDef\n    ) -> List[str]:\n        base = f\"{rel_path}::\" + (f\"{cls}::\" if cls else \"\") + fn.name\n        # Look for @pytest.mark.parametrize(\"arg\", [vals])\n        total: List[str] = []\n        params: List[int] = []\n        try:\n            for dec in getattr(fn, \"decorator_list\", []) or []:\n                # pytest.mark.parametrize(...)\n                if (\n                    isinstance(dec, ast.Call)\n                    and isinstance(dec.func, ast.Attribute)\n                    and dec.func.attr == \"parametrize\"\n                ):\n                    # estimate number of cases from second arg list length\n                    if len(dec.args) >= 2 and isinstance(\n                        dec.args[1], (ast.List, ast.Tuple)\n                    ):\n                        params.append(len(dec.args[1].elts))\n        except Ex\n# ... truncated ...","source_hash":"e28a996e3c22e28318f33e970701e56c53d2becd271f9615a0269e11078879c6","truncated":true}
{"repo_id":"TOLBERT","entity_id":"py:scripts.code_graph.Symbol","uri":"program://TOLBERT/class/scripts.code_graph.Symbol#L15-L26","kind":"class","name":"Symbol","path":"scripts/code_graph.py","language":"python","start_line":15,"end_line":26,"context_start_line":1,"context_end_line":46,"code":"import os\nimport ast\nimport re\nimport json\nimport time  # noqa: F401\nfrom dataclasses import dataclass, field\nfrom typing import Any, Dict, List, Tuple, Optional\ntry:\n    import pathspec  # type: ignore\nexcept Exception:  # pragma: no cover\n    pathspec = None  # type: ignore\n\n\n@dataclass\nclass Symbol:\n    fqn: str\n    name: str\n    qualname: str\n    kind: str  # module|class|function|variable\n    module: str\n    file: str\n    line: int\n    end_line: int\n    doc: Optional[str] = None\n    signature: Optional[str] = None\n    returns: Optional[str] = None\n\n\n@dataclass\nclass ModuleInfo:\n    module: str\n    file: str\n    is_test: bool = False\n    imports: Dict[str, str] = field(\n        default_factory=dict\n    )  # alias -> target (module or module.symbol)\n    defs: List[str] = field(default_factory=list)  # list of symbol FQNs\n    exports: List[str] = field(default_factory=list)  # names from __all__\n\n\nclass CodeGraph:\n    def __init__(self, root: str, *, ignore: Optional[List[str]] = None) -> None:\n        self.root = os.path.abspath(root)\n        # Ignore patterns (relative to root) or glob-like; simple prefix/glob matching\n        self._ignore: List[str] = []\n        if ignore:","source_hash":"e28a996e3c22e28318f33e970701e56c53d2becd271f9615a0269e11078879c6","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.code_graph.ModuleInfo","uri":"program://TOLBERT/class/scripts.code_graph.ModuleInfo#L30-L38","kind":"class","name":"ModuleInfo","path":"scripts/code_graph.py","language":"python","start_line":30,"end_line":38,"context_start_line":10,"context_end_line":58,"code":"except Exception:  # pragma: no cover\n    pathspec = None  # type: ignore\n\n\n@dataclass\nclass Symbol:\n    fqn: str\n    name: str\n    qualname: str\n    kind: str  # module|class|function|variable\n    module: str\n    file: str\n    line: int\n    end_line: int\n    doc: Optional[str] = None\n    signature: Optional[str] = None\n    returns: Optional[str] = None\n\n\n@dataclass\nclass ModuleInfo:\n    module: str\n    file: str\n    is_test: bool = False\n    imports: Dict[str, str] = field(\n        default_factory=dict\n    )  # alias -> target (module or module.symbol)\n    defs: List[str] = field(default_factory=list)  # list of symbol FQNs\n    exports: List[str] = field(default_factory=list)  # names from __all__\n\n\nclass CodeGraph:\n    def __init__(self, root: str, *, ignore: Optional[List[str]] = None) -> None:\n        self.root = os.path.abspath(root)\n        # Ignore patterns (relative to root) or glob-like; simple prefix/glob matching\n        self._ignore: List[str] = []\n        if ignore:\n            # normalize to forward-slash relative prefixes for matching\n            for pat in ignore:\n                if not pat:\n                    continue\n                p = os.path.normpath(pat)\n                # store both relative and absolute forms for convenience\n                self._ignore.append(p)\n        # Load .gitignore as pathspec if available\n        self._pspec = None\n        try:\n            gi = os.path.join(self.root, \".gitignore\")\n            if pathspec is not None and os.path.exists(gi):","source_hash":"e28a996e3c22e28318f33e970701e56c53d2becd271f9615a0269e11078879c6","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.code_graph.CodeGraph","uri":"program://TOLBERT/class/scripts.code_graph.CodeGraph#L41-L863","kind":"class","name":"CodeGraph","path":"scripts/code_graph.py","language":"python","start_line":41,"end_line":863,"context_start_line":21,"context_end_line":883,"code":"    file: str\n    line: int\n    end_line: int\n    doc: Optional[str] = None\n    signature: Optional[str] = None\n    returns: Optional[str] = None\n\n\n@dataclass\nclass ModuleInfo:\n    module: str\n    file: str\n    is_test: bool = False\n    imports: Dict[str, str] = field(\n        default_factory=dict\n    )  # alias -> target (module or module.symbol)\n    defs: List[str] = field(default_factory=list)  # list of symbol FQNs\n    exports: List[str] = field(default_factory=list)  # names from __all__\n\n\nclass CodeGraph:\n    def __init__(self, root: str, *, ignore: Optional[List[str]] = None) -> None:\n        self.root = os.path.abspath(root)\n        # Ignore patterns (relative to root) or glob-like; simple prefix/glob matching\n        self._ignore: List[str] = []\n        if ignore:\n            # normalize to forward-slash relative prefixes for matching\n            for pat in ignore:\n                if not pat:\n                    continue\n                p = os.path.normpath(pat)\n                # store both relative and absolute forms for convenience\n                self._ignore.append(p)\n        # Load .gitignore as pathspec if available\n        self._pspec = None\n        try:\n            gi = os.path.join(self.root, \".gitignore\")\n            if pathspec is not None and os.path.exists(gi):\n                with open(gi, \"r\", encoding=\"utf-8\", errors=\"ignore\") as fh:\n                    lines = [ln.rstrip(\"\\n\") for ln in fh]\n                self._pspec = pathspec.PathSpec.from_lines(\"gitwildmatch\", lines)\n        except Exception:\n            self._pspec = None\n        self.symbols_by_fqn: Dict[str, Symbol] = {}\n        self.symbols_by_name: Dict[str, List[str]] = {}\n        self.modules: Dict[str, ModuleInfo] = {}\n        self.indexed_files: List[str] = []\n        self.calls: List[Tuple[str, str]] = []  # (caller_fqn, callee_fqn_or_key)\n        self.module_to_tests: Dict[str, List[str]] = {}\n        self.coverage_files: Dict[str, set[int]] = {}\n        self.symbol_coverage: Dict[str, float] = {}\n        self.module_imports: Dict[str, List[str]] = {}\n        self.module_star_imports: Dict[str, List[str]] = {}\n        self.pytest_nodes_by_module: Dict[str, List[str]] = {}\n        self._cached_mtimes: Dict[str, int] = {}\n        self._cached_hashes: Dict[str, str] = {}\n\n    def _is_ignored(self, rel: str) -> bool:\n        try:\n            r = rel.replace(os.sep, \"/\")\n            # pathspec first\n            if self._pspec is not None:\n                if self._pspec.match_file(r):\n                    return True\n            # fallback: prefix match\n            for pat in self._ignore:\n                pp = pat.replace(os.sep, \"/\")\n                if r == pp or r.startswith(pp + \"/\"):\n                    return True\n            return False\n        except Exception:\n            return False\n\n    @classmethod\n    def load_or_build(cls, root: str, *, ignore_cache: bool = False, ignore: Optional[List[str]] = None) -> \"CodeGraph\":\n        g = cls(root=root, ignore=ignore)\n        g.build(ignore_cache=ignore_cache)\n        return g\n\n    def build(self, ignore_cache: bool = False) -> None:\n        cache_path = os.path.join(self.root, \".codegraph.json\")\n        if (not ignore_cache) and self._load_cache_relaxed(cache_path):\n            # Incremental: reindex changed and dependents\n            changed, removed = self._detect_changed_files(\n                self._cached_mtimes, self._cached_hashes\n            )\n            if not changed and not removed:\n                return\n            self._incremental_reindex(changed, removed)\n            self._expand_star_imports()\n            self._post_resolve_calls()\n            self._save_cache(cache_path)\n            return\n        for dirpath, dirnames, filenames in os.walk(self.root):\n            # prune ignored directories in-place\n            dir_rel = os.path.relpath(dirpath, self.root)\n            # remove child dirs that are ignored\n            dirnames[:] = [d for d in dirnames if not self._is_ignored(os.path.join(dir_rel, d))]\n            if self._is_ignored(dir_rel):\n                continue\n            for fn in filenames:\n                if not fn.endswith(\".py\"):\n                    continue\n                fpath = os.path.join(dirpath, fn)\n                if self._is_ignored(os.path.relpath(fpath, self.root)):\n                    continue\n                try:\n                    src = open(fpath, \"r\", encoding=\"utf-8\").read()\n                except Exception:\n                    continue\n                try:\n                    tree = ast.parse(src)\n                except Exception:\n                    continue\n                self.indexed_files.append(fpath)\n                self._index_module(fpath, tree)\n        # Build test mapping from imports in test modules\n        self._build_test_mapping()\n        # Expand star imports and post-resolve call targets\n        self._expand_star_imports()\n        self._post_resolve_calls()\n        self._save_cache(cache_path)\n\n    def _add_symbol(self, sym: Symbol) -> None:\n        self.symbols_by_fqn[sym.fqn] = sym\n        self.symbols_by_name.setdefault(sym.name, []).append(sym.fqn)\n        mi = self.modules.setdefault(\n            sym.module, ModuleInfo(module=sym.module, file=sym.file)\n        )\n        if sym.fqn not in mi.defs:\n            mi.defs.append(sym.fqn)\n\n    def _index_module(self, path: str, tree: ast.AST) -> None:\n        module = self._module_name_for_path(path)\n        is_test = (\"/tests/\" in path) or (os.path.basename(path).startswith(\"test_\"))\n        self.modules.setdefault(\n            module, ModuleInfo(module=module, file=path, is_test=is_test)\n        )\n        # Add module symbol\n        mod_fqn = module\n        mod_name = module.split(\".\")[-1]\n        self._add_symbol(\n            Symbol(\n                fqn=mod_fqn,\n                name=mod_name,\n                qualname=\"\",\n                kind=\"module\",\n                module=module,\n                file=path,\n                line=1,\n                end_line=1,\n            )\n        )\n        # Visit\n        visitor = _ModuleVisitor(module, path)\n        visitor.visit(tree)\n        # Register imports\n        self.modules[module].imports.update(visitor.imports)\n        # Module dependency edges\n        self.module_imports[module] = sorted(visitor.import_modules)\n        # Record star imports for later expansion\n        self.module_star_imports[module] = list(getattr(visitor, \"star_imports\", []))\n        # Record __all__ exports\n        self.modules[module].exports = list(getattr(visitor, \"exports\", []))\n        # Register defs\n        for sym in visitor.symbols:\n            self._add_symbol(sym)\n        # Register calls\n        for caller, callee_key in visitor.calls:\n            callee_fqn = self._resolve_callee(module, callee_key, visitor)\n            self.calls.append((caller, callee_fqn or callee_key))\n        # Collect pytest nodes if test module\n        if is_test:\n            rel = os.path.relpath(path, self.root)\n            self.pytest_nodes_by_module[module] = self._collect_pytest_nodes(tree, rel)\n\n    def owners_of(self, symbol: str) -> List[str]:\n        fqns = self.symbols_by_name.get(symbol, [])\n        return sorted(\n            {os.path.relpath(self.symbols_by_fqn[f].file, self.root) for f in fqns}\n        )\n\n    def find_symbol(self, name: str) -> List[Symbol]:\n        return [self.symbols_by_fqn[f] for f in self.symbols_by_name.get(name, [])]\n\n    def defs_in(self, module: str) -> List[str]:\n        mi = self.modules.get(module)\n        return list(mi.defs) if mi else []\n\n    def calls_of(self, fqn: str) -> List[str]:\n        return [c for (caller, c) in self.calls if caller == fqn]\n\n    def who_calls(self, fqn: str) -> List[str]:\n        target_short = fqn.split(\".\")[-1]\n        out: List[str] = []\n        for caller, callee in self.calls:\n            if callee == fqn or callee.split(\".\")[-1] == target_short:\n                out.append(caller)\n        return out\n\n    def search_refs(self, pattern: str) -> List[Tuple[str, int, str]]:\n        \"\"\"Ripgrep-based raw reference search (file, line_no, text).\"\"\"\n        try:\n            import subprocess\n\n            out = subprocess.check_output([\"rg\", \"-n\", pattern, self.root], text=True)\n            rows: List[Tuple[str, int, str]] = []\n            for line in out.splitlines():\n                try:\n                    fp, ln, txt = line.split(\":\", 2)\n                    rows.append((os.path.relpath(fp, self.root), int(ln), txt))\n                except Exception:\n                    continue\n            return rows\n        except Exception:\n            # Fallback: simple Python regex over indexed .py files\n            rows: List[Tuple[str, int, str]] = []\n            try:\n                rx = re.compile(pattern)\n            except Exception:\n                # If pattern is not a valid regex, escape it\n                rx = re.compile(re.escape(pattern))\n            for fpath in self.indexed_files:\n                rel = os.path.relpath(fpath, self.root)\n                try:\n                    with open(fpath, \"r\", encoding=\"utf-8\", errors=\"ignore\") as rf:\n                        for i, ln in enumerate(rf, start=1):\n                            if rx.search(ln):\n                                rows.append((rel, i, ln.rstrip(\"\\n\")))\n                except Exception:\n                    continue\n            return rows\n\n    # --- Helpers --- #\n\n    def module_for_file(self, path: str) -> Optional[str]:\n        p = path\n        if not os.path.isabs(p):\n            p = os.path.abspath(os.path.join(self.root, path))\n        for mod, mi in self.modules.items():\n            if os.path.abspath(mi.file) == p:\n                return mod\n        return None\n\n    def file_for_module(self, module: str) -> Optional[str]:\n        mi = self.modules.get(module)\n        return mi.file if mi else None\n\n    def tests_for_module(self, module: str) -> List[str]:\n        base = module.split(\".\")[0]\n        out = set(self.module_to_tests.get(base, []))\n        # include direct module key if present\n        out.update(self.module_to_tests.get(module, []))\n        return sorted(out)\n\n    def tests_for_symbol(self, fqn: str) -> List[str]:\n        mod = fqn.rsplit(\".\", 1)[0] if \".\" in fqn else fqn\n        return self.tests_for_module(mod)\n\n    def refs_of(self, fqn: str) -> List[Tuple[str, str]]:\n        \"\"\"Return (caller_fqn, callee_match) entries that reference fqn or its short name.\"\"\"\n        target_short = fqn.split(\".\")[-1]\n        out: List[Tuple[str, str]] = []\n        for caller, callee in self.calls:\n            if callee == fqn or callee.split(\".\")[-1] == target_short:\n                out.append((caller, callee))\n        return out\n\n    def export_json(self) -> Dict[str, Any]:\n        return {\n            \"root\": self.root,\n            \"files\": [os.path.relpath(p, self.root) for p in self.indexed_files],\n            \"symbols\": [self._sym_to_dict(s) for s in self.symbols_by_fqn.values()],\n            \"modules\": {k: self._mi_to_dict(v) for k, v in self.modules.items()},\n            \"calls\": self.calls,\n            \"module_to_tests\": self.module_to_tests,\n            \"coverage_files\": {\n                os.path.relpath(k, self.root): sorted(list(v))\n                for k, v in self.coverage_files.items()\n            },\n            \"symbol_coverage\": self.symbol_coverage,\n            \"module_imports\": self.module_imports,\n        }\n\n    def export_sqlite(self, db_path: str) -> None:\n        import sqlite3\n\n        conn = sqlite3.connect(db_path)\n        cur = conn.cursor()\n        cur.executescript(\n            \"\"\"\n            PRAGMA journal_mode=WAL;\n            CREATE TABLE IF NOT EXISTS files(path TEXT PRIMARY KEY);\n            CREATE TABLE IF NOT EXISTS modules(module TEXT PRIMARY KEY, file TEXT, is_test INT);\n            CREATE TABLE IF NOT EXISTS symbols(\n              fqn TEXT PRIMARY KEY, name TEXT, qualname TEXT, kind TEXT, module TEXT,\n              file TEXT, line INT, end_line INT, doc TEXT, signature TEXT, returns TEXT\n            );\n            CREATE TABLE IF NOT EXISTS calls(caller TEXT, callee TEXT);\n            CREATE TABLE IF NOT EXISTS tests_map(module TEXT, test_module TEXT);\n            CREATE TABLE IF NOT EXISTS coverage(file TEXT, line INT);\n            CREATE TABLE IF NOT EXISTS mod_deps(module TEXT, dep TEXT);\n            \"\"\"\n        )\n        cur.executemany(\n            \"INSERT OR IGNORE INTO files(path) VALUES(?)\",\n            [(os.path.relpath(f, self.root),) for f in self.indexed_files],\n        )\n        cur.executemany(\n            \"INSERT OR REPLACE INTO modules(module,file,is_test) VALUES(?,?,?)\",\n            [\n                (m, os.path.relpath(mi.file, self.root), 1 if mi.is_test else 0)\n                for m, mi in self.modules.items()\n            ],\n        )\n        cur.executemany(\n            \"INSERT OR REPLACE INTO symbols VALUES(?,?,?,?,?,?,?,?,?,?,?)\",\n            [\n                (\n                    s.fqn,\n                    s.name,\n                    s.qualname,\n                    s.kind,\n                    s.module,\n                    os.path.relpath(s.file, self.root),\n                    int(s.line),\n                    int(s.end_line),\n                    s.doc or \"\",\n                    s.signature or \"\",\n                    s.returns or \"\",\n                )\n                for s in self.symbols_by_fqn.values()\n            ],\n        )\n        if self.calls:\n            cur.executemany(\n                \"INSERT INTO calls(caller,callee) VALUES(?,?)\", list(self.calls)\n            )\n        rows = []\n        for mod, tests in self.module_to_tests.items():\n            for t in tests:\n                rows.append((mod, t))\n        if rows:\n            cur.executemany(\n                \"INSERT INTO tests_map(module,test_module) VALUES(?,?)\", rows\n            )\n        cov_rows = []\n        for f, lines in self.coverage_files.items():\n            rel = os.path.relpath(f, self.root)\n            cov_rows.extend([(rel, int(n)) for n in lines])\n        if cov_rows:\n            cur.executemany(\"INSERT INTO coverage(file,line) VALUES(?,?)\", cov_rows)\n        dep_rows = []\n        for m, deps in self.module_imports.items():\n            for d in deps:\n                dep_rows.append((m, d))\n        if dep_rows:\n            cur.executemany(\"INSERT INTO mod_deps(module,dep) VALUES(?,?)\", dep_rows)\n        conn.commit()\n        conn.close()\n\n    def _module_name_for_path(self, path: str) -> str:\n        rel = os.path.relpath(path, self.root)\n        no_ext = rel[:-3] if rel.endswith(\".py\") else rel\n        parts = no_ext.split(os.sep)\n        if parts[-1] == \"__init__\":\n            parts = parts[:-1]\n        return \".\".join(p for p in parts if p)\n\n    def _resolve_callee(\n        self, module: str, callee_key: str, visitor: \"_ModuleVisitor\"\n    ) -> Optional[str]:\n        if \".\" in callee_key and \":\" not in callee_key:\n            return callee_key\n\n        if \":\" in callee_key:\n            mod_alias, name = callee_key.split(\":\", 1)\n            target = visitor.imports.get(mod_alias)\n            if target:\n                return f\"{target}.{name}\" if not target.endswith(f\".{name}\") else target\n\n        mi = self.modules.get(module)\n        if mi:\n            # Prefer any def with same suffix name (matches within class or function)\n            for f in mi.defs:\n                if f.split(\".\")[-1] == callee_key:\n                    return f\n\n        tgt = visitor.imports.get(callee_key)\n        if tgt:\n            return tgt\n        return None\n\n    def _build_test_mapping(self) -> None:\n        for mod, mi in self.modules.items():\n            if not mi.is_test:\n                continue\n            for alias, target in mi.imports.items():\n                # target may be module or module.symbol\n                m = target.split(\".\")[0]\n                self.module_to_tests.setdefault(m, []).append(mod)\n\n    def _expand_star_imports(self) -> None:\n        for mod, stars in self.module_star_imports.items():\n            mi = self.modules.get(mod)\n            if not mi:\n                continue\n            for star_mod in stars:\n                defs = [\n                    f\n                    for f in self.modules.get(\n                        star_mod, ModuleInfo(module=star_mod, file=\"\")\n                    ).defs\n                ]\n                exports = set(\n                    self.modules.get(\n                        star_mod, ModuleInfo(module=star_mod, file=\"\")\n                    ).exports\n                    or []\n                )\n                for fqn in defs:\n                    name = fqn.split(\".\")[-1]\n                    if exports:\n                        if name not in exports:\n                            continue\n                    elif name.startswith(\"_\"):\n                        continue\n                    if name not in mi.imports:\n                        mi.imports[name] = f\"{star_mod}.{name}\"\n\n    def _post_resolve_calls(self) -> None:\n        # After imports expanded, try to resolve unresolved simple names\n        new_calls: List[Tuple[str, str]] = []\n        for caller, callee in self.calls:\n            if \".\" in callee:\n                new_calls.append((caller, callee))\n                continue\n            # Find caller module\n            caller_mod = caller.rsplit(\".\", 1)[0] if \".\" in caller else caller\n            imports = self.modules.get(\n                caller_mod, ModuleInfo(module=caller_mod, file=\"\")\n            ).imports\n            tgt = imports.get(callee)\n            if tgt:\n                new_calls.append((caller, tgt))\n            else:\n                # leave as-is\n                new_calls.append((caller, callee))\n        self.calls = new_calls\n\n    def unresolved_calls(self) -> List[Tuple[str, str]]:\n        return [\n            (a, c)\n            for (a, c) in self.calls\n            if \".\" not in c and not self._is_builtin_name(c)\n        ]\n\n    def _collect_pytest_nodes(self, tree: ast.AST, rel_path: str) -> List[str]:\n        nodes: List[str] = []\n        # top-level test_* functions\n        for n in getattr(tree, \"body\", []) or []:\n            if isinstance(n, ast.FunctionDef) and n.name.startswith(\"test_\"):\n                nodes.extend(self._expand_parametrize(rel_path, None, n))\n            if isinstance(n, ast.ClassDef) and n.name.startswith(\"Test\"):\n                cls = n.name\n                for m in getattr(n, \"body\", []) or []:\n                    if isinstance(m, ast.FunctionDef) and m.name.startswith(\"test_\"):\n                        nodes.extend(self._expand_parametrize(rel_path, cls, m))\n        return nodes\n\n    def _expand_parametrize(\n        self, rel_path: str, cls: Optional[str], fn: ast.FunctionDef\n    ) -> List[str]:\n        base = f\"{rel_path}::\" + (f\"{cls}::\" if cls else \"\") + fn.name\n        # Look for @pytest.mark.parametrize(\"arg\", [vals])\n        total: List[str] = []\n        params: List[int] = []\n        try:\n            for dec in getattr(fn, \"decorator_list\", []) or []:\n                # pytest.mark.parametrize(...)\n                if (\n                    isinstance(dec, ast.Call)\n                    and isinstance(dec.func, ast.Attribute)\n                    and dec.func.attr == \"parametrize\"\n                ):\n                    # estimate number of cases from second arg list length\n                    if len(dec.args) >= 2 and isinstance(\n                        dec.args[1], (ast.List, ast.Tuple)\n                    ):\n                        params.append(len(dec.args[1].elts))\n        except Exception:\n            pass\n        if params:\n            count: int = 1\n            for k in params:\n                try:\n                    count *= int(k)\n                except Exception:\n                    count = max(count, 1)\n            for i in range(count):\n                total.append(f\"{base}[{i}]\")\n            return total\n        return [base]\n\n    # --- Cache --- #\n\n    def _try_load_cache(self\n# ... truncated ...","source_hash":"e28a996e3c22e28318f33e970701e56c53d2becd271f9615a0269e11078879c6","truncated":true}
{"repo_id":"TOLBERT","entity_id":"py:scripts.code_graph._cli","uri":"program://TOLBERT/function/scripts.code_graph._cli#L866-L958","kind":"function","name":"_cli","path":"scripts/code_graph.py","language":"python","start_line":866,"end_line":958,"context_start_line":846,"context_end_line":978,"code":"            for fqn, sym in self.symbols_by_fqn.items():\n                covered = files_hits.get(sym.file, set())\n                a = int(sym.line)\n                b = int(sym.end_line) if int(sym.end_line) >= a else a\n                span = list(range(a, b + 1))\n                if not span:\n                    sym_cov[fqn] = 0.0\n                    continue\n                hits = sum(1 for x in span if x in covered)\n                sym_cov[fqn] = hits / float(len(span))\n            self.symbol_coverage = sym_cov\n        except Exception:\n            # Leave coverage empty on error\n            self.coverage_files = {}\n            self.symbol_coverage = {}\n\n    def coverage_of(self, fqn: str) -> Optional[float]:\n        return self.symbol_coverage.get(fqn)\n\n\ndef _cli() -> None:\n    import argparse\n    import json\n\n    p = argparse.ArgumentParser()\n    p.add_argument(\"root\", nargs=\"?\", default=\"./repo\")\n    p.add_argument(\"--ignore\", action=\"append\", default=None, help=\"Relative paths to ignore (repeatable)\")\n    p.add_argument(\"--owners-of\", dest=\"owners_of\", default=None)\n    p.add_argument(\"--search\", dest=\"search\", default=None)\n    p.add_argument(\"--defs-in\", dest=\"defs_in\", default=None)\n    p.add_argument(\"--calls-of\", dest=\"calls_of\", default=None)\n    p.add_argument(\"--who-calls\", dest=\"who_calls\", default=None)\n    p.add_argument(\"--dump\", dest=\"dump\", action=\"store_true\")\n    p.add_argument(\"--coverage-xml\", dest=\"coverage_xml\", default=None)\n    p.add_argument(\"--coverage-of\", dest=\"coverage_of\", default=None)\n    p.add_argument(\"--refs-of\", dest=\"refs_of\", default=None)\n    p.add_argument(\"--tests-for\", dest=\"tests_for\", default=None)\n    p.add_argument(\"--tests-for-module\", dest=\"tests_for_module\", default=None)\n    p.add_argument(\"--export\", dest=\"export\", default=None)\n    p.add_argument(\"--no-cache\", dest=\"no_cache\", action=\"store_true\")\n    p.add_argument(\"--export-sqlite\", dest=\"export_sqlite\", default=None)\n    p.add_argument(\"--pytest-nodes\", dest=\"pytest_nodes\", default=None)\n    p.add_argument(\"--module-deps\", dest=\"module_deps\", default=None)\n    p.add_argument(\"--unresolved\", dest=\"unresolved\", action=\"store_true\")\n    args = p.parse_args()\n    g = CodeGraph.load_or_build(args.root, ignore_cache=bool(args.no_cache), ignore=[s for s in (args.ignore or []) if s])\n    if args.coverage_xml:\n        g.attach_coverage_from_xml(args.coverage_xml)\n        # fall through to other queries if provided\n    if args.owners_of:\n        print(json.dumps(g.owners_of(args.owners_of)))\n        return\n    if args.search:\n        print(json.dumps(g.search_refs(args.search)))\n        return\n    if args.defs_in:\n        print(json.dumps(g.defs_in(args.defs_in)))\n        return\n    if args.calls_of:\n        print(json.dumps(g.calls_of(args.calls_of)))\n        return\n    if args.who_calls:\n        print(json.dumps(g.who_calls(args.who_calls)))\n        return\n    if args.coverage_of:\n        print(json.dumps(g.coverage_of(args.coverage_of)))\n        return\n    if args.refs_of:\n        print(json.dumps(g.refs_of(args.refs_of)))\n        return\n    if args.tests_for:\n        print(json.dumps(g.tests_for_symbol(args.tests_for)))\n        return\n    if args.tests_for_module:\n        print(json.dumps(g.tests_for_module(args.tests_for_module)))\n        return\n    if args.export:\n        obj = g.export_json()\n        if args.export == \"-\":\n            print(json.dumps(obj))\n        else:\n            open(args.export, \"w\", encoding=\"utf-8\").write(json.dumps(obj))\n            print(args.export)\n        return\n    if args.export_sqlite:\n        g.export_sqlite(args.export_sqlite)\n        print(args.export_sqlite)\n        return\n    if args.pytest_nodes:\n        mod = args.pytest_nodes\n        print(json.dumps(g.pytest_nodes_by_module.get(mod, [])))\n        return\n    if args.module_deps:\n        print(json.dumps(g.module_imports.get(args.module_deps, [])))\n        return\n    if args.unresolved:\n        print(json.dumps(g.unresolved_calls()))\n        return\n    if args.dump:\n        print(\n            json.dumps(\n                {\n                    \"files\": len(g.indexed_files),\n                    \"symbols\": len(g.symbols_by_fqn),\n                    \"modules\": len(g.modules),\n                    \"calls\": len(g.calls),\n                    \"coverage_files\": len(g.coverage_files),\n                }\n            )\n        )\n        return\n    # Dump summary\n    print(json.dumps({\"files\": len(g.indexed_files), \"symbols\": len(g.symbols_by_fqn)}))\n\n\nclass _ModuleVisitor(ast.NodeVisitor):\n    def __init__(self, module: str, path: str) -> None:\n        self.module = module\n        self.path = path\n        self.symbols: List[Symbol] = []\n        self.calls: List[Tuple[str, str]] = []  # (caller_fqn, callee_key)\n        self.stack: List[str] = []  # qualname stack\n        self.class_stack: List[str] = []\n        self.imports: Dict[str, str] = {}\n        self.import_modules: List[str] = []\n        self.star_imports: List[str] = []\n        self.exports: List[str] = []\n\n    def _cur_qualname(self) -> str:\n        return \".\".join(self.stack)\n\n    def _cur_class(self) -> Optional[str]:\n        return self.class_stack[-1] if self.class_stack else None","source_hash":"e28a996e3c22e28318f33e970701e56c53d2becd271f9615a0269e11078879c6","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.code_graph._ModuleVisitor","uri":"program://TOLBERT/class/scripts.code_graph._ModuleVisitor#L961-L1193","kind":"class","name":"_ModuleVisitor","path":"scripts/code_graph.py","language":"python","start_line":961,"end_line":1193,"context_start_line":941,"context_end_line":1197,"code":"    if args.unresolved:\n        print(json.dumps(g.unresolved_calls()))\n        return\n    if args.dump:\n        print(\n            json.dumps(\n                {\n                    \"files\": len(g.indexed_files),\n                    \"symbols\": len(g.symbols_by_fqn),\n                    \"modules\": len(g.modules),\n                    \"calls\": len(g.calls),\n                    \"coverage_files\": len(g.coverage_files),\n                }\n            )\n        )\n        return\n    # Dump summary\n    print(json.dumps({\"files\": len(g.indexed_files), \"symbols\": len(g.symbols_by_fqn)}))\n\n\nclass _ModuleVisitor(ast.NodeVisitor):\n    def __init__(self, module: str, path: str) -> None:\n        self.module = module\n        self.path = path\n        self.symbols: List[Symbol] = []\n        self.calls: List[Tuple[str, str]] = []  # (caller_fqn, callee_key)\n        self.stack: List[str] = []  # qualname stack\n        self.class_stack: List[str] = []\n        self.imports: Dict[str, str] = {}\n        self.import_modules: List[str] = []\n        self.star_imports: List[str] = []\n        self.exports: List[str] = []\n\n    def _cur_qualname(self) -> str:\n        return \".\".join(self.stack)\n\n    def _cur_class(self) -> Optional[str]:\n        return self.class_stack[-1] if self.class_stack else None\n\n    def _fqn(self, name: str) -> str:\n        q = self._cur_qualname()\n        return f\"{self.module}.{q + ('.' if q else '')}{name}\"\n\n    def visit_Import(self, node: ast.Import) -> Any:  # type: ignore[override]\n        for alias in node.names:\n            asname = alias.asname or alias.name.split(\".\")[-1]\n            self.imports[asname] = alias.name\n            self.import_modules.append(alias.name.split(\".\")[0])\n        self.generic_visit(node)\n\n    def visit_ImportFrom(self, node: ast.ImportFrom) -> Any:  # type: ignore[override]\n        # Resolve relative imports: from .x import y\n        if node.level and node.module:\n            base = self.module.split(\".\")\n            up = max(0, int(node.level))\n            prefix = base[:-up] if up > 0 else base\n            mod = \".\".join([p for p in prefix if p] + [node.module])\n        elif node.level and not node.module:\n            base = self.module.split(\".\")\n            up = max(0, int(node.level))\n            mod = \".\".join(base[:-up])\n        else:\n            mod = node.module or \"\"\n        for alias in node.names:\n            # star import\n            if getattr(alias, \"name\", \"\") == \"*\":\n                if mod:\n                    self.star_imports.append(mod)\n                continue\n            asname = alias.asname or alias.name\n            self.imports[asname] = f\"{mod}.{alias.name}\" if mod else alias.name\n        if mod:\n            self.import_modules.append(mod.split(\".\")[0])\n        self.generic_visit(node)\n\n    def visit_ClassDef(self, node: ast.ClassDef) -> Any:  # type: ignore[override]\n        fqn = self._fqn(node.name)\n        try:\n            doc_s = ast.get_docstring(node) or None\n        except Exception:\n            doc_s = None\n        sym = Symbol(\n            fqn=fqn,\n            name=node.name,\n            qualname=self._cur_qualname(),\n            kind=\"class\",\n            module=self.module,\n            file=self.path,\n            line=getattr(node, \"lineno\", 1),\n            end_line=getattr(node, \"end_lineno\", getattr(node, \"lineno\", 1)),\n            doc=doc_s,\n        )\n        self.symbols.append(sym)\n        self.stack.append(node.name)\n        self.class_stack.append(node.name)\n        self.generic_visit(node)\n        self.class_stack.pop()\n        self.stack.pop()\n\n    def visit_FunctionDef(self, node: ast.FunctionDef) -> Any:  # type: ignore[override]\n        self._visit_func_like(node)\n\n    def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef) -> Any:  # type: ignore[override]\n        self._visit_func_like(node)\n\n    def _visit_func_like(self, node: Any) -> None:\n        fqn = self._fqn(node.name)\n        # Signature & returns\n        sig_s, ret_s = None, None\n        try:\n            params = []\n            for a in getattr(node, \"args\", None).args or []:\n                nm = getattr(a, \"arg\", \"\")\n                ann = getattr(a, \"annotation\", None)\n                params.append(f\"{nm}:{ast.unparse(ann)}\" if ann is not None else nm)\n            ret = getattr(node, \"returns\", None)\n            ret_s = ast.unparse(ret) if ret is not None else None\n            sig_s = f\"({', '.join(params)})\"\n        except Exception:\n            sig_s, ret_s = None, None\n        try:\n            doc_s = ast.get_docstring(node) or None\n        except Exception:\n            doc_s = None\n        sym = Symbol(\n            fqn=fqn,\n            name=node.name,\n            qualname=self._cur_qualname(),\n            kind=\"function\",\n            module=self.module,\n            file=self.path,\n            line=getattr(node, \"lineno\", 1),\n            end_line=getattr(node, \"end_lineno\", getattr(node, \"lineno\", 1)),\n            doc=doc_s,\n            signature=sig_s,\n            returns=ret_s,\n        )\n        self.symbols.append(sym)\n        self.stack.append(node.name)\n        # Traverse body to collect calls\n        for sub in ast.walk(node):\n            if isinstance(sub, ast.Call):\n                callee_key = self._extract_callee_key(sub.func)\n                if callee_key:\n                    self.calls.append((fqn, callee_key))\n        # Decorators as calls\n        for dec in getattr(node, \"decorator_list\", []) or []:\n            callee_key = self._extract_callee_key(dec)\n            if callee_key:\n                self.calls.append((fqn, callee_key))\n        self.stack.pop()\n\n    def visit_Assign(self, node: ast.Assign) -> Any:  # type: ignore[override]\n        for t in getattr(node, \"targets\", []) or []:\n            if isinstance(t, ast.Name):\n                fqn = self._fqn(t.id)\n                sym = Symbol(\n                    fqn=fqn,\n                    name=t.id,\n                    qualname=self._cur_qualname(),\n                    kind=\"variable\",\n                    module=self.module,\n                    file=self.path,\n                    line=getattr(node, \"lineno\", 1),\n                    end_line=getattr(node, \"end_lineno\", getattr(node, \"lineno\", 1)),\n                )\n                self.symbols.append(sym)\n        # capture __all__ = [\"...\"]\n        try:\n            names = []\n            is_all = any(\n                (isinstance(t, ast.Name) and t.id == \"__all__\") for t in node.targets\n            )\n            if is_all and isinstance(node.value, (ast.List, ast.Tuple)):\n                for el in node.value.elts:\n                    if isinstance(el, ast.Constant) and isinstance(el.value, str):\n                        names.append(el.value)\n            if names:\n                self.exports.extend(names)\n        except Exception:\n            pass\n        self.generic_visit(node)\n\n    def _extract_callee_key(self, fn: ast.AST) -> Optional[str]:\n        # simple name\n        if isinstance(fn, ast.Name):\n            return fn.id\n\n        # super().method()\n        if (\n            isinstance(fn, ast.Attribute)\n            and isinstance(fn.value, ast.Call)\n            and isinstance(fn.value.func, ast.Name)\n            and fn.value.func.id == \"super\"\n        ):\n            meth = fn.attr\n            cur_cls = self._cur_class()\n            if cur_cls:\n                return f\"{self.module}.{cur_cls}.{meth}\"\n            return meth\n\n        # obj.attr chain\n        if isinstance(fn, ast.Attribute):\n            parts: List[str] = []\n            cur = fn\n            while isinstance(cur, ast.Attribute):\n                parts.append(cur.attr)\n                cur = cur.value\n            parts.reverse()\n\n            if isinstance(cur, ast.Name):\n                base = cur.id\n                if base in (\"self\", \"cls\"):\n                    cur_cls = self._cur_class()\n                    if cur_cls and parts:\n                        return f\"{self.module}.{cur_cls}.{parts[-1]}\"\n                    return f\"{self.module}.{cur_cls}\" if cur_cls else parts[-1]\n                if base in self.imports:\n                    return f\"{base}:{parts[-1]}\" if parts else base\n                return f\"{self.module}.{base}.{parts[-1]}\" if parts else base\n        # getattr(module, \"name\") heuristic\n        if (\n            isinstance(fn, ast.Call)\n            and isinstance(fn.func, ast.Name)\n            and fn.func.id == \"getattr\"\n            and fn.args\n            and len(fn.args) >= 2\n            and isinstance(fn.args[0], ast.Name)\n            and isinstance(fn.args[1], ast.Constant)\n            and isinstance(fn.args[1].value, str)\n        ):\n            base = fn.args[0].id\n            name = fn.args[1].value\n            if base in self.imports:\n                return f\"{self.imports[base]}.{name}\"\n            cur_cls = self._cur_class()\n            if base in (\"self\", \"cls\") and cur_cls:\n                return f\"{self.module}.{cur_cls}.{name}\"\n            return f\"{self.module}.{base}.{name}\"\n        # importlib.import_module(\"pkg.mod\") heuristic\n        if (\n            isinstance(fn, ast.Call)\n            and isinstance(fn.func, ast.Attribute)\n            and isinstance(fn.func.value, ast.Name)\n            and fn.func.value.id == \"importlib\"\n            and fn.func.attr == \"import_module\"\n            and fn.args\n            and isinstance(fn.args[0], ast.Constant)\n            and isinstance(fn.args[0].value, str)\n        ):\n            mod = str(fn.args[0].value)\n            return mod\n        return None\n\n\nif __name__ == \"__main__\":\n    _cli()","source_hash":"e28a996e3c22e28318f33e970701e56c53d2becd271f9615a0269e11078879c6","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.code_graph.__init__","uri":"program://TOLBERT/function/scripts.code_graph.__init__#L962-L972","kind":"function","name":"__init__","path":"scripts/code_graph.py","language":"python","start_line":962,"end_line":972,"context_start_line":942,"context_end_line":992,"code":"        print(json.dumps(g.unresolved_calls()))\n        return\n    if args.dump:\n        print(\n            json.dumps(\n                {\n                    \"files\": len(g.indexed_files),\n                    \"symbols\": len(g.symbols_by_fqn),\n                    \"modules\": len(g.modules),\n                    \"calls\": len(g.calls),\n                    \"coverage_files\": len(g.coverage_files),\n                }\n            )\n        )\n        return\n    # Dump summary\n    print(json.dumps({\"files\": len(g.indexed_files), \"symbols\": len(g.symbols_by_fqn)}))\n\n\nclass _ModuleVisitor(ast.NodeVisitor):\n    def __init__(self, module: str, path: str) -> None:\n        self.module = module\n        self.path = path\n        self.symbols: List[Symbol] = []\n        self.calls: List[Tuple[str, str]] = []  # (caller_fqn, callee_key)\n        self.stack: List[str] = []  # qualname stack\n        self.class_stack: List[str] = []\n        self.imports: Dict[str, str] = {}\n        self.import_modules: List[str] = []\n        self.star_imports: List[str] = []\n        self.exports: List[str] = []\n\n    def _cur_qualname(self) -> str:\n        return \".\".join(self.stack)\n\n    def _cur_class(self) -> Optional[str]:\n        return self.class_stack[-1] if self.class_stack else None\n\n    def _fqn(self, name: str) -> str:\n        q = self._cur_qualname()\n        return f\"{self.module}.{q + ('.' if q else '')}{name}\"\n\n    def visit_Import(self, node: ast.Import) -> Any:  # type: ignore[override]\n        for alias in node.names:\n            asname = alias.asname or alias.name.split(\".\")[-1]\n            self.imports[asname] = alias.name\n            self.import_modules.append(alias.name.split(\".\")[0])\n        self.generic_visit(node)\n\n    def visit_ImportFrom(self, node: ast.ImportFrom) -> Any:  # type: ignore[override]\n        # Resolve relative imports: from .x import y","source_hash":"e28a996e3c22e28318f33e970701e56c53d2becd271f9615a0269e11078879c6","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.code_graph._is_ignored","uri":"program://TOLBERT/function/scripts.code_graph._is_ignored#L78-L92","kind":"function","name":"_is_ignored","path":"scripts/code_graph.py","language":"python","start_line":78,"end_line":92,"context_start_line":58,"context_end_line":112,"code":"            if pathspec is not None and os.path.exists(gi):\n                with open(gi, \"r\", encoding=\"utf-8\", errors=\"ignore\") as fh:\n                    lines = [ln.rstrip(\"\\n\") for ln in fh]\n                self._pspec = pathspec.PathSpec.from_lines(\"gitwildmatch\", lines)\n        except Exception:\n            self._pspec = None\n        self.symbols_by_fqn: Dict[str, Symbol] = {}\n        self.symbols_by_name: Dict[str, List[str]] = {}\n        self.modules: Dict[str, ModuleInfo] = {}\n        self.indexed_files: List[str] = []\n        self.calls: List[Tuple[str, str]] = []  # (caller_fqn, callee_fqn_or_key)\n        self.module_to_tests: Dict[str, List[str]] = {}\n        self.coverage_files: Dict[str, set[int]] = {}\n        self.symbol_coverage: Dict[str, float] = {}\n        self.module_imports: Dict[str, List[str]] = {}\n        self.module_star_imports: Dict[str, List[str]] = {}\n        self.pytest_nodes_by_module: Dict[str, List[str]] = {}\n        self._cached_mtimes: Dict[str, int] = {}\n        self._cached_hashes: Dict[str, str] = {}\n\n    def _is_ignored(self, rel: str) -> bool:\n        try:\n            r = rel.replace(os.sep, \"/\")\n            # pathspec first\n            if self._pspec is not None:\n                if self._pspec.match_file(r):\n                    return True\n            # fallback: prefix match\n            for pat in self._ignore:\n                pp = pat.replace(os.sep, \"/\")\n                if r == pp or r.startswith(pp + \"/\"):\n                    return True\n            return False\n        except Exception:\n            return False\n\n    @classmethod\n    def load_or_build(cls, root: str, *, ignore_cache: bool = False, ignore: Optional[List[str]] = None) -> \"CodeGraph\":\n        g = cls(root=root, ignore=ignore)\n        g.build(ignore_cache=ignore_cache)\n        return g\n\n    def build(self, ignore_cache: bool = False) -> None:\n        cache_path = os.path.join(self.root, \".codegraph.json\")\n        if (not ignore_cache) and self._load_cache_relaxed(cache_path):\n            # Incremental: reindex changed and dependents\n            changed, removed = self._detect_changed_files(\n                self._cached_mtimes, self._cached_hashes\n            )\n            if not changed and not removed:\n                return\n            self._incremental_reindex(changed, removed)\n            self._expand_star_imports()\n            self._post_resolve_calls()\n            self._save_cache(cache_path)","source_hash":"e28a996e3c22e28318f33e970701e56c53d2becd271f9615a0269e11078879c6","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.code_graph.load_or_build","uri":"program://TOLBERT/function/scripts.code_graph.load_or_build#L95-L98","kind":"function","name":"load_or_build","path":"scripts/code_graph.py","language":"python","start_line":95,"end_line":98,"context_start_line":75,"context_end_line":118,"code":"        self._cached_mtimes: Dict[str, int] = {}\n        self._cached_hashes: Dict[str, str] = {}\n\n    def _is_ignored(self, rel: str) -> bool:\n        try:\n            r = rel.replace(os.sep, \"/\")\n            # pathspec first\n            if self._pspec is not None:\n                if self._pspec.match_file(r):\n                    return True\n            # fallback: prefix match\n            for pat in self._ignore:\n                pp = pat.replace(os.sep, \"/\")\n                if r == pp or r.startswith(pp + \"/\"):\n                    return True\n            return False\n        except Exception:\n            return False\n\n    @classmethod\n    def load_or_build(cls, root: str, *, ignore_cache: bool = False, ignore: Optional[List[str]] = None) -> \"CodeGraph\":\n        g = cls(root=root, ignore=ignore)\n        g.build(ignore_cache=ignore_cache)\n        return g\n\n    def build(self, ignore_cache: bool = False) -> None:\n        cache_path = os.path.join(self.root, \".codegraph.json\")\n        if (not ignore_cache) and self._load_cache_relaxed(cache_path):\n            # Incremental: reindex changed and dependents\n            changed, removed = self._detect_changed_files(\n                self._cached_mtimes, self._cached_hashes\n            )\n            if not changed and not removed:\n                return\n            self._incremental_reindex(changed, removed)\n            self._expand_star_imports()\n            self._post_resolve_calls()\n            self._save_cache(cache_path)\n            return\n        for dirpath, dirnames, filenames in os.walk(self.root):\n            # prune ignored directories in-place\n            dir_rel = os.path.relpath(dirpath, self.root)\n            # remove child dirs that are ignored\n            dirnames[:] = [d for d in dirnames if not self._is_ignored(os.path.join(dir_rel, d))]","source_hash":"e28a996e3c22e28318f33e970701e56c53d2becd271f9615a0269e11078879c6","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.code_graph.build","uri":"program://TOLBERT/function/scripts.code_graph.build#L100-L142","kind":"function","name":"build","path":"scripts/code_graph.py","language":"python","start_line":100,"end_line":142,"context_start_line":80,"context_end_line":162,"code":"            r = rel.replace(os.sep, \"/\")\n            # pathspec first\n            if self._pspec is not None:\n                if self._pspec.match_file(r):\n                    return True\n            # fallback: prefix match\n            for pat in self._ignore:\n                pp = pat.replace(os.sep, \"/\")\n                if r == pp or r.startswith(pp + \"/\"):\n                    return True\n            return False\n        except Exception:\n            return False\n\n    @classmethod\n    def load_or_build(cls, root: str, *, ignore_cache: bool = False, ignore: Optional[List[str]] = None) -> \"CodeGraph\":\n        g = cls(root=root, ignore=ignore)\n        g.build(ignore_cache=ignore_cache)\n        return g\n\n    def build(self, ignore_cache: bool = False) -> None:\n        cache_path = os.path.join(self.root, \".codegraph.json\")\n        if (not ignore_cache) and self._load_cache_relaxed(cache_path):\n            # Incremental: reindex changed and dependents\n            changed, removed = self._detect_changed_files(\n                self._cached_mtimes, self._cached_hashes\n            )\n            if not changed and not removed:\n                return\n            self._incremental_reindex(changed, removed)\n            self._expand_star_imports()\n            self._post_resolve_calls()\n            self._save_cache(cache_path)\n            return\n        for dirpath, dirnames, filenames in os.walk(self.root):\n            # prune ignored directories in-place\n            dir_rel = os.path.relpath(dirpath, self.root)\n            # remove child dirs that are ignored\n            dirnames[:] = [d for d in dirnames if not self._is_ignored(os.path.join(dir_rel, d))]\n            if self._is_ignored(dir_rel):\n                continue\n            for fn in filenames:\n                if not fn.endswith(\".py\"):\n                    continue\n                fpath = os.path.join(dirpath, fn)\n                if self._is_ignored(os.path.relpath(fpath, self.root)):\n                    continue\n                try:\n                    src = open(fpath, \"r\", encoding=\"utf-8\").read()\n                except Exception:\n                    continue\n                try:\n                    tree = ast.parse(src)\n                except Exception:\n                    continue\n                self.indexed_files.append(fpath)\n                self._index_module(fpath, tree)\n        # Build test mapping from imports in test modules\n        self._build_test_mapping()\n        # Expand star imports and post-resolve call targets\n        self._expand_star_imports()\n        self._post_resolve_calls()\n        self._save_cache(cache_path)\n\n    def _add_symbol(self, sym: Symbol) -> None:\n        self.symbols_by_fqn[sym.fqn] = sym\n        self.symbols_by_name.setdefault(sym.name, []).append(sym.fqn)\n        mi = self.modules.setdefault(\n            sym.module, ModuleInfo(module=sym.module, file=sym.file)\n        )\n        if sym.fqn not in mi.defs:\n            mi.defs.append(sym.fqn)\n\n    def _index_module(self, path: str, tree: ast.AST) -> None:\n        module = self._module_name_for_path(path)\n        is_test = (\"/tests/\" in path) or (os.path.basename(path).startswith(\"test_\"))\n        self.modules.setdefault(\n            module, ModuleInfo(module=module, file=path, is_test=is_test)\n        )\n        # Add module symbol\n        mod_fqn = module\n        mod_name = module.split(\".\")[-1]\n        self._add_symbol(","source_hash":"e28a996e3c22e28318f33e970701e56c53d2becd271f9615a0269e11078879c6","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.code_graph._add_symbol","uri":"program://TOLBERT/function/scripts.code_graph._add_symbol#L144-L151","kind":"function","name":"_add_symbol","path":"scripts/code_graph.py","language":"python","start_line":144,"end_line":151,"context_start_line":124,"context_end_line":171,"code":"                fpath = os.path.join(dirpath, fn)\n                if self._is_ignored(os.path.relpath(fpath, self.root)):\n                    continue\n                try:\n                    src = open(fpath, \"r\", encoding=\"utf-8\").read()\n                except Exception:\n                    continue\n                try:\n                    tree = ast.parse(src)\n                except Exception:\n                    continue\n                self.indexed_files.append(fpath)\n                self._index_module(fpath, tree)\n        # Build test mapping from imports in test modules\n        self._build_test_mapping()\n        # Expand star imports and post-resolve call targets\n        self._expand_star_imports()\n        self._post_resolve_calls()\n        self._save_cache(cache_path)\n\n    def _add_symbol(self, sym: Symbol) -> None:\n        self.symbols_by_fqn[sym.fqn] = sym\n        self.symbols_by_name.setdefault(sym.name, []).append(sym.fqn)\n        mi = self.modules.setdefault(\n            sym.module, ModuleInfo(module=sym.module, file=sym.file)\n        )\n        if sym.fqn not in mi.defs:\n            mi.defs.append(sym.fqn)\n\n    def _index_module(self, path: str, tree: ast.AST) -> None:\n        module = self._module_name_for_path(path)\n        is_test = (\"/tests/\" in path) or (os.path.basename(path).startswith(\"test_\"))\n        self.modules.setdefault(\n            module, ModuleInfo(module=module, file=path, is_test=is_test)\n        )\n        # Add module symbol\n        mod_fqn = module\n        mod_name = module.split(\".\")[-1]\n        self._add_symbol(\n            Symbol(\n                fqn=mod_fqn,\n                name=mod_name,\n                qualname=\"\",\n                kind=\"module\",\n                module=module,\n                file=path,\n                line=1,\n                end_line=1,","source_hash":"e28a996e3c22e28318f33e970701e56c53d2becd271f9615a0269e11078879c6","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.code_graph._index_module","uri":"program://TOLBERT/function/scripts.code_graph._index_module#L153-L195","kind":"function","name":"_index_module","path":"scripts/code_graph.py","language":"python","start_line":153,"end_line":195,"context_start_line":133,"context_end_line":215,"code":"                except Exception:\n                    continue\n                self.indexed_files.append(fpath)\n                self._index_module(fpath, tree)\n        # Build test mapping from imports in test modules\n        self._build_test_mapping()\n        # Expand star imports and post-resolve call targets\n        self._expand_star_imports()\n        self._post_resolve_calls()\n        self._save_cache(cache_path)\n\n    def _add_symbol(self, sym: Symbol) -> None:\n        self.symbols_by_fqn[sym.fqn] = sym\n        self.symbols_by_name.setdefault(sym.name, []).append(sym.fqn)\n        mi = self.modules.setdefault(\n            sym.module, ModuleInfo(module=sym.module, file=sym.file)\n        )\n        if sym.fqn not in mi.defs:\n            mi.defs.append(sym.fqn)\n\n    def _index_module(self, path: str, tree: ast.AST) -> None:\n        module = self._module_name_for_path(path)\n        is_test = (\"/tests/\" in path) or (os.path.basename(path).startswith(\"test_\"))\n        self.modules.setdefault(\n            module, ModuleInfo(module=module, file=path, is_test=is_test)\n        )\n        # Add module symbol\n        mod_fqn = module\n        mod_name = module.split(\".\")[-1]\n        self._add_symbol(\n            Symbol(\n                fqn=mod_fqn,\n                name=mod_name,\n                qualname=\"\",\n                kind=\"module\",\n                module=module,\n                file=path,\n                line=1,\n                end_line=1,\n            )\n        )\n        # Visit\n        visitor = _ModuleVisitor(module, path)\n        visitor.visit(tree)\n        # Register imports\n        self.modules[module].imports.update(visitor.imports)\n        # Module dependency edges\n        self.module_imports[module] = sorted(visitor.import_modules)\n        # Record star imports for later expansion\n        self.module_star_imports[module] = list(getattr(visitor, \"star_imports\", []))\n        # Record __all__ exports\n        self.modules[module].exports = list(getattr(visitor, \"exports\", []))\n        # Register defs\n        for sym in visitor.symbols:\n            self._add_symbol(sym)\n        # Register calls\n        for caller, callee_key in visitor.calls:\n            callee_fqn = self._resolve_callee(module, callee_key, visitor)\n            self.calls.append((caller, callee_fqn or callee_key))\n        # Collect pytest nodes if test module\n        if is_test:\n            rel = os.path.relpath(path, self.root)\n            self.pytest_nodes_by_module[module] = self._collect_pytest_nodes(tree, rel)\n\n    def owners_of(self, symbol: str) -> List[str]:\n        fqns = self.symbols_by_name.get(symbol, [])\n        return sorted(\n            {os.path.relpath(self.symbols_by_fqn[f].file, self.root) for f in fqns}\n        )\n\n    def find_symbol(self, name: str) -> List[Symbol]:\n        return [self.symbols_by_fqn[f] for f in self.symbols_by_name.get(name, [])]\n\n    def defs_in(self, module: str) -> List[str]:\n        mi = self.modules.get(module)\n        return list(mi.defs) if mi else []\n\n    def calls_of(self, fqn: str) -> List[str]:\n        return [c for (caller, c) in self.calls if caller == fqn]\n\n    def who_calls(self, fqn: str) -> List[str]:\n        target_short = fqn.split(\".\")[-1]\n        out: List[str] = []","source_hash":"e28a996e3c22e28318f33e970701e56c53d2becd271f9615a0269e11078879c6","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.code_graph.owners_of","uri":"program://TOLBERT/function/scripts.code_graph.owners_of#L197-L201","kind":"function","name":"owners_of","path":"scripts/code_graph.py","language":"python","start_line":197,"end_line":201,"context_start_line":177,"context_end_line":221,"code":"        # Register imports\n        self.modules[module].imports.update(visitor.imports)\n        # Module dependency edges\n        self.module_imports[module] = sorted(visitor.import_modules)\n        # Record star imports for later expansion\n        self.module_star_imports[module] = list(getattr(visitor, \"star_imports\", []))\n        # Record __all__ exports\n        self.modules[module].exports = list(getattr(visitor, \"exports\", []))\n        # Register defs\n        for sym in visitor.symbols:\n            self._add_symbol(sym)\n        # Register calls\n        for caller, callee_key in visitor.calls:\n            callee_fqn = self._resolve_callee(module, callee_key, visitor)\n            self.calls.append((caller, callee_fqn or callee_key))\n        # Collect pytest nodes if test module\n        if is_test:\n            rel = os.path.relpath(path, self.root)\n            self.pytest_nodes_by_module[module] = self._collect_pytest_nodes(tree, rel)\n\n    def owners_of(self, symbol: str) -> List[str]:\n        fqns = self.symbols_by_name.get(symbol, [])\n        return sorted(\n            {os.path.relpath(self.symbols_by_fqn[f].file, self.root) for f in fqns}\n        )\n\n    def find_symbol(self, name: str) -> List[Symbol]:\n        return [self.symbols_by_fqn[f] for f in self.symbols_by_name.get(name, [])]\n\n    def defs_in(self, module: str) -> List[str]:\n        mi = self.modules.get(module)\n        return list(mi.defs) if mi else []\n\n    def calls_of(self, fqn: str) -> List[str]:\n        return [c for (caller, c) in self.calls if caller == fqn]\n\n    def who_calls(self, fqn: str) -> List[str]:\n        target_short = fqn.split(\".\")[-1]\n        out: List[str] = []\n        for caller, callee in self.calls:\n            if callee == fqn or callee.split(\".\")[-1] == target_short:\n                out.append(caller)\n        return out\n\n    def search_refs(self, pattern: str) -> List[Tuple[str, int, str]]:","source_hash":"e28a996e3c22e28318f33e970701e56c53d2becd271f9615a0269e11078879c6","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.code_graph.find_symbol","uri":"program://TOLBERT/function/scripts.code_graph.find_symbol#L203-L204","kind":"function","name":"find_symbol","path":"scripts/code_graph.py","language":"python","start_line":203,"end_line":204,"context_start_line":183,"context_end_line":224,"code":"        # Record __all__ exports\n        self.modules[module].exports = list(getattr(visitor, \"exports\", []))\n        # Register defs\n        for sym in visitor.symbols:\n            self._add_symbol(sym)\n        # Register calls\n        for caller, callee_key in visitor.calls:\n            callee_fqn = self._resolve_callee(module, callee_key, visitor)\n            self.calls.append((caller, callee_fqn or callee_key))\n        # Collect pytest nodes if test module\n        if is_test:\n            rel = os.path.relpath(path, self.root)\n            self.pytest_nodes_by_module[module] = self._collect_pytest_nodes(tree, rel)\n\n    def owners_of(self, symbol: str) -> List[str]:\n        fqns = self.symbols_by_name.get(symbol, [])\n        return sorted(\n            {os.path.relpath(self.symbols_by_fqn[f].file, self.root) for f in fqns}\n        )\n\n    def find_symbol(self, name: str) -> List[Symbol]:\n        return [self.symbols_by_fqn[f] for f in self.symbols_by_name.get(name, [])]\n\n    def defs_in(self, module: str) -> List[str]:\n        mi = self.modules.get(module)\n        return list(mi.defs) if mi else []\n\n    def calls_of(self, fqn: str) -> List[str]:\n        return [c for (caller, c) in self.calls if caller == fqn]\n\n    def who_calls(self, fqn: str) -> List[str]:\n        target_short = fqn.split(\".\")[-1]\n        out: List[str] = []\n        for caller, callee in self.calls:\n            if callee == fqn or callee.split(\".\")[-1] == target_short:\n                out.append(caller)\n        return out\n\n    def search_refs(self, pattern: str) -> List[Tuple[str, int, str]]:\n        \"\"\"Ripgrep-based raw reference search (file, line_no, text).\"\"\"\n        try:\n            import subprocess","source_hash":"e28a996e3c22e28318f33e970701e56c53d2becd271f9615a0269e11078879c6","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.code_graph.defs_in","uri":"program://TOLBERT/function/scripts.code_graph.defs_in#L206-L208","kind":"function","name":"defs_in","path":"scripts/code_graph.py","language":"python","start_line":206,"end_line":208,"context_start_line":186,"context_end_line":228,"code":"        for sym in visitor.symbols:\n            self._add_symbol(sym)\n        # Register calls\n        for caller, callee_key in visitor.calls:\n            callee_fqn = self._resolve_callee(module, callee_key, visitor)\n            self.calls.append((caller, callee_fqn or callee_key))\n        # Collect pytest nodes if test module\n        if is_test:\n            rel = os.path.relpath(path, self.root)\n            self.pytest_nodes_by_module[module] = self._collect_pytest_nodes(tree, rel)\n\n    def owners_of(self, symbol: str) -> List[str]:\n        fqns = self.symbols_by_name.get(symbol, [])\n        return sorted(\n            {os.path.relpath(self.symbols_by_fqn[f].file, self.root) for f in fqns}\n        )\n\n    def find_symbol(self, name: str) -> List[Symbol]:\n        return [self.symbols_by_fqn[f] for f in self.symbols_by_name.get(name, [])]\n\n    def defs_in(self, module: str) -> List[str]:\n        mi = self.modules.get(module)\n        return list(mi.defs) if mi else []\n\n    def calls_of(self, fqn: str) -> List[str]:\n        return [c for (caller, c) in self.calls if caller == fqn]\n\n    def who_calls(self, fqn: str) -> List[str]:\n        target_short = fqn.split(\".\")[-1]\n        out: List[str] = []\n        for caller, callee in self.calls:\n            if callee == fqn or callee.split(\".\")[-1] == target_short:\n                out.append(caller)\n        return out\n\n    def search_refs(self, pattern: str) -> List[Tuple[str, int, str]]:\n        \"\"\"Ripgrep-based raw reference search (file, line_no, text).\"\"\"\n        try:\n            import subprocess\n\n            out = subprocess.check_output([\"rg\", \"-n\", pattern, self.root], text=True)\n            rows: List[Tuple[str, int, str]] = []\n            for line in out.splitlines():","source_hash":"e28a996e3c22e28318f33e970701e56c53d2becd271f9615a0269e11078879c6","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.code_graph.calls_of","uri":"program://TOLBERT/function/scripts.code_graph.calls_of#L210-L211","kind":"function","name":"calls_of","path":"scripts/code_graph.py","language":"python","start_line":210,"end_line":211,"context_start_line":190,"context_end_line":231,"code":"            callee_fqn = self._resolve_callee(module, callee_key, visitor)\n            self.calls.append((caller, callee_fqn or callee_key))\n        # Collect pytest nodes if test module\n        if is_test:\n            rel = os.path.relpath(path, self.root)\n            self.pytest_nodes_by_module[module] = self._collect_pytest_nodes(tree, rel)\n\n    def owners_of(self, symbol: str) -> List[str]:\n        fqns = self.symbols_by_name.get(symbol, [])\n        return sorted(\n            {os.path.relpath(self.symbols_by_fqn[f].file, self.root) for f in fqns}\n        )\n\n    def find_symbol(self, name: str) -> List[Symbol]:\n        return [self.symbols_by_fqn[f] for f in self.symbols_by_name.get(name, [])]\n\n    def defs_in(self, module: str) -> List[str]:\n        mi = self.modules.get(module)\n        return list(mi.defs) if mi else []\n\n    def calls_of(self, fqn: str) -> List[str]:\n        return [c for (caller, c) in self.calls if caller == fqn]\n\n    def who_calls(self, fqn: str) -> List[str]:\n        target_short = fqn.split(\".\")[-1]\n        out: List[str] = []\n        for caller, callee in self.calls:\n            if callee == fqn or callee.split(\".\")[-1] == target_short:\n                out.append(caller)\n        return out\n\n    def search_refs(self, pattern: str) -> List[Tuple[str, int, str]]:\n        \"\"\"Ripgrep-based raw reference search (file, line_no, text).\"\"\"\n        try:\n            import subprocess\n\n            out = subprocess.check_output([\"rg\", \"-n\", pattern, self.root], text=True)\n            rows: List[Tuple[str, int, str]] = []\n            for line in out.splitlines():\n                try:\n                    fp, ln, txt = line.split(\":\", 2)\n                    rows.append((os.path.relpath(fp, self.root), int(ln), txt))","source_hash":"e28a996e3c22e28318f33e970701e56c53d2becd271f9615a0269e11078879c6","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.code_graph.who_calls","uri":"program://TOLBERT/function/scripts.code_graph.who_calls#L213-L219","kind":"function","name":"who_calls","path":"scripts/code_graph.py","language":"python","start_line":213,"end_line":219,"context_start_line":193,"context_end_line":239,"code":"        if is_test:\n            rel = os.path.relpath(path, self.root)\n            self.pytest_nodes_by_module[module] = self._collect_pytest_nodes(tree, rel)\n\n    def owners_of(self, symbol: str) -> List[str]:\n        fqns = self.symbols_by_name.get(symbol, [])\n        return sorted(\n            {os.path.relpath(self.symbols_by_fqn[f].file, self.root) for f in fqns}\n        )\n\n    def find_symbol(self, name: str) -> List[Symbol]:\n        return [self.symbols_by_fqn[f] for f in self.symbols_by_name.get(name, [])]\n\n    def defs_in(self, module: str) -> List[str]:\n        mi = self.modules.get(module)\n        return list(mi.defs) if mi else []\n\n    def calls_of(self, fqn: str) -> List[str]:\n        return [c for (caller, c) in self.calls if caller == fqn]\n\n    def who_calls(self, fqn: str) -> List[str]:\n        target_short = fqn.split(\".\")[-1]\n        out: List[str] = []\n        for caller, callee in self.calls:\n            if callee == fqn or callee.split(\".\")[-1] == target_short:\n                out.append(caller)\n        return out\n\n    def search_refs(self, pattern: str) -> List[Tuple[str, int, str]]:\n        \"\"\"Ripgrep-based raw reference search (file, line_no, text).\"\"\"\n        try:\n            import subprocess\n\n            out = subprocess.check_output([\"rg\", \"-n\", pattern, self.root], text=True)\n            rows: List[Tuple[str, int, str]] = []\n            for line in out.splitlines():\n                try:\n                    fp, ln, txt = line.split(\":\", 2)\n                    rows.append((os.path.relpath(fp, self.root), int(ln), txt))\n                except Exception:\n                    continue\n            return rows\n        except Exception:\n            # Fallback: simple Python regex over indexed .py files\n            rows: List[Tuple[str, int, str]] = []\n            try:\n                rx = re.compile(pattern)","source_hash":"e28a996e3c22e28318f33e970701e56c53d2becd271f9615a0269e11078879c6","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.code_graph.search_refs","uri":"program://TOLBERT/function/scripts.code_graph.search_refs#L221-L252","kind":"function","name":"search_refs","path":"scripts/code_graph.py","language":"python","start_line":221,"end_line":252,"context_start_line":201,"context_end_line":272,"code":"        )\n\n    def find_symbol(self, name: str) -> List[Symbol]:\n        return [self.symbols_by_fqn[f] for f in self.symbols_by_name.get(name, [])]\n\n    def defs_in(self, module: str) -> List[str]:\n        mi = self.modules.get(module)\n        return list(mi.defs) if mi else []\n\n    def calls_of(self, fqn: str) -> List[str]:\n        return [c for (caller, c) in self.calls if caller == fqn]\n\n    def who_calls(self, fqn: str) -> List[str]:\n        target_short = fqn.split(\".\")[-1]\n        out: List[str] = []\n        for caller, callee in self.calls:\n            if callee == fqn or callee.split(\".\")[-1] == target_short:\n                out.append(caller)\n        return out\n\n    def search_refs(self, pattern: str) -> List[Tuple[str, int, str]]:\n        \"\"\"Ripgrep-based raw reference search (file, line_no, text).\"\"\"\n        try:\n            import subprocess\n\n            out = subprocess.check_output([\"rg\", \"-n\", pattern, self.root], text=True)\n            rows: List[Tuple[str, int, str]] = []\n            for line in out.splitlines():\n                try:\n                    fp, ln, txt = line.split(\":\", 2)\n                    rows.append((os.path.relpath(fp, self.root), int(ln), txt))\n                except Exception:\n                    continue\n            return rows\n        except Exception:\n            # Fallback: simple Python regex over indexed .py files\n            rows: List[Tuple[str, int, str]] = []\n            try:\n                rx = re.compile(pattern)\n            except Exception:\n                # If pattern is not a valid regex, escape it\n                rx = re.compile(re.escape(pattern))\n            for fpath in self.indexed_files:\n                rel = os.path.relpath(fpath, self.root)\n                try:\n                    with open(fpath, \"r\", encoding=\"utf-8\", errors=\"ignore\") as rf:\n                        for i, ln in enumerate(rf, start=1):\n                            if rx.search(ln):\n                                rows.append((rel, i, ln.rstrip(\"\\n\")))\n                except Exception:\n                    continue\n            return rows\n\n    # --- Helpers --- #\n\n    def module_for_file(self, path: str) -> Optional[str]:\n        p = path\n        if not os.path.isabs(p):\n            p = os.path.abspath(os.path.join(self.root, path))\n        for mod, mi in self.modules.items():\n            if os.path.abspath(mi.file) == p:\n                return mod\n        return None\n\n    def file_for_module(self, module: str) -> Optional[str]:\n        mi = self.modules.get(module)\n        return mi.file if mi else None\n\n    def tests_for_module(self, module: str) -> List[str]:\n        base = module.split(\".\")[0]\n        out = set(self.module_to_tests.get(base, []))\n        # include direct module key if present","source_hash":"e28a996e3c22e28318f33e970701e56c53d2becd271f9615a0269e11078879c6","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.code_graph.module_for_file","uri":"program://TOLBERT/function/scripts.code_graph.module_for_file#L256-L263","kind":"function","name":"module_for_file","path":"scripts/code_graph.py","language":"python","start_line":256,"end_line":263,"context_start_line":236,"context_end_line":283,"code":"            # Fallback: simple Python regex over indexed .py files\n            rows: List[Tuple[str, int, str]] = []\n            try:\n                rx = re.compile(pattern)\n            except Exception:\n                # If pattern is not a valid regex, escape it\n                rx = re.compile(re.escape(pattern))\n            for fpath in self.indexed_files:\n                rel = os.path.relpath(fpath, self.root)\n                try:\n                    with open(fpath, \"r\", encoding=\"utf-8\", errors=\"ignore\") as rf:\n                        for i, ln in enumerate(rf, start=1):\n                            if rx.search(ln):\n                                rows.append((rel, i, ln.rstrip(\"\\n\")))\n                except Exception:\n                    continue\n            return rows\n\n    # --- Helpers --- #\n\n    def module_for_file(self, path: str) -> Optional[str]:\n        p = path\n        if not os.path.isabs(p):\n            p = os.path.abspath(os.path.join(self.root, path))\n        for mod, mi in self.modules.items():\n            if os.path.abspath(mi.file) == p:\n                return mod\n        return None\n\n    def file_for_module(self, module: str) -> Optional[str]:\n        mi = self.modules.get(module)\n        return mi.file if mi else None\n\n    def tests_for_module(self, module: str) -> List[str]:\n        base = module.split(\".\")[0]\n        out = set(self.module_to_tests.get(base, []))\n        # include direct module key if present\n        out.update(self.module_to_tests.get(module, []))\n        return sorted(out)\n\n    def tests_for_symbol(self, fqn: str) -> List[str]:\n        mod = fqn.rsplit(\".\", 1)[0] if \".\" in fqn else fqn\n        return self.tests_for_module(mod)\n\n    def refs_of(self, fqn: str) -> List[Tuple[str, str]]:\n        \"\"\"Return (caller_fqn, callee_match) entries that reference fqn or its short name.\"\"\"\n        target_short = fqn.split(\".\")[-1]\n        out: List[Tuple[str, str]] = []","source_hash":"e28a996e3c22e28318f33e970701e56c53d2becd271f9615a0269e11078879c6","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.code_graph.file_for_module","uri":"program://TOLBERT/function/scripts.code_graph.file_for_module#L265-L267","kind":"function","name":"file_for_module","path":"scripts/code_graph.py","language":"python","start_line":265,"end_line":267,"context_start_line":245,"context_end_line":287,"code":"                try:\n                    with open(fpath, \"r\", encoding=\"utf-8\", errors=\"ignore\") as rf:\n                        for i, ln in enumerate(rf, start=1):\n                            if rx.search(ln):\n                                rows.append((rel, i, ln.rstrip(\"\\n\")))\n                except Exception:\n                    continue\n            return rows\n\n    # --- Helpers --- #\n\n    def module_for_file(self, path: str) -> Optional[str]:\n        p = path\n        if not os.path.isabs(p):\n            p = os.path.abspath(os.path.join(self.root, path))\n        for mod, mi in self.modules.items():\n            if os.path.abspath(mi.file) == p:\n                return mod\n        return None\n\n    def file_for_module(self, module: str) -> Optional[str]:\n        mi = self.modules.get(module)\n        return mi.file if mi else None\n\n    def tests_for_module(self, module: str) -> List[str]:\n        base = module.split(\".\")[0]\n        out = set(self.module_to_tests.get(base, []))\n        # include direct module key if present\n        out.update(self.module_to_tests.get(module, []))\n        return sorted(out)\n\n    def tests_for_symbol(self, fqn: str) -> List[str]:\n        mod = fqn.rsplit(\".\", 1)[0] if \".\" in fqn else fqn\n        return self.tests_for_module(mod)\n\n    def refs_of(self, fqn: str) -> List[Tuple[str, str]]:\n        \"\"\"Return (caller_fqn, callee_match) entries that reference fqn or its short name.\"\"\"\n        target_short = fqn.split(\".\")[-1]\n        out: List[Tuple[str, str]] = []\n        for caller, callee in self.calls:\n            if callee == fqn or callee.split(\".\")[-1] == target_short:\n                out.append((caller, callee))\n        return out","source_hash":"e28a996e3c22e28318f33e970701e56c53d2becd271f9615a0269e11078879c6","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.code_graph.tests_for_module","uri":"program://TOLBERT/function/scripts.code_graph.tests_for_module#L269-L274","kind":"function","name":"tests_for_module","path":"scripts/code_graph.py","language":"python","start_line":269,"end_line":274,"context_start_line":249,"context_end_line":294,"code":"                                rows.append((rel, i, ln.rstrip(\"\\n\")))\n                except Exception:\n                    continue\n            return rows\n\n    # --- Helpers --- #\n\n    def module_for_file(self, path: str) -> Optional[str]:\n        p = path\n        if not os.path.isabs(p):\n            p = os.path.abspath(os.path.join(self.root, path))\n        for mod, mi in self.modules.items():\n            if os.path.abspath(mi.file) == p:\n                return mod\n        return None\n\n    def file_for_module(self, module: str) -> Optional[str]:\n        mi = self.modules.get(module)\n        return mi.file if mi else None\n\n    def tests_for_module(self, module: str) -> List[str]:\n        base = module.split(\".\")[0]\n        out = set(self.module_to_tests.get(base, []))\n        # include direct module key if present\n        out.update(self.module_to_tests.get(module, []))\n        return sorted(out)\n\n    def tests_for_symbol(self, fqn: str) -> List[str]:\n        mod = fqn.rsplit(\".\", 1)[0] if \".\" in fqn else fqn\n        return self.tests_for_module(mod)\n\n    def refs_of(self, fqn: str) -> List[Tuple[str, str]]:\n        \"\"\"Return (caller_fqn, callee_match) entries that reference fqn or its short name.\"\"\"\n        target_short = fqn.split(\".\")[-1]\n        out: List[Tuple[str, str]] = []\n        for caller, callee in self.calls:\n            if callee == fqn or callee.split(\".\")[-1] == target_short:\n                out.append((caller, callee))\n        return out\n\n    def export_json(self) -> Dict[str, Any]:\n        return {\n            \"root\": self.root,\n            \"files\": [os.path.relpath(p, self.root) for p in self.indexed_files],\n            \"symbols\": [self._sym_to_dict(s) for s in self.symbols_by_fqn.values()],\n            \"modules\": {k: self._mi_to_dict(v) for k, v in self.modules.items()},","source_hash":"e28a996e3c22e28318f33e970701e56c53d2becd271f9615a0269e11078879c6","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.code_graph.tests_for_symbol","uri":"program://TOLBERT/function/scripts.code_graph.tests_for_symbol#L276-L278","kind":"function","name":"tests_for_symbol","path":"scripts/code_graph.py","language":"python","start_line":276,"end_line":278,"context_start_line":256,"context_end_line":298,"code":"    def module_for_file(self, path: str) -> Optional[str]:\n        p = path\n        if not os.path.isabs(p):\n            p = os.path.abspath(os.path.join(self.root, path))\n        for mod, mi in self.modules.items():\n            if os.path.abspath(mi.file) == p:\n                return mod\n        return None\n\n    def file_for_module(self, module: str) -> Optional[str]:\n        mi = self.modules.get(module)\n        return mi.file if mi else None\n\n    def tests_for_module(self, module: str) -> List[str]:\n        base = module.split(\".\")[0]\n        out = set(self.module_to_tests.get(base, []))\n        # include direct module key if present\n        out.update(self.module_to_tests.get(module, []))\n        return sorted(out)\n\n    def tests_for_symbol(self, fqn: str) -> List[str]:\n        mod = fqn.rsplit(\".\", 1)[0] if \".\" in fqn else fqn\n        return self.tests_for_module(mod)\n\n    def refs_of(self, fqn: str) -> List[Tuple[str, str]]:\n        \"\"\"Return (caller_fqn, callee_match) entries that reference fqn or its short name.\"\"\"\n        target_short = fqn.split(\".\")[-1]\n        out: List[Tuple[str, str]] = []\n        for caller, callee in self.calls:\n            if callee == fqn or callee.split(\".\")[-1] == target_short:\n                out.append((caller, callee))\n        return out\n\n    def export_json(self) -> Dict[str, Any]:\n        return {\n            \"root\": self.root,\n            \"files\": [os.path.relpath(p, self.root) for p in self.indexed_files],\n            \"symbols\": [self._sym_to_dict(s) for s in self.symbols_by_fqn.values()],\n            \"modules\": {k: self._mi_to_dict(v) for k, v in self.modules.items()},\n            \"calls\": self.calls,\n            \"module_to_tests\": self.module_to_tests,\n            \"coverage_files\": {\n                os.path.relpath(k, self.root): sorted(list(v))","source_hash":"e28a996e3c22e28318f33e970701e56c53d2becd271f9615a0269e11078879c6","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.code_graph.refs_of","uri":"program://TOLBERT/function/scripts.code_graph.refs_of#L280-L287","kind":"function","name":"refs_of","path":"scripts/code_graph.py","language":"python","start_line":280,"end_line":287,"context_start_line":260,"context_end_line":307,"code":"        for mod, mi in self.modules.items():\n            if os.path.abspath(mi.file) == p:\n                return mod\n        return None\n\n    def file_for_module(self, module: str) -> Optional[str]:\n        mi = self.modules.get(module)\n        return mi.file if mi else None\n\n    def tests_for_module(self, module: str) -> List[str]:\n        base = module.split(\".\")[0]\n        out = set(self.module_to_tests.get(base, []))\n        # include direct module key if present\n        out.update(self.module_to_tests.get(module, []))\n        return sorted(out)\n\n    def tests_for_symbol(self, fqn: str) -> List[str]:\n        mod = fqn.rsplit(\".\", 1)[0] if \".\" in fqn else fqn\n        return self.tests_for_module(mod)\n\n    def refs_of(self, fqn: str) -> List[Tuple[str, str]]:\n        \"\"\"Return (caller_fqn, callee_match) entries that reference fqn or its short name.\"\"\"\n        target_short = fqn.split(\".\")[-1]\n        out: List[Tuple[str, str]] = []\n        for caller, callee in self.calls:\n            if callee == fqn or callee.split(\".\")[-1] == target_short:\n                out.append((caller, callee))\n        return out\n\n    def export_json(self) -> Dict[str, Any]:\n        return {\n            \"root\": self.root,\n            \"files\": [os.path.relpath(p, self.root) for p in self.indexed_files],\n            \"symbols\": [self._sym_to_dict(s) for s in self.symbols_by_fqn.values()],\n            \"modules\": {k: self._mi_to_dict(v) for k, v in self.modules.items()},\n            \"calls\": self.calls,\n            \"module_to_tests\": self.module_to_tests,\n            \"coverage_files\": {\n                os.path.relpath(k, self.root): sorted(list(v))\n                for k, v in self.coverage_files.items()\n            },\n            \"symbol_coverage\": self.symbol_coverage,\n            \"module_imports\": self.module_imports,\n        }\n\n    def export_sqlite(self, db_path: str) -> None:\n        import sqlite3\n","source_hash":"e28a996e3c22e28318f33e970701e56c53d2becd271f9615a0269e11078879c6","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.code_graph.export_json","uri":"program://TOLBERT/function/scripts.code_graph.export_json#L289-L303","kind":"function","name":"export_json","path":"scripts/code_graph.py","language":"python","start_line":289,"end_line":303,"context_start_line":269,"context_end_line":323,"code":"    def tests_for_module(self, module: str) -> List[str]:\n        base = module.split(\".\")[0]\n        out = set(self.module_to_tests.get(base, []))\n        # include direct module key if present\n        out.update(self.module_to_tests.get(module, []))\n        return sorted(out)\n\n    def tests_for_symbol(self, fqn: str) -> List[str]:\n        mod = fqn.rsplit(\".\", 1)[0] if \".\" in fqn else fqn\n        return self.tests_for_module(mod)\n\n    def refs_of(self, fqn: str) -> List[Tuple[str, str]]:\n        \"\"\"Return (caller_fqn, callee_match) entries that reference fqn or its short name.\"\"\"\n        target_short = fqn.split(\".\")[-1]\n        out: List[Tuple[str, str]] = []\n        for caller, callee in self.calls:\n            if callee == fqn or callee.split(\".\")[-1] == target_short:\n                out.append((caller, callee))\n        return out\n\n    def export_json(self) -> Dict[str, Any]:\n        return {\n            \"root\": self.root,\n            \"files\": [os.path.relpath(p, self.root) for p in self.indexed_files],\n            \"symbols\": [self._sym_to_dict(s) for s in self.symbols_by_fqn.values()],\n            \"modules\": {k: self._mi_to_dict(v) for k, v in self.modules.items()},\n            \"calls\": self.calls,\n            \"module_to_tests\": self.module_to_tests,\n            \"coverage_files\": {\n                os.path.relpath(k, self.root): sorted(list(v))\n                for k, v in self.coverage_files.items()\n            },\n            \"symbol_coverage\": self.symbol_coverage,\n            \"module_imports\": self.module_imports,\n        }\n\n    def export_sqlite(self, db_path: str) -> None:\n        import sqlite3\n\n        conn = sqlite3.connect(db_path)\n        cur = conn.cursor()\n        cur.executescript(\n            \"\"\"\n            PRAGMA journal_mode=WAL;\n            CREATE TABLE IF NOT EXISTS files(path TEXT PRIMARY KEY);\n            CREATE TABLE IF NOT EXISTS modules(module TEXT PRIMARY KEY, file TEXT, is_test INT);\n            CREATE TABLE IF NOT EXISTS symbols(\n              fqn TEXT PRIMARY KEY, name TEXT, qualname TEXT, kind TEXT, module TEXT,\n              file TEXT, line INT, end_line INT, doc TEXT, signature TEXT, returns TEXT\n            );\n            CREATE TABLE IF NOT EXISTS calls(caller TEXT, callee TEXT);\n            CREATE TABLE IF NOT EXISTS tests_map(module TEXT, test_module TEXT);\n            CREATE TABLE IF NOT EXISTS coverage(file TEXT, line INT);\n            CREATE TABLE IF NOT EXISTS mod_deps(module TEXT, dep TEXT);\n            \"\"\"","source_hash":"e28a996e3c22e28318f33e970701e56c53d2becd271f9615a0269e11078879c6","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.code_graph.export_sqlite","uri":"program://TOLBERT/function/scripts.code_graph.export_sqlite#L305-L380","kind":"function","name":"export_sqlite","path":"scripts/code_graph.py","language":"python","start_line":305,"end_line":380,"context_start_line":285,"context_end_line":400,"code":"            if callee == fqn or callee.split(\".\")[-1] == target_short:\n                out.append((caller, callee))\n        return out\n\n    def export_json(self) -> Dict[str, Any]:\n        return {\n            \"root\": self.root,\n            \"files\": [os.path.relpath(p, self.root) for p in self.indexed_files],\n            \"symbols\": [self._sym_to_dict(s) for s in self.symbols_by_fqn.values()],\n            \"modules\": {k: self._mi_to_dict(v) for k, v in self.modules.items()},\n            \"calls\": self.calls,\n            \"module_to_tests\": self.module_to_tests,\n            \"coverage_files\": {\n                os.path.relpath(k, self.root): sorted(list(v))\n                for k, v in self.coverage_files.items()\n            },\n            \"symbol_coverage\": self.symbol_coverage,\n            \"module_imports\": self.module_imports,\n        }\n\n    def export_sqlite(self, db_path: str) -> None:\n        import sqlite3\n\n        conn = sqlite3.connect(db_path)\n        cur = conn.cursor()\n        cur.executescript(\n            \"\"\"\n            PRAGMA journal_mode=WAL;\n            CREATE TABLE IF NOT EXISTS files(path TEXT PRIMARY KEY);\n            CREATE TABLE IF NOT EXISTS modules(module TEXT PRIMARY KEY, file TEXT, is_test INT);\n            CREATE TABLE IF NOT EXISTS symbols(\n              fqn TEXT PRIMARY KEY, name TEXT, qualname TEXT, kind TEXT, module TEXT,\n              file TEXT, line INT, end_line INT, doc TEXT, signature TEXT, returns TEXT\n            );\n            CREATE TABLE IF NOT EXISTS calls(caller TEXT, callee TEXT);\n            CREATE TABLE IF NOT EXISTS tests_map(module TEXT, test_module TEXT);\n            CREATE TABLE IF NOT EXISTS coverage(file TEXT, line INT);\n            CREATE TABLE IF NOT EXISTS mod_deps(module TEXT, dep TEXT);\n            \"\"\"\n        )\n        cur.executemany(\n            \"INSERT OR IGNORE INTO files(path) VALUES(?)\",\n            [(os.path.relpath(f, self.root),) for f in self.indexed_files],\n        )\n        cur.executemany(\n            \"INSERT OR REPLACE INTO modules(module,file,is_test) VALUES(?,?,?)\",\n            [\n                (m, os.path.relpath(mi.file, self.root), 1 if mi.is_test else 0)\n                for m, mi in self.modules.items()\n            ],\n        )\n        cur.executemany(\n            \"INSERT OR REPLACE INTO symbols VALUES(?,?,?,?,?,?,?,?,?,?,?)\",\n            [\n                (\n                    s.fqn,\n                    s.name,\n                    s.qualname,\n                    s.kind,\n                    s.module,\n                    os.path.relpath(s.file, self.root),\n                    int(s.line),\n                    int(s.end_line),\n                    s.doc or \"\",\n                    s.signature or \"\",\n                    s.returns or \"\",\n                )\n                for s in self.symbols_by_fqn.values()\n            ],\n        )\n        if self.calls:\n            cur.executemany(\n                \"INSERT INTO calls(caller,callee) VALUES(?,?)\", list(self.calls)\n            )\n        rows = []\n        for mod, tests in self.module_to_tests.items():\n            for t in tests:\n                rows.append((mod, t))\n        if rows:\n            cur.executemany(\n                \"INSERT INTO tests_map(module,test_module) VALUES(?,?)\", rows\n            )\n        cov_rows = []\n        for f, lines in self.coverage_files.items():\n            rel = os.path.relpath(f, self.root)\n            cov_rows.extend([(rel, int(n)) for n in lines])\n        if cov_rows:\n            cur.executemany(\"INSERT INTO coverage(file,line) VALUES(?,?)\", cov_rows)\n        dep_rows = []\n        for m, deps in self.module_imports.items():\n            for d in deps:\n                dep_rows.append((m, d))\n        if dep_rows:\n            cur.executemany(\"INSERT INTO mod_deps(module,dep) VALUES(?,?)\", dep_rows)\n        conn.commit()\n        conn.close()\n\n    def _module_name_for_path(self, path: str) -> str:\n        rel = os.path.relpath(path, self.root)\n        no_ext = rel[:-3] if rel.endswith(\".py\") else rel\n        parts = no_ext.split(os.sep)\n        if parts[-1] == \"__init__\":\n            parts = parts[:-1]\n        return \".\".join(p for p in parts if p)\n\n    def _resolve_callee(\n        self, module: str, callee_key: str, visitor: \"_ModuleVisitor\"\n    ) -> Optional[str]:\n        if \".\" in callee_key and \":\" not in callee_key:\n            return callee_key\n\n        if \":\" in callee_key:\n            mod_alias, name = callee_key.split(\":\", 1)\n            target = visitor.imports.get(mod_alias)\n            if target:\n                return f\"{target}.{name}\" if not target.endswith(f\".{name}\") else target","source_hash":"e28a996e3c22e28318f33e970701e56c53d2becd271f9615a0269e11078879c6","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.code_graph._module_name_for_path","uri":"program://TOLBERT/function/scripts.code_graph._module_name_for_path#L382-L388","kind":"function","name":"_module_name_for_path","path":"scripts/code_graph.py","language":"python","start_line":382,"end_line":388,"context_start_line":362,"context_end_line":408,"code":"                rows.append((mod, t))\n        if rows:\n            cur.executemany(\n                \"INSERT INTO tests_map(module,test_module) VALUES(?,?)\", rows\n            )\n        cov_rows = []\n        for f, lines in self.coverage_files.items():\n            rel = os.path.relpath(f, self.root)\n            cov_rows.extend([(rel, int(n)) for n in lines])\n        if cov_rows:\n            cur.executemany(\"INSERT INTO coverage(file,line) VALUES(?,?)\", cov_rows)\n        dep_rows = []\n        for m, deps in self.module_imports.items():\n            for d in deps:\n                dep_rows.append((m, d))\n        if dep_rows:\n            cur.executemany(\"INSERT INTO mod_deps(module,dep) VALUES(?,?)\", dep_rows)\n        conn.commit()\n        conn.close()\n\n    def _module_name_for_path(self, path: str) -> str:\n        rel = os.path.relpath(path, self.root)\n        no_ext = rel[:-3] if rel.endswith(\".py\") else rel\n        parts = no_ext.split(os.sep)\n        if parts[-1] == \"__init__\":\n            parts = parts[:-1]\n        return \".\".join(p for p in parts if p)\n\n    def _resolve_callee(\n        self, module: str, callee_key: str, visitor: \"_ModuleVisitor\"\n    ) -> Optional[str]:\n        if \".\" in callee_key and \":\" not in callee_key:\n            return callee_key\n\n        if \":\" in callee_key:\n            mod_alias, name = callee_key.split(\":\", 1)\n            target = visitor.imports.get(mod_alias)\n            if target:\n                return f\"{target}.{name}\" if not target.endswith(f\".{name}\") else target\n\n        mi = self.modules.get(module)\n        if mi:\n            # Prefer any def with same suffix name (matches within class or function)\n            for f in mi.defs:\n                if f.split(\".\")[-1] == callee_key:\n                    return f\n","source_hash":"e28a996e3c22e28318f33e970701e56c53d2becd271f9615a0269e11078879c6","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.code_graph._resolve_callee","uri":"program://TOLBERT/function/scripts.code_graph._resolve_callee#L390-L412","kind":"function","name":"_resolve_callee","path":"scripts/code_graph.py","language":"python","start_line":390,"end_line":412,"context_start_line":370,"context_end_line":432,"code":"            cov_rows.extend([(rel, int(n)) for n in lines])\n        if cov_rows:\n            cur.executemany(\"INSERT INTO coverage(file,line) VALUES(?,?)\", cov_rows)\n        dep_rows = []\n        for m, deps in self.module_imports.items():\n            for d in deps:\n                dep_rows.append((m, d))\n        if dep_rows:\n            cur.executemany(\"INSERT INTO mod_deps(module,dep) VALUES(?,?)\", dep_rows)\n        conn.commit()\n        conn.close()\n\n    def _module_name_for_path(self, path: str) -> str:\n        rel = os.path.relpath(path, self.root)\n        no_ext = rel[:-3] if rel.endswith(\".py\") else rel\n        parts = no_ext.split(os.sep)\n        if parts[-1] == \"__init__\":\n            parts = parts[:-1]\n        return \".\".join(p for p in parts if p)\n\n    def _resolve_callee(\n        self, module: str, callee_key: str, visitor: \"_ModuleVisitor\"\n    ) -> Optional[str]:\n        if \".\" in callee_key and \":\" not in callee_key:\n            return callee_key\n\n        if \":\" in callee_key:\n            mod_alias, name = callee_key.split(\":\", 1)\n            target = visitor.imports.get(mod_alias)\n            if target:\n                return f\"{target}.{name}\" if not target.endswith(f\".{name}\") else target\n\n        mi = self.modules.get(module)\n        if mi:\n            # Prefer any def with same suffix name (matches within class or function)\n            for f in mi.defs:\n                if f.split(\".\")[-1] == callee_key:\n                    return f\n\n        tgt = visitor.imports.get(callee_key)\n        if tgt:\n            return tgt\n        return None\n\n    def _build_test_mapping(self) -> None:\n        for mod, mi in self.modules.items():\n            if not mi.is_test:\n                continue\n            for alias, target in mi.imports.items():\n                # target may be module or module.symbol\n                m = target.split(\".\")[0]\n                self.module_to_tests.setdefault(m, []).append(mod)\n\n    def _expand_star_imports(self) -> None:\n        for mod, stars in self.module_star_imports.items():\n            mi = self.modules.get(mod)\n            if not mi:\n                continue\n            for star_mod in stars:\n                defs = [\n                    f\n                    for f in self.modules.get(\n                        star_mod, ModuleInfo(module=star_mod, file=\"\")","source_hash":"e28a996e3c22e28318f33e970701e56c53d2becd271f9615a0269e11078879c6","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.code_graph._build_test_mapping","uri":"program://TOLBERT/function/scripts.code_graph._build_test_mapping#L414-L421","kind":"function","name":"_build_test_mapping","path":"scripts/code_graph.py","language":"python","start_line":414,"end_line":421,"context_start_line":394,"context_end_line":441,"code":"            return callee_key\n\n        if \":\" in callee_key:\n            mod_alias, name = callee_key.split(\":\", 1)\n            target = visitor.imports.get(mod_alias)\n            if target:\n                return f\"{target}.{name}\" if not target.endswith(f\".{name}\") else target\n\n        mi = self.modules.get(module)\n        if mi:\n            # Prefer any def with same suffix name (matches within class or function)\n            for f in mi.defs:\n                if f.split(\".\")[-1] == callee_key:\n                    return f\n\n        tgt = visitor.imports.get(callee_key)\n        if tgt:\n            return tgt\n        return None\n\n    def _build_test_mapping(self) -> None:\n        for mod, mi in self.modules.items():\n            if not mi.is_test:\n                continue\n            for alias, target in mi.imports.items():\n                # target may be module or module.symbol\n                m = target.split(\".\")[0]\n                self.module_to_tests.setdefault(m, []).append(mod)\n\n    def _expand_star_imports(self) -> None:\n        for mod, stars in self.module_star_imports.items():\n            mi = self.modules.get(mod)\n            if not mi:\n                continue\n            for star_mod in stars:\n                defs = [\n                    f\n                    for f in self.modules.get(\n                        star_mod, ModuleInfo(module=star_mod, file=\"\")\n                    ).defs\n                ]\n                exports = set(\n                    self.modules.get(\n                        star_mod, ModuleInfo(module=star_mod, file=\"\")\n                    ).exports\n                    or []\n                )\n                for fqn in defs:","source_hash":"e28a996e3c22e28318f33e970701e56c53d2becd271f9615a0269e11078879c6","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.code_graph._expand_star_imports","uri":"program://TOLBERT/function/scripts.code_graph._expand_star_imports#L423-L449","kind":"function","name":"_expand_star_imports","path":"scripts/code_graph.py","language":"python","start_line":423,"end_line":449,"context_start_line":403,"context_end_line":469,"code":"        if mi:\n            # Prefer any def with same suffix name (matches within class or function)\n            for f in mi.defs:\n                if f.split(\".\")[-1] == callee_key:\n                    return f\n\n        tgt = visitor.imports.get(callee_key)\n        if tgt:\n            return tgt\n        return None\n\n    def _build_test_mapping(self) -> None:\n        for mod, mi in self.modules.items():\n            if not mi.is_test:\n                continue\n            for alias, target in mi.imports.items():\n                # target may be module or module.symbol\n                m = target.split(\".\")[0]\n                self.module_to_tests.setdefault(m, []).append(mod)\n\n    def _expand_star_imports(self) -> None:\n        for mod, stars in self.module_star_imports.items():\n            mi = self.modules.get(mod)\n            if not mi:\n                continue\n            for star_mod in stars:\n                defs = [\n                    f\n                    for f in self.modules.get(\n                        star_mod, ModuleInfo(module=star_mod, file=\"\")\n                    ).defs\n                ]\n                exports = set(\n                    self.modules.get(\n                        star_mod, ModuleInfo(module=star_mod, file=\"\")\n                    ).exports\n                    or []\n                )\n                for fqn in defs:\n                    name = fqn.split(\".\")[-1]\n                    if exports:\n                        if name not in exports:\n                            continue\n                    elif name.startswith(\"_\"):\n                        continue\n                    if name not in mi.imports:\n                        mi.imports[name] = f\"{star_mod}.{name}\"\n\n    def _post_resolve_calls(self) -> None:\n        # After imports expanded, try to resolve unresolved simple names\n        new_calls: List[Tuple[str, str]] = []\n        for caller, callee in self.calls:\n            if \".\" in callee:\n                new_calls.append((caller, callee))\n                continue\n            # Find caller module\n            caller_mod = caller.rsplit(\".\", 1)[0] if \".\" in caller else caller\n            imports = self.modules.get(\n                caller_mod, ModuleInfo(module=caller_mod, file=\"\")\n            ).imports\n            tgt = imports.get(callee)\n            if tgt:\n                new_calls.append((caller, tgt))\n            else:\n                # leave as-is\n                new_calls.append((caller, callee))\n        self.calls = new_calls","source_hash":"e28a996e3c22e28318f33e970701e56c53d2becd271f9615a0269e11078879c6","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.code_graph._post_resolve_calls","uri":"program://TOLBERT/function/scripts.code_graph._post_resolve_calls#L451-L469","kind":"function","name":"_post_resolve_calls","path":"scripts/code_graph.py","language":"python","start_line":451,"end_line":469,"context_start_line":431,"context_end_line":489,"code":"                    for f in self.modules.get(\n                        star_mod, ModuleInfo(module=star_mod, file=\"\")\n                    ).defs\n                ]\n                exports = set(\n                    self.modules.get(\n                        star_mod, ModuleInfo(module=star_mod, file=\"\")\n                    ).exports\n                    or []\n                )\n                for fqn in defs:\n                    name = fqn.split(\".\")[-1]\n                    if exports:\n                        if name not in exports:\n                            continue\n                    elif name.startswith(\"_\"):\n                        continue\n                    if name not in mi.imports:\n                        mi.imports[name] = f\"{star_mod}.{name}\"\n\n    def _post_resolve_calls(self) -> None:\n        # After imports expanded, try to resolve unresolved simple names\n        new_calls: List[Tuple[str, str]] = []\n        for caller, callee in self.calls:\n            if \".\" in callee:\n                new_calls.append((caller, callee))\n                continue\n            # Find caller module\n            caller_mod = caller.rsplit(\".\", 1)[0] if \".\" in caller else caller\n            imports = self.modules.get(\n                caller_mod, ModuleInfo(module=caller_mod, file=\"\")\n            ).imports\n            tgt = imports.get(callee)\n            if tgt:\n                new_calls.append((caller, tgt))\n            else:\n                # leave as-is\n                new_calls.append((caller, callee))\n        self.calls = new_calls\n\n    def unresolved_calls(self) -> List[Tuple[str, str]]:\n        return [\n            (a, c)\n            for (a, c) in self.calls\n            if \".\" not in c and not self._is_builtin_name(c)\n        ]\n\n    def _collect_pytest_nodes(self, tree: ast.AST, rel_path: str) -> List[str]:\n        nodes: List[str] = []\n        # top-level test_* functions\n        for n in getattr(tree, \"body\", []) or []:\n            if isinstance(n, ast.FunctionDef) and n.name.startswith(\"test_\"):\n                nodes.extend(self._expand_parametrize(rel_path, None, n))\n            if isinstance(n, ast.ClassDef) and n.name.startswith(\"Test\"):\n                cls = n.name\n                for m in getattr(n, \"body\", []) or []:\n                    if isinstance(m, ast.FunctionDef) and m.name.startswith(\"test_\"):\n                        nodes.extend(self._expand_parametrize(rel_path, cls, m))\n        return nodes","source_hash":"e28a996e3c22e28318f33e970701e56c53d2becd271f9615a0269e11078879c6","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.code_graph.unresolved_calls","uri":"program://TOLBERT/function/scripts.code_graph.unresolved_calls#L471-L476","kind":"function","name":"unresolved_calls","path":"scripts/code_graph.py","language":"python","start_line":471,"end_line":476,"context_start_line":451,"context_end_line":496,"code":"    def _post_resolve_calls(self) -> None:\n        # After imports expanded, try to resolve unresolved simple names\n        new_calls: List[Tuple[str, str]] = []\n        for caller, callee in self.calls:\n            if \".\" in callee:\n                new_calls.append((caller, callee))\n                continue\n            # Find caller module\n            caller_mod = caller.rsplit(\".\", 1)[0] if \".\" in caller else caller\n            imports = self.modules.get(\n                caller_mod, ModuleInfo(module=caller_mod, file=\"\")\n            ).imports\n            tgt = imports.get(callee)\n            if tgt:\n                new_calls.append((caller, tgt))\n            else:\n                # leave as-is\n                new_calls.append((caller, callee))\n        self.calls = new_calls\n\n    def unresolved_calls(self) -> List[Tuple[str, str]]:\n        return [\n            (a, c)\n            for (a, c) in self.calls\n            if \".\" not in c and not self._is_builtin_name(c)\n        ]\n\n    def _collect_pytest_nodes(self, tree: ast.AST, rel_path: str) -> List[str]:\n        nodes: List[str] = []\n        # top-level test_* functions\n        for n in getattr(tree, \"body\", []) or []:\n            if isinstance(n, ast.FunctionDef) and n.name.startswith(\"test_\"):\n                nodes.extend(self._expand_parametrize(rel_path, None, n))\n            if isinstance(n, ast.ClassDef) and n.name.startswith(\"Test\"):\n                cls = n.name\n                for m in getattr(n, \"body\", []) or []:\n                    if isinstance(m, ast.FunctionDef) and m.name.startswith(\"test_\"):\n                        nodes.extend(self._expand_parametrize(rel_path, cls, m))\n        return nodes\n\n    def _expand_parametrize(\n        self, rel_path: str, cls: Optional[str], fn: ast.FunctionDef\n    ) -> List[str]:\n        base = f\"{rel_path}::\" + (f\"{cls}::\" if cls else \"\") + fn.name\n        # Look for @pytest.mark.parametrize(\"arg\", [vals])\n        total: List[str] = []","source_hash":"e28a996e3c22e28318f33e970701e56c53d2becd271f9615a0269e11078879c6","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.code_graph._collect_pytest_nodes","uri":"program://TOLBERT/function/scripts.code_graph._collect_pytest_nodes#L478-L489","kind":"function","name":"_collect_pytest_nodes","path":"scripts/code_graph.py","language":"python","start_line":478,"end_line":489,"context_start_line":458,"context_end_line":509,"code":"            # Find caller module\n            caller_mod = caller.rsplit(\".\", 1)[0] if \".\" in caller else caller\n            imports = self.modules.get(\n                caller_mod, ModuleInfo(module=caller_mod, file=\"\")\n            ).imports\n            tgt = imports.get(callee)\n            if tgt:\n                new_calls.append((caller, tgt))\n            else:\n                # leave as-is\n                new_calls.append((caller, callee))\n        self.calls = new_calls\n\n    def unresolved_calls(self) -> List[Tuple[str, str]]:\n        return [\n            (a, c)\n            for (a, c) in self.calls\n            if \".\" not in c and not self._is_builtin_name(c)\n        ]\n\n    def _collect_pytest_nodes(self, tree: ast.AST, rel_path: str) -> List[str]:\n        nodes: List[str] = []\n        # top-level test_* functions\n        for n in getattr(tree, \"body\", []) or []:\n            if isinstance(n, ast.FunctionDef) and n.name.startswith(\"test_\"):\n                nodes.extend(self._expand_parametrize(rel_path, None, n))\n            if isinstance(n, ast.ClassDef) and n.name.startswith(\"Test\"):\n                cls = n.name\n                for m in getattr(n, \"body\", []) or []:\n                    if isinstance(m, ast.FunctionDef) and m.name.startswith(\"test_\"):\n                        nodes.extend(self._expand_parametrize(rel_path, cls, m))\n        return nodes\n\n    def _expand_parametrize(\n        self, rel_path: str, cls: Optional[str], fn: ast.FunctionDef\n    ) -> List[str]:\n        base = f\"{rel_path}::\" + (f\"{cls}::\" if cls else \"\") + fn.name\n        # Look for @pytest.mark.parametrize(\"arg\", [vals])\n        total: List[str] = []\n        params: List[int] = []\n        try:\n            for dec in getattr(fn, \"decorator_list\", []) or []:\n                # pytest.mark.parametrize(...)\n                if (\n                    isinstance(dec, ast.Call)\n                    and isinstance(dec.func, ast.Attribute)\n                    and dec.func.attr == \"parametrize\"\n                ):\n                    # estimate number of cases from second arg list length\n                    if len(dec.args) >= 2 and isinstance(\n                        dec.args[1], (ast.List, ast.Tuple)\n                    ):","source_hash":"e28a996e3c22e28318f33e970701e56c53d2becd271f9615a0269e11078879c6","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.code_graph._expand_parametrize","uri":"program://TOLBERT/function/scripts.code_graph._expand_parametrize#L491-L523","kind":"function","name":"_expand_parametrize","path":"scripts/code_graph.py","language":"python","start_line":491,"end_line":523,"context_start_line":471,"context_end_line":543,"code":"    def unresolved_calls(self) -> List[Tuple[str, str]]:\n        return [\n            (a, c)\n            for (a, c) in self.calls\n            if \".\" not in c and not self._is_builtin_name(c)\n        ]\n\n    def _collect_pytest_nodes(self, tree: ast.AST, rel_path: str) -> List[str]:\n        nodes: List[str] = []\n        # top-level test_* functions\n        for n in getattr(tree, \"body\", []) or []:\n            if isinstance(n, ast.FunctionDef) and n.name.startswith(\"test_\"):\n                nodes.extend(self._expand_parametrize(rel_path, None, n))\n            if isinstance(n, ast.ClassDef) and n.name.startswith(\"Test\"):\n                cls = n.name\n                for m in getattr(n, \"body\", []) or []:\n                    if isinstance(m, ast.FunctionDef) and m.name.startswith(\"test_\"):\n                        nodes.extend(self._expand_parametrize(rel_path, cls, m))\n        return nodes\n\n    def _expand_parametrize(\n        self, rel_path: str, cls: Optional[str], fn: ast.FunctionDef\n    ) -> List[str]:\n        base = f\"{rel_path}::\" + (f\"{cls}::\" if cls else \"\") + fn.name\n        # Look for @pytest.mark.parametrize(\"arg\", [vals])\n        total: List[str] = []\n        params: List[int] = []\n        try:\n            for dec in getattr(fn, \"decorator_list\", []) or []:\n                # pytest.mark.parametrize(...)\n                if (\n                    isinstance(dec, ast.Call)\n                    and isinstance(dec.func, ast.Attribute)\n                    and dec.func.attr == \"parametrize\"\n                ):\n                    # estimate number of cases from second arg list length\n                    if len(dec.args) >= 2 and isinstance(\n                        dec.args[1], (ast.List, ast.Tuple)\n                    ):\n                        params.append(len(dec.args[1].elts))\n        except Exception:\n            pass\n        if params:\n            count: int = 1\n            for k in params:\n                try:\n                    count *= int(k)\n                except Exception:\n                    count = max(count, 1)\n            for i in range(count):\n                total.append(f\"{base}[{i}]\")\n            return total\n        return [base]\n\n    # --- Cache --- #\n\n    def _try_load_cache(self, cache_path: str) -> bool:\n        try:\n            if not os.path.exists(cache_path):\n                return False\n            data = json.loads(open(cache_path, \"r\", encoding=\"utf-8\").read())\n            if str(data.get(\"version\", \"\")) != \"3\":\n                return False\n            # Verify mtimes and hashes\n            files = data.get(\"indexed_files\", [])\n            mt = data.get(\"mtimes\", {})\n            hh = data.get(\"hashes\", {})\n            for f in files:\n                if not os.path.exists(f):\n                    return False\n                if int(os.path.getmtime(f)) != int(mt.get(f, 0)):\n                    return False\n                if self._file_hash(f) != str(hh.get(f, \"\")):","source_hash":"e28a996e3c22e28318f33e970701e56c53d2becd271f9615a0269e11078879c6","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.code_graph._try_load_cache","uri":"program://TOLBERT/function/scripts.code_graph._try_load_cache#L527-L559","kind":"function","name":"_try_load_cache","path":"scripts/code_graph.py","language":"python","start_line":527,"end_line":559,"context_start_line":507,"context_end_line":579,"code":"                    if len(dec.args) >= 2 and isinstance(\n                        dec.args[1], (ast.List, ast.Tuple)\n                    ):\n                        params.append(len(dec.args[1].elts))\n        except Exception:\n            pass\n        if params:\n            count: int = 1\n            for k in params:\n                try:\n                    count *= int(k)\n                except Exception:\n                    count = max(count, 1)\n            for i in range(count):\n                total.append(f\"{base}[{i}]\")\n            return total\n        return [base]\n\n    # --- Cache --- #\n\n    def _try_load_cache(self, cache_path: str) -> bool:\n        try:\n            if not os.path.exists(cache_path):\n                return False\n            data = json.loads(open(cache_path, \"r\", encoding=\"utf-8\").read())\n            if str(data.get(\"version\", \"\")) != \"3\":\n                return False\n            # Verify mtimes and hashes\n            files = data.get(\"indexed_files\", [])\n            mt = data.get(\"mtimes\", {})\n            hh = data.get(\"hashes\", {})\n            for f in files:\n                if not os.path.exists(f):\n                    return False\n                if int(os.path.getmtime(f)) != int(mt.get(f, 0)):\n                    return False\n                if self._file_hash(f) != str(hh.get(f, \"\")):\n                    return False\n            # Load\n            self.indexed_files = files\n            for s in data.get(\"symbols\", []):\n                sym = Symbol(**s)\n                self._add_symbol(sym)\n            for mod, mi in data.get(\"modules\", {}).items():\n                self.modules[mod] = ModuleInfo(**mi)\n            self.calls = [tuple(x) for x in data.get(\"calls\", [])]\n            self.module_to_tests = data.get(\"module_to_tests\", {})\n            self.module_imports = data.get(\"module_imports\", {})\n            self._cached_mtimes = {k: int(v) for k, v in (mt or {}).items()}\n            self._cached_hashes = {k: str(v) for k, v in (hh or {}).items()}\n            return True\n        except Exception:\n            return False\n\n    def _load_cache_relaxed(self, cache_path: str) -> bool:\n        try:\n            if not os.path.exists(cache_path):\n                return False\n            data = json.loads(open(cache_path, \"r\", encoding=\"utf-8\").read())\n            if str(data.get(\"version\", \"\")) != \"3\":\n                return False\n            self.indexed_files = data.get(\"indexed_files\", [])\n            for s in data.get(\"symbols\", []):\n                sym = Symbol(**s)\n                self._add_symbol(sym)\n            for mod, mi in data.get(\"modules\", {}).items():\n                self.modules[mod] = ModuleInfo(**mi)\n            self.calls = [tuple(x) for x in data.get(\"calls\", [])]\n            self.module_to_tests = data.get(\"module_to_tests\", {})\n            self.module_imports = data.get(\"module_imports\", {})\n            self._cached_mtimes = {\n                k: int(v) for k, v in (data.get(\"mtimes\", {}) or {}).items()\n            }","source_hash":"e28a996e3c22e28318f33e970701e56c53d2becd271f9615a0269e11078879c6","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.code_graph._load_cache_relaxed","uri":"program://TOLBERT/function/scripts.code_graph._load_cache_relaxed#L561-L585","kind":"function","name":"_load_cache_relaxed","path":"scripts/code_graph.py","language":"python","start_line":561,"end_line":585,"context_start_line":541,"context_end_line":605,"code":"                if int(os.path.getmtime(f)) != int(mt.get(f, 0)):\n                    return False\n                if self._file_hash(f) != str(hh.get(f, \"\")):\n                    return False\n            # Load\n            self.indexed_files = files\n            for s in data.get(\"symbols\", []):\n                sym = Symbol(**s)\n                self._add_symbol(sym)\n            for mod, mi in data.get(\"modules\", {}).items():\n                self.modules[mod] = ModuleInfo(**mi)\n            self.calls = [tuple(x) for x in data.get(\"calls\", [])]\n            self.module_to_tests = data.get(\"module_to_tests\", {})\n            self.module_imports = data.get(\"module_imports\", {})\n            self._cached_mtimes = {k: int(v) for k, v in (mt or {}).items()}\n            self._cached_hashes = {k: str(v) for k, v in (hh or {}).items()}\n            return True\n        except Exception:\n            return False\n\n    def _load_cache_relaxed(self, cache_path: str) -> bool:\n        try:\n            if not os.path.exists(cache_path):\n                return False\n            data = json.loads(open(cache_path, \"r\", encoding=\"utf-8\").read())\n            if str(data.get(\"version\", \"\")) != \"3\":\n                return False\n            self.indexed_files = data.get(\"indexed_files\", [])\n            for s in data.get(\"symbols\", []):\n                sym = Symbol(**s)\n                self._add_symbol(sym)\n            for mod, mi in data.get(\"modules\", {}).items():\n                self.modules[mod] = ModuleInfo(**mi)\n            self.calls = [tuple(x) for x in data.get(\"calls\", [])]\n            self.module_to_tests = data.get(\"module_to_tests\", {})\n            self.module_imports = data.get(\"module_imports\", {})\n            self._cached_mtimes = {\n                k: int(v) for k, v in (data.get(\"mtimes\", {}) or {}).items()\n            }\n            self._cached_hashes = {\n                k: str(v) for k, v in (data.get(\"hashes\", {}) or {}).items()\n            }\n            return True\n        except Exception:\n            return False\n\n    def _detect_changed_files(\n        self, old_mt: Dict[str, int], old_hh: Dict[str, str]\n    ) -> Tuple[List[str], List[str]]:\n        curr_files: List[str] = []\n        for dirpath, dirnames, filenames in os.walk(self.root):\n            dir_rel = os.path.relpath(dirpath, self.root)\n            dirnames[:] = [d for d in dirnames if not self._is_ignored(os.path.join(dir_rel, d))]\n            if self._is_ignored(dir_rel):\n                continue\n            for fn in filenames:\n                if fn.endswith(\".py\"):\n                    fp = os.path.join(dirpath, fn)\n                    if self._is_ignored(os.path.relpath(fp, self.root)):\n                        continue\n                    curr_files.append(fp)\n        curr = set(curr_files)\n        prev = set(self.indexed_files or [])\n        removed = list(prev - curr)\n        added = list(curr - prev)","source_hash":"e28a996e3c22e28318f33e970701e56c53d2becd271f9615a0269e11078879c6","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.code_graph._detect_changed_files","uri":"program://TOLBERT/function/scripts.code_graph._detect_changed_files#L587-L617","kind":"function","name":"_detect_changed_files","path":"scripts/code_graph.py","language":"python","start_line":587,"end_line":617,"context_start_line":567,"context_end_line":637,"code":"                return False\n            self.indexed_files = data.get(\"indexed_files\", [])\n            for s in data.get(\"symbols\", []):\n                sym = Symbol(**s)\n                self._add_symbol(sym)\n            for mod, mi in data.get(\"modules\", {}).items():\n                self.modules[mod] = ModuleInfo(**mi)\n            self.calls = [tuple(x) for x in data.get(\"calls\", [])]\n            self.module_to_tests = data.get(\"module_to_tests\", {})\n            self.module_imports = data.get(\"module_imports\", {})\n            self._cached_mtimes = {\n                k: int(v) for k, v in (data.get(\"mtimes\", {}) or {}).items()\n            }\n            self._cached_hashes = {\n                k: str(v) for k, v in (data.get(\"hashes\", {}) or {}).items()\n            }\n            return True\n        except Exception:\n            return False\n\n    def _detect_changed_files(\n        self, old_mt: Dict[str, int], old_hh: Dict[str, str]\n    ) -> Tuple[List[str], List[str]]:\n        curr_files: List[str] = []\n        for dirpath, dirnames, filenames in os.walk(self.root):\n            dir_rel = os.path.relpath(dirpath, self.root)\n            dirnames[:] = [d for d in dirnames if not self._is_ignored(os.path.join(dir_rel, d))]\n            if self._is_ignored(dir_rel):\n                continue\n            for fn in filenames:\n                if fn.endswith(\".py\"):\n                    fp = os.path.join(dirpath, fn)\n                    if self._is_ignored(os.path.relpath(fp, self.root)):\n                        continue\n                    curr_files.append(fp)\n        curr = set(curr_files)\n        prev = set(self.indexed_files or [])\n        removed = list(prev - curr)\n        added = list(curr - prev)\n        changed: List[str] = list(added)\n        for f in curr & prev:\n            try:\n                mt = int(os.path.getmtime(f))\n                hh = self._file_hash(f)\n            except Exception:\n                changed.append(f)\n                continue\n            if old_mt.get(f) != mt or old_hh.get(f) != hh:\n                changed.append(f)\n        self.indexed_files = sorted(list(curr))\n        return sorted(set(changed)), sorted(removed)\n\n    def _incremental_reindex(\n        self, changed_files: List[str], removed_files: List[str]\n    ) -> None:\n        # purge removed modules\n        for f in removed_files:\n            m = self._module_name_for_path(f)\n            if m in self.modules:\n                to_remove = [\n                    fqn for fqn, s in list(self.symbols_by_fqn.items()) if s.module == m\n                ]\n                for fqn in to_remove:\n                    s = self.symbols_by_fqn.pop(fqn, None)\n                    if s:\n                        self.symbols_by_name[s.name] = [\n                            x for x in self.symbols_by_name.get(s.name, []) if x != fqn\n                        ]\n                self.calls = [\n                    (a, b) for (a, b) in self.calls if not a.startswith(m + \".\")\n                ]","source_hash":"e28a996e3c22e28318f33e970701e56c53d2becd271f9615a0269e11078879c6","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.code_graph._incremental_reindex","uri":"program://TOLBERT/function/scripts.code_graph._incremental_reindex#L619-L653","kind":"function","name":"_incremental_reindex","path":"scripts/code_graph.py","language":"python","start_line":619,"end_line":653,"context_start_line":599,"context_end_line":673,"code":"                    if self._is_ignored(os.path.relpath(fp, self.root)):\n                        continue\n                    curr_files.append(fp)\n        curr = set(curr_files)\n        prev = set(self.indexed_files or [])\n        removed = list(prev - curr)\n        added = list(curr - prev)\n        changed: List[str] = list(added)\n        for f in curr & prev:\n            try:\n                mt = int(os.path.getmtime(f))\n                hh = self._file_hash(f)\n            except Exception:\n                changed.append(f)\n                continue\n            if old_mt.get(f) != mt or old_hh.get(f) != hh:\n                changed.append(f)\n        self.indexed_files = sorted(list(curr))\n        return sorted(set(changed)), sorted(removed)\n\n    def _incremental_reindex(\n        self, changed_files: List[str], removed_files: List[str]\n    ) -> None:\n        # purge removed modules\n        for f in removed_files:\n            m = self._module_name_for_path(f)\n            if m in self.modules:\n                to_remove = [\n                    fqn for fqn, s in list(self.symbols_by_fqn.items()) if s.module == m\n                ]\n                for fqn in to_remove:\n                    s = self.symbols_by_fqn.pop(fqn, None)\n                    if s:\n                        self.symbols_by_name[s.name] = [\n                            x for x in self.symbols_by_name.get(s.name, []) if x != fqn\n                        ]\n                self.calls = [\n                    (a, b) for (a, b) in self.calls if not a.startswith(m + \".\")\n                ]\n                self.modules.pop(m, None)\n                self.module_imports.pop(m, None)\n                self.module_star_imports.pop(m, None)\n        mods = {self._module_name_for_path(f) for f in changed_files}\n        # include dependents via reverse import graph\n        rev = self._reverse_imports()\n        queue = list(mods)\n        seen = set(mods)\n        while queue:\n            m = queue.pop(0)\n            for dep in rev.get(m, []):\n                if dep not in seen:\n                    seen.add(dep)\n                    queue.append(dep)\n        for m in seen:\n            self._reindex_module(m)\n\n    def _reverse_imports(self) -> Dict[str, List[str]]:\n        rev: Dict[str, List[str]] = {}\n        for m, deps in self.module_imports.items():\n            for d in deps:\n                rev.setdefault(d, []).append(m)\n        return rev\n\n    def _reindex_module(self, module: str) -> None:\n        mi = self.modules.get(module)\n        if not mi:\n            return\n        # remove existing symbols and calls for this module\n        to_remove = [\n            fqn for fqn, s in self.symbols_by_fqn.items() if s.module == module\n        ]\n        for fqn in to_remove:\n            s = self.symbols_by_fqn.pop(fqn, None)\n            if s:\n                lst = self.symbols_by_name.get(s.name, [])","source_hash":"e28a996e3c22e28318f33e970701e56c53d2becd271f9615a0269e11078879c6","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.code_graph._reverse_imports","uri":"program://TOLBERT/function/scripts.code_graph._reverse_imports#L655-L660","kind":"function","name":"_reverse_imports","path":"scripts/code_graph.py","language":"python","start_line":655,"end_line":660,"context_start_line":635,"context_end_line":680,"code":"                self.calls = [\n                    (a, b) for (a, b) in self.calls if not a.startswith(m + \".\")\n                ]\n                self.modules.pop(m, None)\n                self.module_imports.pop(m, None)\n                self.module_star_imports.pop(m, None)\n        mods = {self._module_name_for_path(f) for f in changed_files}\n        # include dependents via reverse import graph\n        rev = self._reverse_imports()\n        queue = list(mods)\n        seen = set(mods)\n        while queue:\n            m = queue.pop(0)\n            for dep in rev.get(m, []):\n                if dep not in seen:\n                    seen.add(dep)\n                    queue.append(dep)\n        for m in seen:\n            self._reindex_module(m)\n\n    def _reverse_imports(self) -> Dict[str, List[str]]:\n        rev: Dict[str, List[str]] = {}\n        for m, deps in self.module_imports.items():\n            for d in deps:\n                rev.setdefault(d, []).append(m)\n        return rev\n\n    def _reindex_module(self, module: str) -> None:\n        mi = self.modules.get(module)\n        if not mi:\n            return\n        # remove existing symbols and calls for this module\n        to_remove = [\n            fqn for fqn, s in self.symbols_by_fqn.items() if s.module == module\n        ]\n        for fqn in to_remove:\n            s = self.symbols_by_fqn.pop(fqn, None)\n            if s:\n                lst = self.symbols_by_name.get(s.name, [])\n                self.symbols_by_name[s.name] = [x for x in lst if x != fqn]\n        self.calls = [(a, b) for (a, b) in self.calls if not a.startswith(module + \".\")]\n        # reset import maps for this module\n        self.modules[module].imports = {}\n        self.module_imports[module] = []\n        self.module_star_imports[module] = []\n        # re-parse","source_hash":"e28a996e3c22e28318f33e970701e56c53d2becd271f9615a0269e11078879c6","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.code_graph._reindex_module","uri":"program://TOLBERT/function/scripts.code_graph._reindex_module#L662-L696","kind":"function","name":"_reindex_module","path":"scripts/code_graph.py","language":"python","start_line":662,"end_line":696,"context_start_line":642,"context_end_line":716,"code":"        # include dependents via reverse import graph\n        rev = self._reverse_imports()\n        queue = list(mods)\n        seen = set(mods)\n        while queue:\n            m = queue.pop(0)\n            for dep in rev.get(m, []):\n                if dep not in seen:\n                    seen.add(dep)\n                    queue.append(dep)\n        for m in seen:\n            self._reindex_module(m)\n\n    def _reverse_imports(self) -> Dict[str, List[str]]:\n        rev: Dict[str, List[str]] = {}\n        for m, deps in self.module_imports.items():\n            for d in deps:\n                rev.setdefault(d, []).append(m)\n        return rev\n\n    def _reindex_module(self, module: str) -> None:\n        mi = self.modules.get(module)\n        if not mi:\n            return\n        # remove existing symbols and calls for this module\n        to_remove = [\n            fqn for fqn, s in self.symbols_by_fqn.items() if s.module == module\n        ]\n        for fqn in to_remove:\n            s = self.symbols_by_fqn.pop(fqn, None)\n            if s:\n                lst = self.symbols_by_name.get(s.name, [])\n                self.symbols_by_name[s.name] = [x for x in lst if x != fqn]\n        self.calls = [(a, b) for (a, b) in self.calls if not a.startswith(module + \".\")]\n        # reset import maps for this module\n        self.modules[module].imports = {}\n        self.module_imports[module] = []\n        self.module_star_imports[module] = []\n        # re-parse\n        try:\n            src = open(mi.file, \"r\", encoding=\"utf-8\").read()\n            tree = ast.parse(src)\n        except Exception:\n            return\n        visitor = _ModuleVisitor(module, mi.file)\n        visitor.visit(tree)\n        self.modules[module].imports.update(visitor.imports)\n        self.module_imports[module] = sorted(visitor.import_modules)\n        self.module_star_imports[module] = list(getattr(visitor, \"star_imports\", []))\n        self.modules[module].exports = list(getattr(visitor, \"exports\", []))\n        for sym in visitor.symbols:\n            self._add_symbol(sym)\n        for caller, callee_key in visitor.calls:\n            callee_fqn = self._resolve_callee(module, callee_key, visitor)\n            self.calls.append((caller, callee_fqn or callee_key))\n\n    def _save_cache(self, cache_path: str) -> None:\n        try:\n            mt = {f: int(os.path.getmtime(f)) for f in self.indexed_files}\n            hh = {f: self._file_hash(f) for f in self.indexed_files}\n            data = {\n                \"version\": \"3\",\n                \"indexed_files\": self.indexed_files,\n                \"mtimes\": mt,\n                \"hashes\": hh,\n                \"symbols\": [self._sym_to_dict(s) for s in self.symbols_by_fqn.values()],\n                \"modules\": {k: self._mi_to_dict(v) for k, v in self.modules.items()},\n                \"calls\": self.calls,\n                \"module_to_tests\": self.module_to_tests,\n                \"module_imports\": self.module_imports,\n            }\n            open(cache_path, \"w\", encoding=\"utf-8\").write(json.dumps(data))\n        except Exception:\n            pass\n","source_hash":"e28a996e3c22e28318f33e970701e56c53d2becd271f9615a0269e11078879c6","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.code_graph._save_cache","uri":"program://TOLBERT/function/scripts.code_graph._save_cache#L698-L715","kind":"function","name":"_save_cache","path":"scripts/code_graph.py","language":"python","start_line":698,"end_line":715,"context_start_line":678,"context_end_line":735,"code":"        self.module_imports[module] = []\n        self.module_star_imports[module] = []\n        # re-parse\n        try:\n            src = open(mi.file, \"r\", encoding=\"utf-8\").read()\n            tree = ast.parse(src)\n        except Exception:\n            return\n        visitor = _ModuleVisitor(module, mi.file)\n        visitor.visit(tree)\n        self.modules[module].imports.update(visitor.imports)\n        self.module_imports[module] = sorted(visitor.import_modules)\n        self.module_star_imports[module] = list(getattr(visitor, \"star_imports\", []))\n        self.modules[module].exports = list(getattr(visitor, \"exports\", []))\n        for sym in visitor.symbols:\n            self._add_symbol(sym)\n        for caller, callee_key in visitor.calls:\n            callee_fqn = self._resolve_callee(module, callee_key, visitor)\n            self.calls.append((caller, callee_fqn or callee_key))\n\n    def _save_cache(self, cache_path: str) -> None:\n        try:\n            mt = {f: int(os.path.getmtime(f)) for f in self.indexed_files}\n            hh = {f: self._file_hash(f) for f in self.indexed_files}\n            data = {\n                \"version\": \"3\",\n                \"indexed_files\": self.indexed_files,\n                \"mtimes\": mt,\n                \"hashes\": hh,\n                \"symbols\": [self._sym_to_dict(s) for s in self.symbols_by_fqn.values()],\n                \"modules\": {k: self._mi_to_dict(v) for k, v in self.modules.items()},\n                \"calls\": self.calls,\n                \"module_to_tests\": self.module_to_tests,\n                \"module_imports\": self.module_imports,\n            }\n            open(cache_path, \"w\", encoding=\"utf-8\").write(json.dumps(data))\n        except Exception:\n            pass\n\n    def _sym_to_dict(self, s: Symbol) -> Dict[str, Any]:\n        return {\n            \"fqn\": s.fqn,\n            \"name\": s.name,\n            \"qualname\": s.qualname,\n            \"kind\": s.kind,\n            \"module\": s.module,\n            \"file\": s.file,\n            \"line\": s.line,\n            \"end_line\": s.end_line,\n            \"doc\": s.doc,\n            \"signature\": s.signature,\n            \"returns\": s.returns,\n        }\n\n    def _mi_to_dict(self, mi: ModuleInfo) -> Dict[str, Any]:\n        return {\n            \"module\": mi.module,\n            \"file\": mi.file,","source_hash":"e28a996e3c22e28318f33e970701e56c53d2becd271f9615a0269e11078879c6","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.code_graph._sym_to_dict","uri":"program://TOLBERT/function/scripts.code_graph._sym_to_dict#L717-L730","kind":"function","name":"_sym_to_dict","path":"scripts/code_graph.py","language":"python","start_line":717,"end_line":730,"context_start_line":697,"context_end_line":750,"code":"\n    def _save_cache(self, cache_path: str) -> None:\n        try:\n            mt = {f: int(os.path.getmtime(f)) for f in self.indexed_files}\n            hh = {f: self._file_hash(f) for f in self.indexed_files}\n            data = {\n                \"version\": \"3\",\n                \"indexed_files\": self.indexed_files,\n                \"mtimes\": mt,\n                \"hashes\": hh,\n                \"symbols\": [self._sym_to_dict(s) for s in self.symbols_by_fqn.values()],\n                \"modules\": {k: self._mi_to_dict(v) for k, v in self.modules.items()},\n                \"calls\": self.calls,\n                \"module_to_tests\": self.module_to_tests,\n                \"module_imports\": self.module_imports,\n            }\n            open(cache_path, \"w\", encoding=\"utf-8\").write(json.dumps(data))\n        except Exception:\n            pass\n\n    def _sym_to_dict(self, s: Symbol) -> Dict[str, Any]:\n        return {\n            \"fqn\": s.fqn,\n            \"name\": s.name,\n            \"qualname\": s.qualname,\n            \"kind\": s.kind,\n            \"module\": s.module,\n            \"file\": s.file,\n            \"line\": s.line,\n            \"end_line\": s.end_line,\n            \"doc\": s.doc,\n            \"signature\": s.signature,\n            \"returns\": s.returns,\n        }\n\n    def _mi_to_dict(self, mi: ModuleInfo) -> Dict[str, Any]:\n        return {\n            \"module\": mi.module,\n            \"file\": mi.file,\n            \"is_test\": mi.is_test,\n            \"imports\": mi.imports,\n            \"defs\": mi.defs,\n            \"exports\": mi.exports,\n        }\n\n    def _is_builtin_name(self, name: str) -> bool:\n        try:\n            import builtins as _bi  # type: ignore\n\n            if hasattr(_bi, name):\n                return True\n        except Exception:\n            pass\n        return name in {","source_hash":"e28a996e3c22e28318f33e970701e56c53d2becd271f9615a0269e11078879c6","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.code_graph._mi_to_dict","uri":"program://TOLBERT/function/scripts.code_graph._mi_to_dict#L732-L740","kind":"function","name":"_mi_to_dict","path":"scripts/code_graph.py","language":"python","start_line":732,"end_line":740,"context_start_line":712,"context_end_line":760,"code":"            }\n            open(cache_path, \"w\", encoding=\"utf-8\").write(json.dumps(data))\n        except Exception:\n            pass\n\n    def _sym_to_dict(self, s: Symbol) -> Dict[str, Any]:\n        return {\n            \"fqn\": s.fqn,\n            \"name\": s.name,\n            \"qualname\": s.qualname,\n            \"kind\": s.kind,\n            \"module\": s.module,\n            \"file\": s.file,\n            \"line\": s.line,\n            \"end_line\": s.end_line,\n            \"doc\": s.doc,\n            \"signature\": s.signature,\n            \"returns\": s.returns,\n        }\n\n    def _mi_to_dict(self, mi: ModuleInfo) -> Dict[str, Any]:\n        return {\n            \"module\": mi.module,\n            \"file\": mi.file,\n            \"is_test\": mi.is_test,\n            \"imports\": mi.imports,\n            \"defs\": mi.defs,\n            \"exports\": mi.exports,\n        }\n\n    def _is_builtin_name(self, name: str) -> bool:\n        try:\n            import builtins as _bi  # type: ignore\n\n            if hasattr(_bi, name):\n                return True\n        except Exception:\n            pass\n        return name in {\n            \"super\",\n            \"property\",\n            \"globals\",\n            \"locals\",\n            \"__import__\",\n            \"print\",\n            \"len\",\n            \"range\",\n            \"dict\",\n            \"list\",","source_hash":"e28a996e3c22e28318f33e970701e56c53d2becd271f9615a0269e11078879c6","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.code_graph._is_builtin_name","uri":"program://TOLBERT/function/scripts.code_graph._is_builtin_name#L742-L783","kind":"function","name":"_is_builtin_name","path":"scripts/code_graph.py","language":"python","start_line":742,"end_line":783,"context_start_line":722,"context_end_line":803,"code":"            \"kind\": s.kind,\n            \"module\": s.module,\n            \"file\": s.file,\n            \"line\": s.line,\n            \"end_line\": s.end_line,\n            \"doc\": s.doc,\n            \"signature\": s.signature,\n            \"returns\": s.returns,\n        }\n\n    def _mi_to_dict(self, mi: ModuleInfo) -> Dict[str, Any]:\n        return {\n            \"module\": mi.module,\n            \"file\": mi.file,\n            \"is_test\": mi.is_test,\n            \"imports\": mi.imports,\n            \"defs\": mi.defs,\n            \"exports\": mi.exports,\n        }\n\n    def _is_builtin_name(self, name: str) -> bool:\n        try:\n            import builtins as _bi  # type: ignore\n\n            if hasattr(_bi, name):\n                return True\n        except Exception:\n            pass\n        return name in {\n            \"super\",\n            \"property\",\n            \"globals\",\n            \"locals\",\n            \"__import__\",\n            \"print\",\n            \"len\",\n            \"range\",\n            \"dict\",\n            \"list\",\n            \"set\",\n            \"tuple\",\n            \"int\",\n            \"float\",\n            \"bool\",\n            \"max\",\n            \"min\",\n            \"sum\",\n            \"open\",\n            \"enumerate\",\n            \"zip\",\n            \"map\",\n            \"filter\",\n            \"round\",\n            \"any\",\n            \"all\",\n            \"sorted\",\n            \"hasattr\",\n            \"getattr\",\n            \"setattr\",\n            \"isinstance\",\n            \"issubclass\",\n        }\n\n    def _file_hash(self, path: str) -> str:\n        try:\n            import hashlib\n\n            with open(path, \"rb\") as rf:\n                return hashlib.sha1(rf.read()).hexdigest()\n        except Exception:\n            return \"\"\n\n    # --- Coverage --- #\n\n    def attach_coverage_from_xml(self, xml_path: str) -> None:\n        try:\n            import xml.etree.ElementTree as ET\n\n            tree = ET.parse(xml_path)\n            root = tree.getroot()\n            files_hits: Dict[str, set[int]] = {}\n            # coverage.py XML: <class filename=\"path\"> ... <lines><line number=\"N\" hits=\"H\"/></lines>","source_hash":"e28a996e3c22e28318f33e970701e56c53d2becd271f9615a0269e11078879c6","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.code_graph._file_hash","uri":"program://TOLBERT/function/scripts.code_graph._file_hash#L785-L792","kind":"function","name":"_file_hash","path":"scripts/code_graph.py","language":"python","start_line":785,"end_line":792,"context_start_line":765,"context_end_line":812,"code":"            \"bool\",\n            \"max\",\n            \"min\",\n            \"sum\",\n            \"open\",\n            \"enumerate\",\n            \"zip\",\n            \"map\",\n            \"filter\",\n            \"round\",\n            \"any\",\n            \"all\",\n            \"sorted\",\n            \"hasattr\",\n            \"getattr\",\n            \"setattr\",\n            \"isinstance\",\n            \"issubclass\",\n        }\n\n    def _file_hash(self, path: str) -> str:\n        try:\n            import hashlib\n\n            with open(path, \"rb\") as rf:\n                return hashlib.sha1(rf.read()).hexdigest()\n        except Exception:\n            return \"\"\n\n    # --- Coverage --- #\n\n    def attach_coverage_from_xml(self, xml_path: str) -> None:\n        try:\n            import xml.etree.ElementTree as ET\n\n            tree = ET.parse(xml_path)\n            root = tree.getroot()\n            files_hits: Dict[str, set[int]] = {}\n            # coverage.py XML: <class filename=\"path\"> ... <lines><line number=\"N\" hits=\"H\"/></lines>\n            for cls in root.findall(\".//class\"):\n                fn = cls.attrib.get(\"filename\", \"\")\n                if not fn:\n                    continue\n                # Normalize to absolute path\n                f_abs = (\n                    fn\n                    if os.path.isabs(fn)\n                    else os.path.abspath(os.path.join(self.root, fn))","source_hash":"e28a996e3c22e28318f33e970701e56c53d2becd271f9615a0269e11078879c6","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.code_graph.attach_coverage_from_xml","uri":"program://TOLBERT/function/scripts.code_graph.attach_coverage_from_xml#L796-L860","kind":"function","name":"attach_coverage_from_xml","path":"scripts/code_graph.py","language":"python","start_line":796,"end_line":860,"context_start_line":776,"context_end_line":880,"code":"            \"all\",\n            \"sorted\",\n            \"hasattr\",\n            \"getattr\",\n            \"setattr\",\n            \"isinstance\",\n            \"issubclass\",\n        }\n\n    def _file_hash(self, path: str) -> str:\n        try:\n            import hashlib\n\n            with open(path, \"rb\") as rf:\n                return hashlib.sha1(rf.read()).hexdigest()\n        except Exception:\n            return \"\"\n\n    # --- Coverage --- #\n\n    def attach_coverage_from_xml(self, xml_path: str) -> None:\n        try:\n            import xml.etree.ElementTree as ET\n\n            tree = ET.parse(xml_path)\n            root = tree.getroot()\n            files_hits: Dict[str, set[int]] = {}\n            # coverage.py XML: <class filename=\"path\"> ... <lines><line number=\"N\" hits=\"H\"/></lines>\n            for cls in root.findall(\".//class\"):\n                fn = cls.attrib.get(\"filename\", \"\")\n                if not fn:\n                    continue\n                # Normalize to absolute path\n                f_abs = (\n                    fn\n                    if os.path.isabs(fn)\n                    else os.path.abspath(os.path.join(self.root, fn))\n                )\n                hits = files_hits.setdefault(f_abs, set())\n                for ln in cls.findall(\".//line\"):\n                    try:\n                        num = int(ln.attrib.get(\"number\", \"0\"))\n                        h = int(ln.attrib.get(\"hits\", \"0\"))\n                        if h > 0:\n                            hits.add(num)\n                    except Exception:\n                        continue\n            # Some coverage.xml variants place <file> nodes\n            if not files_hits:\n                for fnode in root.findall(\".//file\"):\n                    fn = fnode.attrib.get(\"filename\", \"\")\n                    if not fn:\n                        continue\n                    f_abs = (\n                        fn\n                        if os.path.isabs(fn)\n                        else os.path.abspath(os.path.join(self.root, fn))\n                    )\n                    hits = files_hits.setdefault(f_abs, set())\n                    for ln in fnode.findall(\".//line\"):\n                        try:\n                            num = int(ln.attrib.get(\"number\", \"0\"))\n                            h = int(ln.attrib.get(\"hits\", \"0\"))\n                            if h > 0:\n                                hits.add(num)\n                        except Exception:\n                            continue\n            self.coverage_files = files_hits\n            # Compute per-symbol coverage\n            sym_cov: Dict[str, float] = {}\n            for fqn, sym in self.symbols_by_fqn.items():\n                covered = files_hits.get(sym.file, set())\n                a = int(sym.line)\n                b = int(sym.end_line) if int(sym.end_line) >= a else a\n                span = list(range(a, b + 1))\n                if not span:\n                    sym_cov[fqn] = 0.0\n                    continue\n                hits = sum(1 for x in span if x in covered)\n                sym_cov[fqn] = hits / float(len(span))\n            self.symbol_coverage = sym_cov\n        except Exception:\n            # Leave coverage empty on error\n            self.coverage_files = {}\n            self.symbol_coverage = {}\n\n    def coverage_of(self, fqn: str) -> Optional[float]:\n        return self.symbol_coverage.get(fqn)\n\n\ndef _cli() -> None:\n    import argparse\n    import json\n\n    p = argparse.ArgumentParser()\n    p.add_argument(\"root\", nargs=\"?\", default=\"./repo\")\n    p.add_argument(\"--ignore\", action=\"append\", default=None, help=\"Relative paths to ignore (repeatable)\")\n    p.add_argument(\"--owners-of\", dest=\"owners_of\", default=None)\n    p.add_argument(\"--search\", dest=\"search\", default=None)\n    p.add_argument(\"--defs-in\", dest=\"defs_in\", default=None)\n    p.add_argument(\"--calls-of\", dest=\"calls_of\", default=None)\n    p.add_argument(\"--who-calls\", dest=\"who_calls\", default=None)\n    p.add_argument(\"--dump\", dest=\"dump\", action=\"store_true\")\n    p.add_argument(\"--coverage-xml\", dest=\"coverage_xml\", default=None)\n    p.add_argument(\"--coverage-of\", dest=\"coverage_of\", default=None)","source_hash":"e28a996e3c22e28318f33e970701e56c53d2becd271f9615a0269e11078879c6","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.code_graph.coverage_of","uri":"program://TOLBERT/function/scripts.code_graph.coverage_of#L862-L863","kind":"function","name":"coverage_of","path":"scripts/code_graph.py","language":"python","start_line":862,"end_line":863,"context_start_line":842,"context_end_line":883,"code":"                            continue\n            self.coverage_files = files_hits\n            # Compute per-symbol coverage\n            sym_cov: Dict[str, float] = {}\n            for fqn, sym in self.symbols_by_fqn.items():\n                covered = files_hits.get(sym.file, set())\n                a = int(sym.line)\n                b = int(sym.end_line) if int(sym.end_line) >= a else a\n                span = list(range(a, b + 1))\n                if not span:\n                    sym_cov[fqn] = 0.0\n                    continue\n                hits = sum(1 for x in span if x in covered)\n                sym_cov[fqn] = hits / float(len(span))\n            self.symbol_coverage = sym_cov\n        except Exception:\n            # Leave coverage empty on error\n            self.coverage_files = {}\n            self.symbol_coverage = {}\n\n    def coverage_of(self, fqn: str) -> Optional[float]:\n        return self.symbol_coverage.get(fqn)\n\n\ndef _cli() -> None:\n    import argparse\n    import json\n\n    p = argparse.ArgumentParser()\n    p.add_argument(\"root\", nargs=\"?\", default=\"./repo\")\n    p.add_argument(\"--ignore\", action=\"append\", default=None, help=\"Relative paths to ignore (repeatable)\")\n    p.add_argument(\"--owners-of\", dest=\"owners_of\", default=None)\n    p.add_argument(\"--search\", dest=\"search\", default=None)\n    p.add_argument(\"--defs-in\", dest=\"defs_in\", default=None)\n    p.add_argument(\"--calls-of\", dest=\"calls_of\", default=None)\n    p.add_argument(\"--who-calls\", dest=\"who_calls\", default=None)\n    p.add_argument(\"--dump\", dest=\"dump\", action=\"store_true\")\n    p.add_argument(\"--coverage-xml\", dest=\"coverage_xml\", default=None)\n    p.add_argument(\"--coverage-of\", dest=\"coverage_of\", default=None)\n    p.add_argument(\"--refs-of\", dest=\"refs_of\", default=None)\n    p.add_argument(\"--tests-for\", dest=\"tests_for\", default=None)\n    p.add_argument(\"--tests-for-module\", dest=\"tests_for_module\", default=None)","source_hash":"e28a996e3c22e28318f33e970701e56c53d2becd271f9615a0269e11078879c6","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.code_graph._cur_qualname","uri":"program://TOLBERT/function/scripts.code_graph._cur_qualname#L974-L975","kind":"function","name":"_cur_qualname","path":"scripts/code_graph.py","language":"python","start_line":974,"end_line":975,"context_start_line":954,"context_end_line":995,"code":"            )\n        )\n        return\n    # Dump summary\n    print(json.dumps({\"files\": len(g.indexed_files), \"symbols\": len(g.symbols_by_fqn)}))\n\n\nclass _ModuleVisitor(ast.NodeVisitor):\n    def __init__(self, module: str, path: str) -> None:\n        self.module = module\n        self.path = path\n        self.symbols: List[Symbol] = []\n        self.calls: List[Tuple[str, str]] = []  # (caller_fqn, callee_key)\n        self.stack: List[str] = []  # qualname stack\n        self.class_stack: List[str] = []\n        self.imports: Dict[str, str] = {}\n        self.import_modules: List[str] = []\n        self.star_imports: List[str] = []\n        self.exports: List[str] = []\n\n    def _cur_qualname(self) -> str:\n        return \".\".join(self.stack)\n\n    def _cur_class(self) -> Optional[str]:\n        return self.class_stack[-1] if self.class_stack else None\n\n    def _fqn(self, name: str) -> str:\n        q = self._cur_qualname()\n        return f\"{self.module}.{q + ('.' if q else '')}{name}\"\n\n    def visit_Import(self, node: ast.Import) -> Any:  # type: ignore[override]\n        for alias in node.names:\n            asname = alias.asname or alias.name.split(\".\")[-1]\n            self.imports[asname] = alias.name\n            self.import_modules.append(alias.name.split(\".\")[0])\n        self.generic_visit(node)\n\n    def visit_ImportFrom(self, node: ast.ImportFrom) -> Any:  # type: ignore[override]\n        # Resolve relative imports: from .x import y\n        if node.level and node.module:\n            base = self.module.split(\".\")\n            up = max(0, int(node.level))","source_hash":"e28a996e3c22e28318f33e970701e56c53d2becd271f9615a0269e11078879c6","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.code_graph._cur_class","uri":"program://TOLBERT/function/scripts.code_graph._cur_class#L977-L978","kind":"function","name":"_cur_class","path":"scripts/code_graph.py","language":"python","start_line":977,"end_line":978,"context_start_line":957,"context_end_line":998,"code":"    # Dump summary\n    print(json.dumps({\"files\": len(g.indexed_files), \"symbols\": len(g.symbols_by_fqn)}))\n\n\nclass _ModuleVisitor(ast.NodeVisitor):\n    def __init__(self, module: str, path: str) -> None:\n        self.module = module\n        self.path = path\n        self.symbols: List[Symbol] = []\n        self.calls: List[Tuple[str, str]] = []  # (caller_fqn, callee_key)\n        self.stack: List[str] = []  # qualname stack\n        self.class_stack: List[str] = []\n        self.imports: Dict[str, str] = {}\n        self.import_modules: List[str] = []\n        self.star_imports: List[str] = []\n        self.exports: List[str] = []\n\n    def _cur_qualname(self) -> str:\n        return \".\".join(self.stack)\n\n    def _cur_class(self) -> Optional[str]:\n        return self.class_stack[-1] if self.class_stack else None\n\n    def _fqn(self, name: str) -> str:\n        q = self._cur_qualname()\n        return f\"{self.module}.{q + ('.' if q else '')}{name}\"\n\n    def visit_Import(self, node: ast.Import) -> Any:  # type: ignore[override]\n        for alias in node.names:\n            asname = alias.asname or alias.name.split(\".\")[-1]\n            self.imports[asname] = alias.name\n            self.import_modules.append(alias.name.split(\".\")[0])\n        self.generic_visit(node)\n\n    def visit_ImportFrom(self, node: ast.ImportFrom) -> Any:  # type: ignore[override]\n        # Resolve relative imports: from .x import y\n        if node.level and node.module:\n            base = self.module.split(\".\")\n            up = max(0, int(node.level))\n            prefix = base[:-up] if up > 0 else base\n            mod = \".\".join([p for p in prefix if p] + [node.module])\n        elif node.level and not node.module:","source_hash":"e28a996e3c22e28318f33e970701e56c53d2becd271f9615a0269e11078879c6","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.code_graph._fqn","uri":"program://TOLBERT/function/scripts.code_graph._fqn#L980-L982","kind":"function","name":"_fqn","path":"scripts/code_graph.py","language":"python","start_line":980,"end_line":982,"context_start_line":960,"context_end_line":1002,"code":"\nclass _ModuleVisitor(ast.NodeVisitor):\n    def __init__(self, module: str, path: str) -> None:\n        self.module = module\n        self.path = path\n        self.symbols: List[Symbol] = []\n        self.calls: List[Tuple[str, str]] = []  # (caller_fqn, callee_key)\n        self.stack: List[str] = []  # qualname stack\n        self.class_stack: List[str] = []\n        self.imports: Dict[str, str] = {}\n        self.import_modules: List[str] = []\n        self.star_imports: List[str] = []\n        self.exports: List[str] = []\n\n    def _cur_qualname(self) -> str:\n        return \".\".join(self.stack)\n\n    def _cur_class(self) -> Optional[str]:\n        return self.class_stack[-1] if self.class_stack else None\n\n    def _fqn(self, name: str) -> str:\n        q = self._cur_qualname()\n        return f\"{self.module}.{q + ('.' if q else '')}{name}\"\n\n    def visit_Import(self, node: ast.Import) -> Any:  # type: ignore[override]\n        for alias in node.names:\n            asname = alias.asname or alias.name.split(\".\")[-1]\n            self.imports[asname] = alias.name\n            self.import_modules.append(alias.name.split(\".\")[0])\n        self.generic_visit(node)\n\n    def visit_ImportFrom(self, node: ast.ImportFrom) -> Any:  # type: ignore[override]\n        # Resolve relative imports: from .x import y\n        if node.level and node.module:\n            base = self.module.split(\".\")\n            up = max(0, int(node.level))\n            prefix = base[:-up] if up > 0 else base\n            mod = \".\".join([p for p in prefix if p] + [node.module])\n        elif node.level and not node.module:\n            base = self.module.split(\".\")\n            up = max(0, int(node.level))\n            mod = \".\".join(base[:-up])\n        else:","source_hash":"e28a996e3c22e28318f33e970701e56c53d2becd271f9615a0269e11078879c6","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.code_graph.visit_Import","uri":"program://TOLBERT/function/scripts.code_graph.visit_Import#L984-L989","kind":"function","name":"visit_Import","path":"scripts/code_graph.py","language":"python","start_line":984,"end_line":989,"context_start_line":964,"context_end_line":1009,"code":"        self.path = path\n        self.symbols: List[Symbol] = []\n        self.calls: List[Tuple[str, str]] = []  # (caller_fqn, callee_key)\n        self.stack: List[str] = []  # qualname stack\n        self.class_stack: List[str] = []\n        self.imports: Dict[str, str] = {}\n        self.import_modules: List[str] = []\n        self.star_imports: List[str] = []\n        self.exports: List[str] = []\n\n    def _cur_qualname(self) -> str:\n        return \".\".join(self.stack)\n\n    def _cur_class(self) -> Optional[str]:\n        return self.class_stack[-1] if self.class_stack else None\n\n    def _fqn(self, name: str) -> str:\n        q = self._cur_qualname()\n        return f\"{self.module}.{q + ('.' if q else '')}{name}\"\n\n    def visit_Import(self, node: ast.Import) -> Any:  # type: ignore[override]\n        for alias in node.names:\n            asname = alias.asname or alias.name.split(\".\")[-1]\n            self.imports[asname] = alias.name\n            self.import_modules.append(alias.name.split(\".\")[0])\n        self.generic_visit(node)\n\n    def visit_ImportFrom(self, node: ast.ImportFrom) -> Any:  # type: ignore[override]\n        # Resolve relative imports: from .x import y\n        if node.level and node.module:\n            base = self.module.split(\".\")\n            up = max(0, int(node.level))\n            prefix = base[:-up] if up > 0 else base\n            mod = \".\".join([p for p in prefix if p] + [node.module])\n        elif node.level and not node.module:\n            base = self.module.split(\".\")\n            up = max(0, int(node.level))\n            mod = \".\".join(base[:-up])\n        else:\n            mod = node.module or \"\"\n        for alias in node.names:\n            # star import\n            if getattr(alias, \"name\", \"\") == \"*\":\n                if mod:\n                    self.star_imports.append(mod)\n                continue","source_hash":"e28a996e3c22e28318f33e970701e56c53d2becd271f9615a0269e11078879c6","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.code_graph.visit_ImportFrom","uri":"program://TOLBERT/function/scripts.code_graph.visit_ImportFrom#L991-L1014","kind":"function","name":"visit_ImportFrom","path":"scripts/code_graph.py","language":"python","start_line":991,"end_line":1014,"context_start_line":971,"context_end_line":1034,"code":"        self.star_imports: List[str] = []\n        self.exports: List[str] = []\n\n    def _cur_qualname(self) -> str:\n        return \".\".join(self.stack)\n\n    def _cur_class(self) -> Optional[str]:\n        return self.class_stack[-1] if self.class_stack else None\n\n    def _fqn(self, name: str) -> str:\n        q = self._cur_qualname()\n        return f\"{self.module}.{q + ('.' if q else '')}{name}\"\n\n    def visit_Import(self, node: ast.Import) -> Any:  # type: ignore[override]\n        for alias in node.names:\n            asname = alias.asname or alias.name.split(\".\")[-1]\n            self.imports[asname] = alias.name\n            self.import_modules.append(alias.name.split(\".\")[0])\n        self.generic_visit(node)\n\n    def visit_ImportFrom(self, node: ast.ImportFrom) -> Any:  # type: ignore[override]\n        # Resolve relative imports: from .x import y\n        if node.level and node.module:\n            base = self.module.split(\".\")\n            up = max(0, int(node.level))\n            prefix = base[:-up] if up > 0 else base\n            mod = \".\".join([p for p in prefix if p] + [node.module])\n        elif node.level and not node.module:\n            base = self.module.split(\".\")\n            up = max(0, int(node.level))\n            mod = \".\".join(base[:-up])\n        else:\n            mod = node.module or \"\"\n        for alias in node.names:\n            # star import\n            if getattr(alias, \"name\", \"\") == \"*\":\n                if mod:\n                    self.star_imports.append(mod)\n                continue\n            asname = alias.asname or alias.name\n            self.imports[asname] = f\"{mod}.{alias.name}\" if mod else alias.name\n        if mod:\n            self.import_modules.append(mod.split(\".\")[0])\n        self.generic_visit(node)\n\n    def visit_ClassDef(self, node: ast.ClassDef) -> Any:  # type: ignore[override]\n        fqn = self._fqn(node.name)\n        try:\n            doc_s = ast.get_docstring(node) or None\n        except Exception:\n            doc_s = None\n        sym = Symbol(\n            fqn=fqn,\n            name=node.name,\n            qualname=self._cur_qualname(),\n            kind=\"class\",\n            module=self.module,\n            file=self.path,\n            line=getattr(node, \"lineno\", 1),\n            end_line=getattr(node, \"end_lineno\", getattr(node, \"lineno\", 1)),\n            doc=doc_s,\n        )\n        self.symbols.append(sym)\n        self.stack.append(node.name)","source_hash":"e28a996e3c22e28318f33e970701e56c53d2becd271f9615a0269e11078879c6","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.code_graph.visit_ClassDef","uri":"program://TOLBERT/function/scripts.code_graph.visit_ClassDef#L1016-L1038","kind":"function","name":"visit_ClassDef","path":"scripts/code_graph.py","language":"python","start_line":1016,"end_line":1038,"context_start_line":996,"context_end_line":1058,"code":"            prefix = base[:-up] if up > 0 else base\n            mod = \".\".join([p for p in prefix if p] + [node.module])\n        elif node.level and not node.module:\n            base = self.module.split(\".\")\n            up = max(0, int(node.level))\n            mod = \".\".join(base[:-up])\n        else:\n            mod = node.module or \"\"\n        for alias in node.names:\n            # star import\n            if getattr(alias, \"name\", \"\") == \"*\":\n                if mod:\n                    self.star_imports.append(mod)\n                continue\n            asname = alias.asname or alias.name\n            self.imports[asname] = f\"{mod}.{alias.name}\" if mod else alias.name\n        if mod:\n            self.import_modules.append(mod.split(\".\")[0])\n        self.generic_visit(node)\n\n    def visit_ClassDef(self, node: ast.ClassDef) -> Any:  # type: ignore[override]\n        fqn = self._fqn(node.name)\n        try:\n            doc_s = ast.get_docstring(node) or None\n        except Exception:\n            doc_s = None\n        sym = Symbol(\n            fqn=fqn,\n            name=node.name,\n            qualname=self._cur_qualname(),\n            kind=\"class\",\n            module=self.module,\n            file=self.path,\n            line=getattr(node, \"lineno\", 1),\n            end_line=getattr(node, \"end_lineno\", getattr(node, \"lineno\", 1)),\n            doc=doc_s,\n        )\n        self.symbols.append(sym)\n        self.stack.append(node.name)\n        self.class_stack.append(node.name)\n        self.generic_visit(node)\n        self.class_stack.pop()\n        self.stack.pop()\n\n    def visit_FunctionDef(self, node: ast.FunctionDef) -> Any:  # type: ignore[override]\n        self._visit_func_like(node)\n\n    def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef) -> Any:  # type: ignore[override]\n        self._visit_func_like(node)\n\n    def _visit_func_like(self, node: Any) -> None:\n        fqn = self._fqn(node.name)\n        # Signature & returns\n        sig_s, ret_s = None, None\n        try:\n            params = []\n            for a in getattr(node, \"args\", None).args or []:\n                nm = getattr(a, \"arg\", \"\")\n                ann = getattr(a, \"annotation\", None)\n                params.append(f\"{nm}:{ast.unparse(ann)}\" if ann is not None else nm)\n            ret = getattr(node, \"returns\", None)\n            ret_s = ast.unparse(ret) if ret is not None else None\n            sig_s = f\"({', '.join(params)})\"","source_hash":"e28a996e3c22e28318f33e970701e56c53d2becd271f9615a0269e11078879c6","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.code_graph.visit_FunctionDef","uri":"program://TOLBERT/function/scripts.code_graph.visit_FunctionDef#L1040-L1041","kind":"function","name":"visit_FunctionDef","path":"scripts/code_graph.py","language":"python","start_line":1040,"end_line":1041,"context_start_line":1020,"context_end_line":1061,"code":"        except Exception:\n            doc_s = None\n        sym = Symbol(\n            fqn=fqn,\n            name=node.name,\n            qualname=self._cur_qualname(),\n            kind=\"class\",\n            module=self.module,\n            file=self.path,\n            line=getattr(node, \"lineno\", 1),\n            end_line=getattr(node, \"end_lineno\", getattr(node, \"lineno\", 1)),\n            doc=doc_s,\n        )\n        self.symbols.append(sym)\n        self.stack.append(node.name)\n        self.class_stack.append(node.name)\n        self.generic_visit(node)\n        self.class_stack.pop()\n        self.stack.pop()\n\n    def visit_FunctionDef(self, node: ast.FunctionDef) -> Any:  # type: ignore[override]\n        self._visit_func_like(node)\n\n    def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef) -> Any:  # type: ignore[override]\n        self._visit_func_like(node)\n\n    def _visit_func_like(self, node: Any) -> None:\n        fqn = self._fqn(node.name)\n        # Signature & returns\n        sig_s, ret_s = None, None\n        try:\n            params = []\n            for a in getattr(node, \"args\", None).args or []:\n                nm = getattr(a, \"arg\", \"\")\n                ann = getattr(a, \"annotation\", None)\n                params.append(f\"{nm}:{ast.unparse(ann)}\" if ann is not None else nm)\n            ret = getattr(node, \"returns\", None)\n            ret_s = ast.unparse(ret) if ret is not None else None\n            sig_s = f\"({', '.join(params)})\"\n        except Exception:\n            sig_s, ret_s = None, None\n        try:","source_hash":"e28a996e3c22e28318f33e970701e56c53d2becd271f9615a0269e11078879c6","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.code_graph.visit_AsyncFunctionDef","uri":"program://TOLBERT/function/scripts.code_graph.visit_AsyncFunctionDef#L1043-L1044","kind":"function","name":"visit_AsyncFunctionDef","path":"scripts/code_graph.py","language":"python","start_line":1043,"end_line":1044,"context_start_line":1023,"context_end_line":1064,"code":"            fqn=fqn,\n            name=node.name,\n            qualname=self._cur_qualname(),\n            kind=\"class\",\n            module=self.module,\n            file=self.path,\n            line=getattr(node, \"lineno\", 1),\n            end_line=getattr(node, \"end_lineno\", getattr(node, \"lineno\", 1)),\n            doc=doc_s,\n        )\n        self.symbols.append(sym)\n        self.stack.append(node.name)\n        self.class_stack.append(node.name)\n        self.generic_visit(node)\n        self.class_stack.pop()\n        self.stack.pop()\n\n    def visit_FunctionDef(self, node: ast.FunctionDef) -> Any:  # type: ignore[override]\n        self._visit_func_like(node)\n\n    def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef) -> Any:  # type: ignore[override]\n        self._visit_func_like(node)\n\n    def _visit_func_like(self, node: Any) -> None:\n        fqn = self._fqn(node.name)\n        # Signature & returns\n        sig_s, ret_s = None, None\n        try:\n            params = []\n            for a in getattr(node, \"args\", None).args or []:\n                nm = getattr(a, \"arg\", \"\")\n                ann = getattr(a, \"annotation\", None)\n                params.append(f\"{nm}:{ast.unparse(ann)}\" if ann is not None else nm)\n            ret = getattr(node, \"returns\", None)\n            ret_s = ast.unparse(ret) if ret is not None else None\n            sig_s = f\"({', '.join(params)})\"\n        except Exception:\n            sig_s, ret_s = None, None\n        try:\n            doc_s = ast.get_docstring(node) or None\n        except Exception:\n            doc_s = None","source_hash":"e28a996e3c22e28318f33e970701e56c53d2becd271f9615a0269e11078879c6","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.code_graph._visit_func_like","uri":"program://TOLBERT/function/scripts.code_graph._visit_func_like#L1046-L1091","kind":"function","name":"_visit_func_like","path":"scripts/code_graph.py","language":"python","start_line":1046,"end_line":1091,"context_start_line":1026,"context_end_line":1111,"code":"            kind=\"class\",\n            module=self.module,\n            file=self.path,\n            line=getattr(node, \"lineno\", 1),\n            end_line=getattr(node, \"end_lineno\", getattr(node, \"lineno\", 1)),\n            doc=doc_s,\n        )\n        self.symbols.append(sym)\n        self.stack.append(node.name)\n        self.class_stack.append(node.name)\n        self.generic_visit(node)\n        self.class_stack.pop()\n        self.stack.pop()\n\n    def visit_FunctionDef(self, node: ast.FunctionDef) -> Any:  # type: ignore[override]\n        self._visit_func_like(node)\n\n    def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef) -> Any:  # type: ignore[override]\n        self._visit_func_like(node)\n\n    def _visit_func_like(self, node: Any) -> None:\n        fqn = self._fqn(node.name)\n        # Signature & returns\n        sig_s, ret_s = None, None\n        try:\n            params = []\n            for a in getattr(node, \"args\", None).args or []:\n                nm = getattr(a, \"arg\", \"\")\n                ann = getattr(a, \"annotation\", None)\n                params.append(f\"{nm}:{ast.unparse(ann)}\" if ann is not None else nm)\n            ret = getattr(node, \"returns\", None)\n            ret_s = ast.unparse(ret) if ret is not None else None\n            sig_s = f\"({', '.join(params)})\"\n        except Exception:\n            sig_s, ret_s = None, None\n        try:\n            doc_s = ast.get_docstring(node) or None\n        except Exception:\n            doc_s = None\n        sym = Symbol(\n            fqn=fqn,\n            name=node.name,\n            qualname=self._cur_qualname(),\n            kind=\"function\",\n            module=self.module,\n            file=self.path,\n            line=getattr(node, \"lineno\", 1),\n            end_line=getattr(node, \"end_lineno\", getattr(node, \"lineno\", 1)),\n            doc=doc_s,\n            signature=sig_s,\n            returns=ret_s,\n        )\n        self.symbols.append(sym)\n        self.stack.append(node.name)\n        # Traverse body to collect calls\n        for sub in ast.walk(node):\n            if isinstance(sub, ast.Call):\n                callee_key = self._extract_callee_key(sub.func)\n                if callee_key:\n                    self.calls.append((fqn, callee_key))\n        # Decorators as calls\n        for dec in getattr(node, \"decorator_list\", []) or []:\n            callee_key = self._extract_callee_key(dec)\n            if callee_key:\n                self.calls.append((fqn, callee_key))\n        self.stack.pop()\n\n    def visit_Assign(self, node: ast.Assign) -> Any:  # type: ignore[override]\n        for t in getattr(node, \"targets\", []) or []:\n            if isinstance(t, ast.Name):\n                fqn = self._fqn(t.id)\n                sym = Symbol(\n                    fqn=fqn,\n                    name=t.id,\n                    qualname=self._cur_qualname(),\n                    kind=\"variable\",\n                    module=self.module,\n                    file=self.path,\n                    line=getattr(node, \"lineno\", 1),\n                    end_line=getattr(node, \"end_lineno\", getattr(node, \"lineno\", 1)),\n                )\n                self.symbols.append(sym)\n        # capture __all__ = [\"...\"]\n        try:\n            names = []\n            is_all = any(","source_hash":"e28a996e3c22e28318f33e970701e56c53d2becd271f9615a0269e11078879c6","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.code_graph.visit_Assign","uri":"program://TOLBERT/function/scripts.code_graph.visit_Assign#L1093-L1122","kind":"function","name":"visit_Assign","path":"scripts/code_graph.py","language":"python","start_line":1093,"end_line":1122,"context_start_line":1073,"context_end_line":1142,"code":"            end_line=getattr(node, \"end_lineno\", getattr(node, \"lineno\", 1)),\n            doc=doc_s,\n            signature=sig_s,\n            returns=ret_s,\n        )\n        self.symbols.append(sym)\n        self.stack.append(node.name)\n        # Traverse body to collect calls\n        for sub in ast.walk(node):\n            if isinstance(sub, ast.Call):\n                callee_key = self._extract_callee_key(sub.func)\n                if callee_key:\n                    self.calls.append((fqn, callee_key))\n        # Decorators as calls\n        for dec in getattr(node, \"decorator_list\", []) or []:\n            callee_key = self._extract_callee_key(dec)\n            if callee_key:\n                self.calls.append((fqn, callee_key))\n        self.stack.pop()\n\n    def visit_Assign(self, node: ast.Assign) -> Any:  # type: ignore[override]\n        for t in getattr(node, \"targets\", []) or []:\n            if isinstance(t, ast.Name):\n                fqn = self._fqn(t.id)\n                sym = Symbol(\n                    fqn=fqn,\n                    name=t.id,\n                    qualname=self._cur_qualname(),\n                    kind=\"variable\",\n                    module=self.module,\n                    file=self.path,\n                    line=getattr(node, \"lineno\", 1),\n                    end_line=getattr(node, \"end_lineno\", getattr(node, \"lineno\", 1)),\n                )\n                self.symbols.append(sym)\n        # capture __all__ = [\"...\"]\n        try:\n            names = []\n            is_all = any(\n                (isinstance(t, ast.Name) and t.id == \"__all__\") for t in node.targets\n            )\n            if is_all and isinstance(node.value, (ast.List, ast.Tuple)):\n                for el in node.value.elts:\n                    if isinstance(el, ast.Constant) and isinstance(el.value, str):\n                        names.append(el.value)\n            if names:\n                self.exports.extend(names)\n        except Exception:\n            pass\n        self.generic_visit(node)\n\n    def _extract_callee_key(self, fn: ast.AST) -> Optional[str]:\n        # simple name\n        if isinstance(fn, ast.Name):\n            return fn.id\n\n        # super().method()\n        if (\n            isinstance(fn, ast.Attribute)\n            and isinstance(fn.value, ast.Call)\n            and isinstance(fn.value.func, ast.Name)\n            and fn.value.func.id == \"super\"\n        ):\n            meth = fn.attr\n            cur_cls = self._cur_class()\n            if cur_cls:\n                return f\"{self.module}.{cur_cls}.{meth}\"\n            return meth\n\n        # obj.attr chain","source_hash":"e28a996e3c22e28318f33e970701e56c53d2becd271f9615a0269e11078879c6","truncated":false}
{"repo_id":"TOLBERT","entity_id":"py:scripts.code_graph._extract_callee_key","uri":"program://TOLBERT/function/scripts.code_graph._extract_callee_key#L1124-L1193","kind":"function","name":"_extract_callee_key","path":"scripts/code_graph.py","language":"python","start_line":1124,"end_line":1193,"context_start_line":1104,"context_end_line":1197,"code":"                    line=getattr(node, \"lineno\", 1),\n                    end_line=getattr(node, \"end_lineno\", getattr(node, \"lineno\", 1)),\n                )\n                self.symbols.append(sym)\n        # capture __all__ = [\"...\"]\n        try:\n            names = []\n            is_all = any(\n                (isinstance(t, ast.Name) and t.id == \"__all__\") for t in node.targets\n            )\n            if is_all and isinstance(node.value, (ast.List, ast.Tuple)):\n                for el in node.value.elts:\n                    if isinstance(el, ast.Constant) and isinstance(el.value, str):\n                        names.append(el.value)\n            if names:\n                self.exports.extend(names)\n        except Exception:\n            pass\n        self.generic_visit(node)\n\n    def _extract_callee_key(self, fn: ast.AST) -> Optional[str]:\n        # simple name\n        if isinstance(fn, ast.Name):\n            return fn.id\n\n        # super().method()\n        if (\n            isinstance(fn, ast.Attribute)\n            and isinstance(fn.value, ast.Call)\n            and isinstance(fn.value.func, ast.Name)\n            and fn.value.func.id == \"super\"\n        ):\n            meth = fn.attr\n            cur_cls = self._cur_class()\n            if cur_cls:\n                return f\"{self.module}.{cur_cls}.{meth}\"\n            return meth\n\n        # obj.attr chain\n        if isinstance(fn, ast.Attribute):\n            parts: List[str] = []\n            cur = fn\n            while isinstance(cur, ast.Attribute):\n                parts.append(cur.attr)\n                cur = cur.value\n            parts.reverse()\n\n            if isinstance(cur, ast.Name):\n                base = cur.id\n                if base in (\"self\", \"cls\"):\n                    cur_cls = self._cur_class()\n                    if cur_cls and parts:\n                        return f\"{self.module}.{cur_cls}.{parts[-1]}\"\n                    return f\"{self.module}.{cur_cls}\" if cur_cls else parts[-1]\n                if base in self.imports:\n                    return f\"{base}:{parts[-1]}\" if parts else base\n                return f\"{self.module}.{base}.{parts[-1]}\" if parts else base\n        # getattr(module, \"name\") heuristic\n        if (\n            isinstance(fn, ast.Call)\n            and isinstance(fn.func, ast.Name)\n            and fn.func.id == \"getattr\"\n            and fn.args\n            and len(fn.args) >= 2\n            and isinstance(fn.args[0], ast.Name)\n            and isinstance(fn.args[1], ast.Constant)\n            and isinstance(fn.args[1].value, str)\n        ):\n            base = fn.args[0].id\n            name = fn.args[1].value\n            if base in self.imports:\n                return f\"{self.imports[base]}.{name}\"\n            cur_cls = self._cur_class()\n            if base in (\"self\", \"cls\") and cur_cls:\n                return f\"{self.module}.{cur_cls}.{name}\"\n            return f\"{self.module}.{base}.{name}\"\n        # importlib.import_module(\"pkg.mod\") heuristic\n        if (\n            isinstance(fn, ast.Call)\n            and isinstance(fn.func, ast.Attribute)\n            and isinstance(fn.func.value, ast.Name)\n            and fn.func.value.id == \"importlib\"\n            and fn.func.attr == \"import_module\"\n            and fn.args\n            and isinstance(fn.args[0], ast.Constant)\n            and isinstance(fn.args[0].value, str)\n        ):\n            mod = str(fn.args[0].value)\n            return mod\n        return None\n\n\nif __name__ == \"__main__\":\n    _cli()","source_hash":"e28a996e3c22e28318f33e970701e56c53d2becd271f9615a0269e11078879c6","truncated":false}
{"repo_id":"TOLBERT","entity_id":"file:tests/test_modeling.py","uri":"program://TOLBERT/file/tests/test_modeling.py","kind":"file","name":"tests/test_modeling.py","path":"tests/test_modeling.py","language":"python","start_line":1,"end_line":1,"context_start_line":1,"context_end_line":21,"code":"import types\nfrom pathlib import Path\nimport sys\n\nimport torch\n\n# Ensure project root is on sys.path so `tolbert` imports resolve consistently,\n# even when tests are run from outside the repository root.\nPROJECT_ROOT = Path(__file__).resolve().parents[1]\nif str(PROJECT_ROOT) not in sys.path:\n    sys.path.insert(0, str(PROJECT_ROOT))\n\nfrom tolbert import modeling\n\n\nclass _DummyEncoder(torch.nn.Module):\n    \"\"\"\n    Tiny stand-in for a HuggingFace AutoModel encoder.\n\n    It exposes:\n      - .config.hidden_size","source_hash":"a23659190b4c9b73cf53e1dad8c490be6e3133c7094f04b2b898046a281ef83c","truncated":false}
{"repo_id":"TOLBERT","entity_id":"file:tests/test_repo_tree_of_life.py","uri":"program://TOLBERT/file/tests/test_repo_tree_of_life.py","kind":"file","name":"tests/test_repo_tree_of_life.py","path":"tests/test_repo_tree_of_life.py","language":"python","start_line":1,"end_line":1,"context_start_line":1,"context_end_line":21,"code":"from pathlib import Path\nimport sys\nfrom typing import List\n\nimport torch\n\n# Ensure project root is on sys.path so we import the local `scripts` package.\nPROJECT_ROOT = Path(__file__).resolve().parents[1]\nif str(PROJECT_ROOT) not in sys.path:\n    sys.path.insert(0, str(PROJECT_ROOT))\n\nfrom scripts import build_repo_tree_of_life\n\n\nclass _DummySpan:\n    def __init__(self, start_line: int, end_line: int) -> None:\n        self.start_line = start_line\n        self.end_line = end_line\n\n\nclass _DummyEntity:","source_hash":"c0b4a5aed10439fc6d91251766383af3c831dd9d5f42151a506f8cc9344cbde9","truncated":false}
{"repo_id":"TOLBERT","entity_id":"file:tests/test_data_and_metrics.py","uri":"program://TOLBERT/file/tests/test_data_and_metrics.py","kind":"file","name":"tests/test_data_and_metrics.py","path":"tests/test_data_and_metrics.py","language":"python","start_line":1,"end_line":1,"context_start_line":1,"context_end_line":21,"code":"import json\nfrom pathlib import Path\nimport sys\n\nimport torch\n\n# Ensure project root is on sys.path so local `tolbert` and `scripts` packages\n# are importable regardless of the working directory.\nPROJECT_ROOT = Path(__file__).resolve().parents[1]\nif str(PROJECT_ROOT) not in sys.path:\n    sys.path.insert(0, str(PROJECT_ROOT))\n\nfrom tolbert.data import TreeOfLifeDataset, collate_tree_of_life_batch\nfrom scripts import eval_retrieval\n\n\ndef test_tree_of_life_dataset_and_collate_single_path(tmp_path: Path):\n    \"\"\"\n    Verify that TreeOfLifeDataset:\n      - reads node_path into per-level targets,\n      - produces paths suitable for contrastive / path losses,","source_hash":"569916a895377791b1ccb6b8d8f47469f70691ac8b88df7997708184227c5915","truncated":false}
{"repo_id":"TOLBERT","entity_id":"file:tests/test_builders.py","uri":"program://TOLBERT/file/tests/test_builders.py","kind":"file","name":"tests/test_builders.py","path":"tests/test_builders.py","language":"python","start_line":1,"end_line":1,"context_start_line":1,"context_end_line":21,"code":"import csv\nimport json\nfrom pathlib import Path\nimport sys\nfrom typing import Dict\n\n# Ensure project root is on sys.path so we import the local `scripts` package\n# instead of any third-party package named `scripts`.\nPROJECT_ROOT = Path(__file__).resolve().parents[1]\nif str(PROJECT_ROOT) not in sys.path:\n    sys.path.insert(0, str(PROJECT_ROOT))\n\nfrom scripts import (\n    build_wos_spans,\n    build_researchhierarchy_spans,\n    build_codehierarchy_spans,\n    build_joint_code_paper_tol,\n)\n\n\ndef test_build_wos_spans_helpers(tmp_path: Path):","source_hash":"e54370468bc4cb2c6f68bf01d13939be270b9fbc84b4bb8e4b6b0cc0d67ddfc4","truncated":false}
{"repo_id":"TOLBERT","entity_id":"file:tests/test_losses_and_decoding.py","uri":"program://TOLBERT/file/tests/test_losses_and_decoding.py","kind":"file","name":"tests/test_losses_and_decoding.py","path":"tests/test_losses_and_decoding.py","language":"python","start_line":1,"end_line":1,"context_start_line":1,"context_end_line":21,"code":"import torch\nfrom pathlib import Path\nimport sys\n\n# Ensure project root is on sys.path so `tolbert` imports resolve consistently.\nPROJECT_ROOT = Path(__file__).resolve().parents[1]\nif str(PROJECT_ROOT) not in sys.path:\n    sys.path.insert(0, str(PROJECT_ROOT))\n\nfrom tolbert import losses\nfrom tolbert import decoding\n\n\ndef test_tree_contrastive_loss_zero_when_no_shared_ancestors():\n    \"\"\"\n    If no pairs share any non-root ancestor, the contrastive loss should be 0.\n    \"\"\"\n    emb = torch.randn(3, 8)\n    # All paths differ immediately after root.\n    paths = [\n        [0, 1],","source_hash":"8e425f43a898b67c4ce378a22847e7602bf39402d30194c89309b62c2fa08b98","truncated":false}
{"repo_id":"TOLBERT","entity_id":"file:tolbert/config.py","uri":"program://TOLBERT/file/tolbert/config.py","kind":"file","name":"tolbert/config.py","path":"tolbert/config.py","language":"python","start_line":1,"end_line":1,"context_start_line":1,"context_end_line":21,"code":"import json\nfrom pathlib import Path\nfrom typing import Any, Dict\n\n\ndef load_tolbert_config(path: str) -> Dict[str, Any]:\n    \"\"\"\n    Load a simple YAML or JSON config file into a Python dict.\n\n    - If the extension is .yaml or .yml, this function requires PyYAML.\n    - If the extension is .json, it uses the standard library.\n    \"\"\"\n    cfg_path = Path(path)\n    if not cfg_path.exists():\n        raise FileNotFoundError(f\"Config file not found: {cfg_path}\")\n\n    suffix = cfg_path.suffix.lower()\n    if suffix in {\".yaml\", \".yml\"}:\n        try:\n            import yaml  # type: ignore\n        except ImportError as e:","source_hash":"271ccda44a2d59d42fe6674d5025f484744a0e709742fd432dbca6d5c97b0a8f","truncated":false}
{"repo_id":"TOLBERT","entity_id":"file:tolbert/modeling.py","uri":"program://TOLBERT/file/tolbert/modeling.py","kind":"file","name":"tolbert/modeling.py","path":"tolbert/modeling.py","language":"python","start_line":1,"end_line":1,"context_start_line":1,"context_end_line":21,"code":"from dataclasses import dataclass\nfrom typing import Any, Dict, Optional, Sequence\n\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nfrom transformers import AutoModel\n\n\n@dataclass\nclass TOLBERTConfig:\n    \"\"\"\n    Minimal configuration for the TOLBERT encoder.\n    \n    This mirrors the sketch in `docs/api_reference.md` and is intended\n    to be extended with any additional hyperparameters you need.\n    \"\"\"\n\n    base_model_name: str\n    level_sizes: Dict[int, int]\n    proj_dim: int = 256","source_hash":"3db428a7a0c04a6a556bf9b462e69ac73b5cb342a3bbfb42bd0e80200cd4a34c","truncated":false}
{"repo_id":"TOLBERT","entity_id":"file:tolbert/losses.py","uri":"program://TOLBERT/file/tolbert/losses.py","kind":"file","name":"tolbert/losses.py","path":"tolbert/losses.py","language":"python","start_line":1,"end_line":1,"context_start_line":1,"context_end_line":21,"code":"from typing import List, Sequence\n\nimport torch\n\n\ndef _compute_shared_depth(pi: Sequence[int], pj: Sequence[int]) -> int:\n    \"\"\"\n    Depth of deepest shared label beyond the root.\n\n    We treat index 0 in the path as the root. The shared depth is the\n    number of consecutive matching labels starting from index 1.\n    \"\"\"\n    max_len = min(len(pi), len(pj))\n    depth = 0\n    # Start from index 1 to skip the root.\n    for idx in range(1, max_len):\n        if pi[idx] != pj[idx]:\n            break\n        depth += 1\n    return depth\n","source_hash":"d175336f15064e20ce4160ea8a4d2a797755a44065422ad6d71b9d8443355825","truncated":false}
{"repo_id":"TOLBERT","entity_id":"file:tolbert/__init__.py","uri":"program://TOLBERT/file/tolbert/__init__.py","kind":"file","name":"tolbert/__init__.py","path":"tolbert/__init__.py","language":"python","start_line":1,"end_line":1,"context_start_line":1,"context_end_line":15,"code":"\"\"\"\nMinimal TOLBERT package skeleton.\n\nThis module exposes the core configuration and model classes so that\nexamples in `docs/usage.md` and `docs/api_reference.md` can import them.\n\nThe implementations here are intentionally lightweight and are meant\nto be extended as you wire in real data and training code.\n\"\"\"\n\nfrom .modeling import TOLBERT, TOLBERTConfig\n\n__all__ = [\"TOLBERT\", \"TOLBERTConfig\"]\n\n","source_hash":"4571c26544c06ea60e6e431fb71c5f900127e33f70e0e9e8f5ea6de93de0224f","truncated":false}
{"repo_id":"TOLBERT","entity_id":"file:tolbert/data.py","uri":"program://TOLBERT/file/tolbert/data.py","kind":"file","name":"tolbert/data.py","path":"tolbert/data.py","language":"python","start_line":1,"end_line":1,"context_start_line":1,"context_end_line":21,"code":"from __future__ import annotations\n\nimport json\nfrom dataclasses import dataclass\nfrom typing import Dict, List, Optional, Any\n\nimport torch\nfrom torch.utils.data import Dataset\nfrom transformers import PreTrainedTokenizerBase\n\n\n@dataclass\nclass SpanRecord:\n    text: str\n    # Canonical single path used for per-level classification targets.\n    node_path: Optional[List[int]]\n    # Full raw record, which may include richer DAG-style fields such as\n    # `node_paths` (multiple valid paths) in addition to `node_path`.\n    raw: Dict[str, Any]\n\n","source_hash":"e1b347cb34f4a22a8a9bcc3759f305f97da1daf4cfd19b35ca34c618ee3cdf03","truncated":false}
{"repo_id":"TOLBERT","entity_id":"file:tolbert/decoding.py","uri":"program://TOLBERT/file/tolbert/decoding.py","kind":"file","name":"tolbert/decoding.py","path":"tolbert/decoding.py","language":"python","start_line":1,"end_line":1,"context_start_line":1,"context_end_line":21,"code":"from __future__ import annotations\n\nfrom typing import Dict, List, Optional, Sequence\n\nimport torch\n\n\ndef greedy_hierarchical_decode(\n    level_logits: Dict[str, torch.Tensor],\n    parent_to_children: Dict[int, Dict[int, List[int]]],\n    levels: Optional[Sequence[int]] = None,\n) -> Dict[int, torch.Tensor]:\n    \"\"\"\n    Greedy top-down decoding of a hierarchical path with child masking.\n\n    This helper mirrors the inference-time procedure described in the TOLBERT\n    paper: for each level, predictions are restricted to children of the\n    previously chosen parent whenever a parent->children mapping is provided.\n\n    Args:\n        level_logits:","source_hash":"2e77feda6009f2bea3c643ddd160f59ef48d6b0d72c51cace59fcdb8d57e3aee","truncated":false}
{"repo_id":"TOLBERT","entity_id":"file:modules/program_graph.py","uri":"program://TOLBERT/file/modules/program_graph.py","kind":"file","name":"modules/program_graph.py","path":"modules/program_graph.py","language":"python","start_line":1,"end_line":1,"context_start_line":1,"context_end_line":21,"code":"from __future__ import annotations\n\nfrom dataclasses import dataclass, field\nfrom typing import Any, Dict, Iterable, List, Optional, Tuple\n\n\n# Basic identifiers\nEntityId = str\n\n\n@dataclass(frozen=True)\nclass Span:\n    \"\"\"Inclusive 1-based line span within an artifact.\"\"\"\n\n    start_line: int\n    end_line: int\n\n\n@dataclass\nclass Artifact:\n    \"\"\"","source_hash":"f32dd991ecbf9067178a3703b1be0d4601f339d20349172993dd1ae4f9bfc3c3","truncated":false}
{"repo_id":"TOLBERT","entity_id":"file:scripts/preprocess_pdfs.py","uri":"program://TOLBERT/file/scripts/preprocess_pdfs.py","kind":"file","name":"scripts/preprocess_pdfs.py","path":"scripts/preprocess_pdfs.py","language":"python","start_line":1,"end_line":1,"context_start_line":1,"context_end_line":21,"code":"\"\"\"\nLightweight PDF preprocessing script.\n\nReads PDFs from /arxiv/pdfs/{year}/, extracts structured tokens via P0's tokenizer,\nand writes JSONL chunks (section/equation/figure/table/text) under exports/pdfs_structured/.\n\nUsage:\n  # Specific year range (inclusive)\n  PYTHONPATH=.. python -m models.scripts.preprocess_pdfs --years 2018 2020 --max-files 1000\n\n  # All years and all files (may be large)\n  PYTHONPATH=.. python -m models.scripts.preprocess_pdfs --max-files 0\n\n  # Use a VLM (e.g., Qwen/Qwen3-VL-2B-Instruct) for OCR\n  PYTHONPATH=.. python -m models.scripts.preprocess_pdfs --max-files 0 --qwen-model Qwen/Qwen3-VL-2B-Instruct\n\nSupports resumable runs: existing shards in the output directory are scanned and\ntheir pdf_path entries are skipped, so re-running continues where it left off.\n\"\"\"\n\nimport argparse","source_hash":"30f8438c60ae79d09a7c944ac558823c35963546eba2b8f7196a782700099acf","truncated":false}
{"repo_id":"TOLBERT","entity_id":"file:scripts/eval_zero_shot_cross_domain.py","uri":"program://TOLBERT/file/scripts/eval_zero_shot_cross_domain.py","kind":"file","name":"scripts/eval_zero_shot_cross_domain.py","path":"scripts/eval_zero_shot_cross_domain.py","language":"python","start_line":1,"end_line":1,"context_start_line":1,"context_end_line":21,"code":"\"\"\"\nSimple cross-domain zero-shot evaluation script for TOLBERT.\n\nThis wraps the hierarchical classification evaluator to support the scenario:\n\n  - Train TOLBERT on domain A (e.g., CodeHierarchy).\n  - Evaluate the same checkpoint on domain B (e.g., WOS) without further training.\n\nUsage:\n\n  # Evaluate a code-trained model on WOS spans\n  python -m scripts.eval_zero_shot_cross_domain \\\\\n      --config configs/codehierarchy_example.yaml \\\\\n      --checkpoint checkpoints/codehierarchy/tolbert_epoch5.pt \\\\\n      --target-config configs/wos_example.yaml \\\\\n      --target-spans data/wos/spans_test.jsonl\n\nThe script uses:\n  - base_model_name and model head structure from the *source* config\n    (the one used for training),\n  - but evaluation data and tokenizer settings (e.g., max_length) from","source_hash":"e767fb5692f2c8cac3cf173bd350576b6c0101eb0626d929114add875d33f237","truncated":false}
{"repo_id":"TOLBERT","entity_id":"file:scripts/build_wos_spans.py","uri":"program://TOLBERT/file/scripts/build_wos_spans.py","kind":"file","name":"scripts/build_wos_spans.py","path":"scripts/build_wos_spans.py","language":"python","start_line":1,"end_line":1,"context_start_line":1,"context_end_line":21,"code":"\"\"\"\nBuild JSONL spans and ontology metadata for a WOS-style hierarchical text dataset.\n\nThis script is a reference implementation of the ResearchHierarchy construction\ndescribed in the TOLBERT paper. It does **not** ship any WOS data; instead, it\nexpects you to provide a CSV file with one row per document and three levels of\nlabels.\n\nExpected input CSV schema (you can adapt this to your variant as needed):\n\n    text_col:   column containing the text to encode (e.g., abstract)\n    l1_col:     top-level field (e.g., \"Computer Science\")\n    l2_col:     second-level subfield\n    l3_col:     third-level discipline\n\nBy default we assume:\n\n    --text-col text\n    --l1-col   level1\n    --l2-col   level2\n    --l3-col   level3","source_hash":"ddb099315e7bc0048643832ced2f4eaea51afb31ff4bc31f66aeec55ff96ef67","truncated":false}
{"repo_id":"TOLBERT","entity_id":"file:scripts/codegraph_core.py","uri":"program://TOLBERT/file/scripts/codegraph_core.py","kind":"file","name":"scripts/codegraph_core.py","path":"scripts/codegraph_core.py","language":"python","start_line":1,"end_line":1,"context_start_line":1,"context_end_line":21,"code":"from __future__ import annotations\n\nimport os\nimport ast\nimport hashlib\nfrom dataclasses import dataclass\nfrom typing import Dict, List, Optional, Tuple, Iterable, Set\n\n\n@dataclass(frozen=True)\nclass FileSpan:\n    file: str           # absolute path\n    start_line: int     # 1-based inclusive\n    end_line: int       # 1-based inclusive\n\n\n@dataclass\nclass CGEntity:\n    id: str             # stable id (e.g., fqn)\n    kind: str           # module|function|class|test\n    name: str","source_hash":"27d2c9fbe4b62cf66c684b76a8ffba2ba3dad061314037a111259361fe252990","truncated":false}
{"repo_id":"TOLBERT","entity_id":"file:scripts/build_researchhierarchy_spans.py","uri":"program://TOLBERT/file/scripts/build_researchhierarchy_spans.py","kind":"file","name":"scripts/build_researchhierarchy_spans.py","path":"scripts/build_researchhierarchy_spans.py","language":"python","start_line":1,"end_line":1,"context_start_line":1,"context_end_line":21,"code":"\"\"\"\nBuild ResearchHierarchy-style JSONL spans and simple ontology metadata for WOS / arXiv papers.\n\nThis is a reference implementation of the dataset construction described for the\nResearchHierarchy benchmark in the TOLBERT paper. It expects you to provide a local\nmetadata file that assigns each paper to a 3-level research taxonomy and (optionally)\nits backing PDF path.\n\nThe script is intentionally lightweight and mirrors the structure of\n`build_codehierarchy_spans.py`:\n\nInput\n=====\n- --metadata_file:\n    A CSV or JSONL file with, at minimum, the columns:\n      doc_id, field, subfield, discipline, text\n\n    Optionally it may also include:\n      pdf_path: absolute or repo-relative path to the PDF for this paper\n      source:  short tag like \"wos\" or \"arxiv\" identifying the corpus\n","source_hash":"9ba1f42b48662e1a4b26b9554e0b2f038c6dc115b440b175902ef3386791150a","truncated":false}
{"repo_id":"TOLBERT","entity_id":"file:scripts/agent_pr_paper_recommender.py","uri":"program://TOLBERT/file/scripts/agent_pr_paper_recommender.py","kind":"file","name":"scripts/agent_pr_paper_recommender.py","path":"scripts/agent_pr_paper_recommender.py","language":"python","start_line":1,"end_line":1,"context_start_line":1,"context_end_line":21,"code":"\"\"\"\nAgent / LLM stack skeleton: PR -> paper recommendations via TOLBERT.\n\nThis script is a high-level wiring of the \"worked scenario\" from `docs/usage.md`:\n  1. Ingest a pull request (PR) as text spans.\n  2. Encode spans with TOLBERT.\n  3. Locate the PR within the Tree-of-Life (domain/subdomain).\n  4. Retrieve relevant paper spans from a pre-built index.\n  5. Use an LLM to summarize / explain the recommendations.\n\nYou are expected to plug in:\n  - real PR ingestion,\n  - a proper paper-span index (vector DB, search service, etc.),\n  - and your own LLM backend in `call_llm`.\n\"\"\"\n\nimport argparse\nfrom pathlib import Path\nfrom typing import Any, Dict, List, Tuple\n\nimport torch","source_hash":"24db8874e1fff25f28fb857720c13e8c262d8c4f888ea8c39fabeae3aba6ef3f","truncated":false}
{"repo_id":"TOLBERT","entity_id":"file:scripts/build_joint_code_paper_tol.py","uri":"program://TOLBERT/file/scripts/build_joint_code_paper_tol.py","kind":"file","name":"scripts/build_joint_code_paper_tol.py","path":"scripts/build_joint_code_paper_tol.py","language":"python","start_line":1,"end_line":1,"context_start_line":1,"context_end_line":21,"code":"\"\"\"\nBuild a joint code+paper Tree-of-Life (ToL) from existing per-domain spans.\n\nThis script is the missing glue described in the paper/docs: it takes\nseparate code and paper span files (each with its own local ontology and\n`node_path` ids) and produces:\n\n- A single, unified `nodes.jsonl` Tree-of-Life with:\n    level 0: root\n    level 1: domain nodes (e.g., \"Code\", \"Papers\")\n    level 2+: remapped nodes from the original per-domain ontologies\n- Rewritten span files for code and papers where `node_path` has been\n  updated to refer to the *joint* node ID space.\n- A `level_sizes` JSON helper compatible with `TOLBERTConfig.level_sizes`.\n\nDesign notes\n============\n\nThis script deliberately **does not attempt to infer a semantic mapping**\nbetween code categories (e.g., \"Web\", \"ML\", \"Systems\") and paper fields\n(\"Computer Science\", \"Physics\", ...). Doing that well would require","source_hash":"6380e9c6adcc8b9f8253da0127930805dfd0f32ba8a4783de34a83eca5bfb7c1","truncated":false}
{"repo_id":"TOLBERT","entity_id":"file:scripts/eval_flat_baseline.py","uri":"program://TOLBERT/file/scripts/eval_flat_baseline.py","kind":"file","name":"scripts/eval_flat_baseline.py","path":"scripts/eval_flat_baseline.py","language":"python","start_line":1,"end_line":1,"context_start_line":1,"context_end_line":21,"code":"\"\"\"\nEvaluate a flat (leaf-level) baseline classifier on a labeled spans_file.\n\nThis computes standard leaf-level accuracy for the \"BERT-flat\" style baselines\ntrained with scripts/train_flat_baseline.py. It does NOT reconstruct full\nhierarchical paths; it simply evaluates how well the model predicts the leaf\nnode id (last element of node_path).\n\nExample:\n\n  python -m scripts.eval_flat_baseline \\\\\n      --config configs/codehierarchy_example.yaml \\\\\n      --checkpoint-dir checkpoints/codehierarchy_bert_flat \\\\\n      --spans-file /data/tolbert/data/codehierarchy/spans_test.jsonl\n\"\"\"\n\nfrom __future__ import annotations\n\nimport argparse\nimport json\nfrom pathlib import Path","source_hash":"dc5374f19c16a413028a1321089704a4edd39c70fe6acf08a697c6dfcb7d9ffb","truncated":false}
{"repo_id":"TOLBERT","entity_id":"file:scripts/train_tolbert.py","uri":"program://TOLBERT/file/scripts/train_tolbert.py","kind":"file","name":"scripts/train_tolbert.py","path":"scripts/train_tolbert.py","language":"python","start_line":1,"end_line":1,"context_start_line":1,"context_end_line":21,"code":"\"\"\"\nMinimal training skeleton for TOLBERT **with curriculum and multi-domain support**.\n\nThis script wires together:\n  - config loading\n  - tokenizer + dataset(s)\n  - model + optimizer\n  - a training loop with optional curriculum over hierarchical / path / contrastive losses\n\nIt assumes you have prepared one or more `spans_file`(s) as described in `docs/tree_of_life.md`.\n\"\"\"\n\nimport argparse\nfrom pathlib import Path\nfrom typing import Any, Dict, Optional\n\nimport torch\nfrom torch.utils.data import DataLoader, ConcatDataset\nfrom transformers import AutoTokenizer\nimport os\n","source_hash":"a3d153b42c9ecbc9731d749ebc6c9ef6775be090e4d1a5f0b71bc6b157cea378","truncated":false}
{"repo_id":"TOLBERT","entity_id":"file:scripts/repo_graph.py","uri":"program://TOLBERT/file/scripts/repo_graph.py","kind":"file","name":"scripts/repo_graph.py","path":"scripts/repo_graph.py","language":"python","start_line":1,"end_line":1,"context_start_line":1,"context_end_line":21,"code":"from __future__ import annotations\n\nimport os\nimport re\nimport hashlib\nfrom typing import Iterable, List, Tuple, Dict, Optional, Set, Any\n\nfrom modules.program_graph import ProgramGraph, Entity, Edge, Artifact, Span, ResolvedAnchor, EntityId\n\n\ndef program_id_for_repo(repo_root: str) -> str:\n    base = os.path.basename(os.path.abspath(repo_root)) or \"repo\"\n    return base\n\n\ndef artifact_uri(program_id: str, rel_path: str) -> str:\n    rel = rel_path.replace(\"\\\\\", \"/\").lstrip(\"/\")\n    return f\"program://{program_id}/artifact/{rel}\"\n\n\ndef parse_program_uri(uri: str) -> Tuple[str, str, str, Optional[Tuple[int, int]]]:","source_hash":"cbc0aa5dcdb8bd7bf8e739e35d1190516934c4d470257d2017a31f88c0b7f173","truncated":false}
{"repo_id":"TOLBERT","entity_id":"file:scripts/eval_hierarchical_classification.py","uri":"program://TOLBERT/file/scripts/eval_hierarchical_classification.py","kind":"file","name":"scripts/eval_hierarchical_classification.py","path":"scripts/eval_hierarchical_classification.py","language":"python","start_line":1,"end_line":1,"context_start_line":1,"context_end_line":21,"code":"\"\"\"\nEvaluate a trained TOLBERT checkpoint on a labeled spans_file.\n\nThis script implements the hierarchical classification metrics discussed\nin the TOLBERT paper:\n\n  - per-level accuracy\n  - per-level micro F1 (for single-label multiclass this equals accuracy)\n  - path accuracy (all supervised levels correct for a span)\n\nUsage (CodeHierarchy example):\n\n  python -m scripts.eval_hierarchical_classification \\\\\n      --config configs/codehierarchy_example.yaml \\\\\n      --checkpoint checkpoints/codehierarchy/tolbert_epoch5.pt \\\\\n      --spans-file data/codehierarchy/spans_test.jsonl\n\"\"\"\n\nfrom __future__ import annotations\n\nimport argparse","source_hash":"acb23c51c73bcda18fef8093cea458f7e7c239b33c9544dfb7e51fa2e0aae41f","truncated":false}
{"repo_id":"TOLBERT","entity_id":"file:scripts/build_repo_tree_of_life.py","uri":"program://TOLBERT/file/scripts/build_repo_tree_of_life.py","kind":"file","name":"scripts/build_repo_tree_of_life.py","path":"scripts/build_repo_tree_of_life.py","language":"python","start_line":1,"end_line":1,"context_start_line":1,"context_end_line":21,"code":"\"\"\"\nBuild a simple Tree-of-Life taxonomy and span records from a single repository\nusing the language-agnostic RepoGraph.\n\nThis is a concrete, graph-driven implementation of the code-side part of\n`docs/tree_of_life.md`:\n\n  - Nodes:\n      level 0: root\n      level 1: language nodes (Python, Java, C/C++, Go, JS/TS, ...)\n      level 2: repo node\n      level 3: top-level directory nodes (subtrees within the repo)\n      level 4: file nodes\n      level 5: symbol nodes (functions / methods / classes), when available\n\n  - Edges:\n      parent_id / child_id edges forming a tree over the above nodes.\n\n  - Spans:\n      one span per file, with a node_path from root → language → repo →\n      top-level directory → file.","source_hash":"b673708c0bd5ff3dd51161d80a8765539b0df20bd24126c18bc79efc8f1e18a8","truncated":false}
{"repo_id":"TOLBERT","entity_id":"file:scripts/build_codehierarchy_spans.py","uri":"program://TOLBERT/file/scripts/build_codehierarchy_spans.py","kind":"file","name":"scripts/build_codehierarchy_spans.py","path":"scripts/build_codehierarchy_spans.py","language":"python","start_line":1,"end_line":1,"context_start_line":1,"context_end_line":21,"code":"\"\"\"\nBuild CodeHierarchy-style JSONL spans and simple ontology metadata.\n\nThis is a *reference* implementation of the dataset construction described\nin the TOLBERT paper for the CodeHierarchy benchmark. It does not fetch or\nship any GitHub data; instead, it expects you to point it at a directory of\nlocal repositories plus a small metadata file that assigns each repo to a\nlanguage and coarse category.\n\nInput:\n  - --repos_root:\n      Directory that contains one subdirectory per repository, e.g.\n        repos_root/\n          repo1/\n            ...\n          repo2/\n            ...\n  - --metadata_file:\n      A CSV or JSONL file with, at minimum, the fields:\n        repo_name, language, category\n      where:","source_hash":"822e0397f322d201e0770f48c87c652ef9c45741ca9b6bea2e680752d11b73dc","truncated":false}
{"repo_id":"TOLBERT","entity_id":"file:scripts/build_arxiv_cls_spans.py","uri":"program://TOLBERT/file/scripts/build_arxiv_cls_spans.py","kind":"file","name":"scripts/build_arxiv_cls_spans.py","path":"scripts/build_arxiv_cls_spans.py","language":"python","start_line":1,"end_line":1,"context_start_line":1,"context_end_line":21,"code":"\"\"\"\nBuild ArXiv-CLS–style JSONL spans and simple ontology metadata.\n\nThis script is a small helper for the ArXiv-CLS variant described in the\nTOLBERT paper. It mirrors the style of `build_wos_spans.py` / `build_codehierarchy_spans.py`,\nbut targets the 2-level arXiv category hierarchy.\n\nThe ArXiv-CLS setup in the paper uses:\n\n  - Documents: recent arXiv CS papers (e.g., title + abstract text).\n  - Labels: a two-level arXiv category taxonomy, e.g.:\n        domain  = \"cs\"\n        category = \"cs.LG\"\n\nYou are expected to provide a metadata file (CSV or JSONL) with at least:\n\n  - doc_id:   unique paper identifier (e.g., arXiv ID)\n  - domain:   top-level arXiv area (e.g., \"cs\", \"math\")\n  - category: fine-grained arXiv category (e.g., \"cs.LG\", \"cs.CL\")\n  - text:     text span to encode (e.g., title + abstract)\n","source_hash":"eef2318b47079f127398f996d922b9fd8f45972facc8ba3737540e1cc84ee77d","truncated":false}
{"repo_id":"TOLBERT","entity_id":"file:scripts/eval_retrieval.py","uri":"program://TOLBERT/file/scripts/eval_retrieval.py","kind":"file","name":"scripts/eval_retrieval.py","path":"scripts/eval_retrieval.py","language":"python","start_line":1,"end_line":1,"context_start_line":1,"context_end_line":21,"code":"\"\"\"\nEvaluate embeddings on retrieval-style tasks.\n\nThis script computes:\n  - MRR (Mean Reciprocal Rank)\n  - Precision@K\n\nfor a simple setup where:\n  - The index consists of spans from one spans_file (e.g., code files).\n  - The queries are spans from another spans_file (e.g., paper abstracts).\n  - \"Relevance\" is defined by sharing one or more levels in the hierarchy.\n\nBy default we use \"share at least level 2\" as the relevance criterion, but\nthis can be adjusted via flags.\n\nUsage (Paper2Code-style example):\n\n  python -m scripts.eval_retrieval \\\\\n      --config configs/codehierarchy_example.yaml \\\\\n      --checkpoint checkpoints/tolbert_epoch5.pt \\\\\n      --index-spans data/codehierarchy/spans_code.jsonl \\\\","source_hash":"0618a8d31a4435c8ec1cfe19fb3dee05f16a905b73db22e3a3ea623292149c00","truncated":false}
{"repo_id":"TOLBERT","entity_id":"file:scripts/__init__.py","uri":"program://TOLBERT/file/scripts/__init__.py","kind":"file","name":"scripts/__init__.py","path":"scripts/__init__.py","language":"python","start_line":1,"end_line":1,"context_start_line":1,"context_end_line":9,"code":"\"\"\"\nLocal scripts package for TOLBERT utilities (dataset builders, training, eval).\n\nThis file exists so that tests and external tools can reliably import modules\nlike `scripts.build_wos_spans` without accidentally resolving to any unrelated\nthird-party `scripts` package on the Python path.\n\"\"\"\n\n","source_hash":"6bf856745d23d7c7c8aeb2ad603ba7472071ba00d449202e4bc95526de85a415","truncated":false}
{"repo_id":"TOLBERT","entity_id":"file:scripts/train_flat_baseline.py","uri":"program://TOLBERT/file/scripts/train_flat_baseline.py","kind":"file","name":"scripts/train_flat_baseline.py","path":"scripts/train_flat_baseline.py","language":"python","start_line":1,"end_line":1,"context_start_line":1,"context_end_line":21,"code":"\"\"\"\nTrain a flat (leaf-level) baseline classifier on spans_file.\n\nThis script is intended to reproduce the \"BERT-flat\" style baselines from\nSection 4 using standard HuggingFace models (e.g. BERT, SciBERT, CodeBERT,\nModernBERT) on the same JSONL spans files used for TOLBERT.\n\nKey characteristics:\n  - Single-label, flat classification on the *leaf* node of each path\n    (last element of `node_path`).\n  - Uses AutoModelForSequenceClassification with a single softmax head.\n  - Ignores intermediate hierarchy levels entirely.\n\nExample (CodeHierarchy, BERT-base flat):\n\n  python -m scripts.train_flat_baseline \\\\\n      --config configs/codehierarchy_example.yaml \\\\\n      --output-dir checkpoints/codehierarchy_bert_flat \\\\\n      --base-model-name bert-base-uncased\n\nExample (WOS, SciBERT flat):","source_hash":"d6f993cb8736e408b149d004ed642cf41238027e2fdfa82112b52974dee32112","truncated":false}
{"repo_id":"TOLBERT","entity_id":"file:scripts/retrieval_sandbox.py","uri":"program://TOLBERT/file/scripts/retrieval_sandbox.py","kind":"file","name":"scripts/retrieval_sandbox.py","path":"scripts/retrieval_sandbox.py","language":"python","start_line":1,"end_line":1,"context_start_line":1,"context_end_line":21,"code":"\"\"\"\nSimple retrieval sandbox for TOLBERT.\n\nThis script:\n  - loads a trained TOLBERT checkpoint and tokenizer,\n  - encodes spans from a `spans_file`,\n  - builds an in-memory index of embeddings,\n  - lets you run ad-hoc queries over that index from the command line.\n\nIt is intended for small-scale experimentation and debugging, not production.\n\"\"\"\n\nimport argparse\nfrom pathlib import Path\nfrom typing import Any, Dict, List, Tuple\n\nimport torch\nfrom torch.nn import functional as F\nfrom transformers import AutoTokenizer\nimport os\n","source_hash":"45d7644b52ea2f46e0a00c129acd5d4c49a097e3ab56203649d3976759b35261","truncated":false}
{"repo_id":"TOLBERT","entity_id":"file:scripts/code_graph.py","uri":"program://TOLBERT/file/scripts/code_graph.py","kind":"file","name":"scripts/code_graph.py","path":"scripts/code_graph.py","language":"python","start_line":1,"end_line":1,"context_start_line":1,"context_end_line":21,"code":"import os\nimport ast\nimport re\nimport json\nimport time  # noqa: F401\nfrom dataclasses import dataclass, field\nfrom typing import Any, Dict, List, Tuple, Optional\ntry:\n    import pathspec  # type: ignore\nexcept Exception:  # pragma: no cover\n    pathspec = None  # type: ignore\n\n\n@dataclass\nclass Symbol:\n    fqn: str\n    name: str\n    qualname: str\n    kind: str  # module|class|function|variable\n    module: str\n    file: str","source_hash":"e28a996e3c22e28318f33e970701e56c53d2becd271f9615a0269e11078879c6","truncated":false}