SYMBOL INDEX (1231 symbols across 128 files)

FILE: run_alphafold.py
  function make_model_config (line 381) | def make_model_config(
  class ModelRunner (line 401) | class ModelRunner:
    method __init__ (line 404) | def __init__(
    method model_params (line 415) | def model_params(self) -> hk.Params:
    method _model (line 420) | def _model(
    method run_inference (line 433) | def run_inference(
    method extract_inference_results (line 455) | def extract_inference_results(
    method extract_embeddings (line 468) | def extract_embeddings(
    method extract_distogram (line 483) | def extract_distogram(
  class ResultsForSeed (line 494) | class ResultsForSeed:
  function predict_structure (line 513) | def predict_structure(
  function write_fold_input_json (line 588) | def write_fold_input_json(
  function write_outputs (line 600) | def write_outputs(
  function replace_db_dir (line 670) | def replace_db_dir(path_with_db_dir: str, db_dirs: Sequence[str]) -> str:
  function process_fold_input (line 691) | def process_fold_input(
  function process_fold_input (line 708) | def process_fold_input(
  function process_fold_input (line 724) | def process_fold_input(
  function main (line 832) | def main(_):

FILE: run_alphafold_data_test.py
  function _output (line 49) | def _output(name: str):
  function _hash_data (line 55) | def _hash_data(x: Any, /) -> str:
  function _ (line 62) | def _(x: bytes, /) -> str:
  function _ (line 67) | def _(x: jax.Array) -> str:
  function _ (line 72) | def _(x: np.ndarray) -> str:
  function _ (line 79) | def _(_: structure.Structure) -> str:
  function _ (line 84) | def _(_: atom_layout.AtomLayout) -> str:
  function _generate_diff (line 88) | def _generate_diff(actual: str, expected: str) -> str:
  class DataPipelineTest (line 100) | class DataPipelineTest(parameterized.TestCase):
    method setUp (line 103) | def setUp(self):
    method compare_golden (line 180) | def compare_golden(self, result_path: str) -> None:
    method test_config (line 194) | def test_config(self):
    method test_featurisation (line 203) | def test_featurisation(self):
    method test_write_input_json (line 226) | def test_write_input_json(self):
    method test_process_fold_input_runs_only_data_pipeline (line 238) | def test_process_fold_input_runs_only_data_pipeline(self):
    method test_replace_db_dir (line 256) | def test_replace_db_dir(self, num_db_dirs: int) -> None:

FILE: run_alphafold_test.py
  function _output (line 46) | def _output(name: str):
  function _generate_diff (line 54) | def _generate_diff(actual: str, expected: str) -> str:
  class InferenceTest (line 66) | class InferenceTest(parameterized.TestCase):
    method setUp (line 69) | def setUp(self):
    method test_model_inference (line 156) | def test_model_inference(self):
    method test_process_fold_input_runs_only_inference (line 177) | def test_process_fold_input_runs_only_inference(self):
    method test_inference (line 200) | def test_inference(self, bucket, seed):

FILE: src/alphafold3/build_data.py
  function build_data (line 23) | def build_data():

FILE: src/alphafold3/common/base_config.py
  function _strip_optional (line 25) | def _strip_optional(t: type[Any]) -> type[Any]:
  class _Autocreate (line 37) | class _Autocreate:
    method __init__ (line 39) | def __init__(self, **defaults: Any):
  function autocreate (line 43) | def autocreate(**defaults: Any) -> Any:
  function _clone_field (line 48) | def _clone_field(
  class ConfigMeta (line 65) | class ConfigMeta(type):
    method __new__ (line 68) | def __new__(mcs, name, bases, classdict):
  class BaseConfig (line 128) | class BaseConfig(metaclass=ConfigMeta):
    method _coercable_fields (line 140) | def _coercable_fields(self) -> Mapping[str, tuple[type['BaseConfig'], ...
    method as_dict (line 143) | def as_dict(self) -> Mapping[str, Any]:

FILE: src/alphafold3/common/folding_input.py
  function _validate_keys (line 46) | def _validate_keys(actual: Collection[str], expected: Collection[str]):
  function _read_file (line 52) | def _read_file(path: pathlib.Path, json_path: pathlib.Path | None) -> str:
  class Template (line 86) | class Template:
    method __init__ (line 91) | def __init__(self, *, mmcif: str, query_to_template_map: Mapping[int, ...
    method query_to_template_map (line 105) | def query_to_template_map(self) -> Mapping[int, int]:
    method mmcif (line 109) | def mmcif(self) -> str:
    method __hash__ (line 112) | def __hash__(self) -> int:
    method __eq__ (line 115) | def __eq__(self, other: Self) -> bool:
  class ProteinChain (line 123) | class ProteinChain:
    method __init__ (line 136) | def __init__(
    method id (line 187) | def id(self) -> str:
    method sequence (line 191) | def sequence(self) -> str:
    method ptms (line 202) | def ptms(self) -> Sequence[tuple[str, int]]:
    method description (line 206) | def description(self) -> str | None:
    method paired_msa (line 210) | def paired_msa(self) -> str | None:
    method unpaired_msa (line 214) | def unpaired_msa(self) -> str | None:
    method templates (line 218) | def templates(self) -> Sequence[Template] | None:
    method __len__ (line 221) | def __len__(self) -> int:
    method __eq__ (line 224) | def __eq__(self, other: Self) -> bool:
    method __hash__ (line 235) | def __hash__(self) -> int:
    method hash_without_id (line 246) | def hash_without_id(self) -> int:
    method from_alphafoldserver_dict (line 258) | def from_alphafoldserver_dict(
    method from_dict (line 298) | def from_dict(
    method to_dict (line 389) | def to_dict(
    method to_ccd_sequence (line 420) | def to_ccd_sequence(self) -> Sequence[str]:
    method fill_missing_fields (line 430) | def fill_missing_fields(self) -> Self:
  class RnaChain (line 443) | class RnaChain:
    method __init__ (line 454) | def __init__(
    method id (line 494) | def id(self) -> str:
    method sequence (line 498) | def sequence(self) -> str:
    method modifications (line 509) | def modifications(self) -> Sequence[tuple[str, int]]:
    method description (line 513) | def description(self) -> str | None:
    method unpaired_msa (line 517) | def unpaired_msa(self) -> str | None:
    method __len__ (line 520) | def __len__(self) -> int:
    method __eq__ (line 523) | def __eq__(self, other: Self) -> bool:
    method __hash__ (line 532) | def __hash__(self) -> int:
    method hash_without_id (line 541) | def hash_without_id(self) -> int:
    method from_alphafoldserver_dict (line 551) | def from_alphafoldserver_dict(
    method from_dict (line 564) | def from_dict(
    method to_dict (line 612) | def to_dict(
    method to_ccd_sequence (line 629) | def to_ccd_sequence(self) -> Sequence[str]:
    method fill_missing_fields (line 639) | def fill_missing_fields(self) -> Self:
  class DnaChain (line 649) | class DnaChain:
    method __init__ (line 654) | def __init__(
    method id (line 687) | def id(self) -> str:
    method sequence (line 691) | def sequence(self) -> str:
    method description (line 702) | def description(self) -> str | None:
    method __len__ (line 705) | def __len__(self) -> int:
    method __eq__ (line 708) | def __eq__(self, other: Self) -> bool:
    method __hash__ (line 716) | def __hash__(self) -> int:
    method modifications (line 721) | def modifications(self) -> Sequence[tuple[str, int]]:
    method hash_without_id (line 724) | def hash_without_id(self) -> int:
    method from_alphafoldserver_dict (line 729) | def from_alphafoldserver_dict(
    method from_dict (line 742) | def from_dict(
    method to_dict (line 762) | def to_dict(
    method to_ccd_sequence (line 778) | def to_ccd_sequence(self) -> Sequence[str]:
  class Ligand (line 790) | class Ligand:
    method __post_init__ (line 809) | def __post_init__(self):
    method __len__ (line 822) | def __len__(self) -> int:
    method hash_without_id (line 828) | def hash_without_id(self) -> int:
    method from_alphafoldserver_dict (line 833) | def from_alphafoldserver_dict(
    method from_dict (line 847) | def from_dict(
    method to_dict (line 882) | def to_dict(
  function _sample_rng_seed (line 896) | def _sample_rng_seed() -> int:
  function _validate_user_ccd_keys (line 902) | def _validate_user_ccd_keys(keys: Sequence[str], component_name: str) ->...
  class Input (line 932) | class Input:
    method __post_init__ (line 961) | def __post_init__(self):
    method protein_chains (line 992) | def protein_chains(self) -> Sequence[ProteinChain]:
    method rna_chains (line 996) | def rna_chains(self) -> Sequence[RnaChain]:
    method dna_chains (line 1000) | def dna_chains(self) -> Sequence[DnaChain]:
    method ligands (line 1004) | def ligands(self) -> Sequence[Ligand]:
    method sanitised_name (line 1007) | def sanitised_name(self) -> str:
    method from_alphafoldserver_fold_job (line 1014) | def from_alphafoldserver_fold_job(cls, fold_job: Mapping[str, Any]) ->...
    method from_json (line 1103) | def from_json(
    method from_mmcif (line 1254) | def from_mmcif(cls, mmcif_str: str, ccd: chemical_components.Ccd) -> S...
    method to_structure (line 1365) | def to_structure(self, ccd: chemical_components.Ccd) -> structure.Stru...
    method to_json (line 1436) | def to_json(self) -> str:
    method fill_missing_fields (line 1471) | def fill_missing_fields(self) -> Self:
    method with_multiple_seeds (line 1481) | def with_multiple_seeds(self, num_seeds: int) -> Self:
  function load_fold_inputs_from_path (line 1494) | def load_fold_inputs_from_path(json_path: pathlib.Path) -> Iterator[Input]:
  function load_fold_inputs_from_dir (line 1523) | def load_fold_inputs_from_dir(input_dir: pathlib.Path) -> Iterator[Input]:

FILE: src/alphafold3/common/resources.py
  function filename (line 29) | def filename(name: str | os.PathLike[str]) -> str:
  function open_resource (line 44) | def open_resource(
  function open_resource (line 51) | def open_resource(
  function open_resource (line 57) | def open_resource(
  function get_resource_dir (line 70) | def get_resource_dir(path: str | os.PathLike[str]) -> os.PathLike[str]:
  function walk (line 74) | def walk(path: str) -> Iterator[tuple[str, list[str], list[str]]]:

FILE: src/alphafold3/common/safe_pickle.py
  class _RestrictedUnpickler (line 42) | class _RestrictedUnpickler(pickle.Unpickler):
    method find_class (line 45) | def find_class(self, module: str, name: str) -> Any:
  function load (line 52) | def load(file_obj: BinaryIO) -> Any:

FILE: src/alphafold3/common/testing/data.py
  class Data (line 20) | class Data:
    method __init__ (line 23) | def __init__(self, data_dir: os.PathLike[str] | str):
    method path (line 31) | def path(self, data_name: str | os.PathLike[str] | None = None) -> str:
    method load (line 48) | def load(
    method load (line 54) | def load(
    method load (line 59) | def load(

FILE: src/alphafold3/constants/chemical_components.py
  function _load_ccd_pickle_cached (line 29) | def _load_ccd_pickle_cached(
  class Ccd (line 37) | class Ccd(Mapping[str, Mapping[str, Sequence[str]]]):
    method __init__ (line 48) | def __init__(
    method __getitem__ (line 75) | def __getitem__(self, key: str) -> Mapping[str, Sequence[str]]:
    method __contains__ (line 78) | def __contains__(self, key: str) -> bool:
    method __iter__ (line 81) | def __iter__(self) -> Iterator[str]:
    method __len__ (line 84) | def __len__(self) -> int:
    method __hash__ (line 87) | def __hash__(self) -> int:
    method get (line 90) | def get(
    method items (line 95) | def items(self) -> ItemsView[str, Mapping[str, Sequence[str]]]:
    method values (line 98) | def values(self) -> ValuesView[Mapping[str, Sequence[str]]]:
    method keys (line 101) | def keys(self) -> KeysView[str]:
  class ComponentInfo (line 106) | class ComponentInfo:
  function mmcif_to_info (line 117) | def mmcif_to_info(mmcif: Mapping[str, Sequence[str]]) -> ComponentInfo:
  function component_name_to_info (line 172) | def component_name_to_info(ccd: Ccd, res_name: str) -> ComponentInfo | N...
  function type_symbol (line 179) | def type_symbol(ccd: Ccd, res_name: str, atom_name: str) -> str:

FILE: src/alphafold3/constants/converters/ccd_pickle_gen.py
  function main (line 22) | def main(argv: Sequence[str]) -> None:

FILE: src/alphafold3/constants/converters/chemical_component_sets_gen.py
  function find_ions_and_glycans_in_ccd (line 29) | def find_ions_and_glycans_in_ccd(
  function main (line 61) | def main(argv: Sequence[str]) -> None:

FILE: src/alphafold3/constants/mmcif_names.py
  function is_standard_polymer_type (line 118) | def is_standard_polymer_type(chain_type: str) -> bool:
  function guess_polymer_type (line 130) | def guess_polymer_type(chain_residues: Sequence[str]) -> str:
  function fix_non_standard_polymer_res (line 176) | def fix_non_standard_polymer_res(*, res_name: str, chain_type: str) -> str:

FILE: src/alphafold3/constants/periodic_table.py
  class Element (line 21) | class Element:

FILE: src/alphafold3/constants/residue_names.py
  function letters_three_to_one (line 234) | def letters_three_to_one(restype: str, *, default: str) -> str:

FILE: src/alphafold3/cpp.cc
  type alphafold3 (line 25) | namespace alphafold3 {
    function PYBIND11_MODULE (line 29) | PYBIND11_MODULE(cpp, m) {

FILE: src/alphafold3/data/cpp/msa_profile_pybind.cc
  function ComputeMsaProfile (line 22) | py::array_t<double> ComputeMsaProfile(
  type alphafold3 (line 72) | namespace alphafold3 {
    function RegisterModuleMsaProfile (line 74) | void RegisterModuleMsaProfile(pybind11::module m) {

FILE: src/alphafold3/data/cpp/msa_profile_pybind.h
  function namespace (line 16) | namespace alphafold3 {

FILE: src/alphafold3/data/featurisation.py
  function validate_fold_input (line 24) | def validate_fold_input(fold_input: folding_input.Input):
  function featurise_input (line 38) | def featurise_input(

FILE: src/alphafold3/data/msa.py
  class Error (line 28) | class Error(Exception):
  function _featurize (line 32) | def _featurize(seq: str, chain_poly_type: str) -> str | list[int]:
  function sequences_are_feature_equivalent (line 42) | def sequences_are_feature_equivalent(
  class Msa (line 52) | class Msa:
    method __init__ (line 55) | def __init__(
    method from_multiple_msas (line 113) | def from_multiple_msas(
    method from_multiple_a3ms (line 156) | def from_multiple_a3ms(
    method from_a3m (line 199) | def from_a3m(
    method from_empty (line 229) | def from_empty(cls, query_sequence: str, chain_poly_type: str) -> Self:
    method depth (line 240) | def depth(self) -> int:
    method __repr__ (line 243) | def __repr__(self) -> str:
    method to_a3m (line 246) | def to_a3m(self) -> str:
    method featurize (line 254) | def featurize(self) -> MutableMapping[str, np.ndarray]:
  function get_msa_tool (line 287) | def get_msa_tool(
  function get_msa (line 318) | def get_msa(

FILE: src/alphafold3/data/msa_config.py
  function _validate_chain_poly_type (line 19) | def _validate_chain_poly_type(chain_poly_type: str) -> None:
  class DatabaseConfig (line 28) | class DatabaseConfig:
  class JackhmmerConfig (line 36) | class JackhmmerConfig:
  class NhmmerConfig (line 69) | class NhmmerConfig:
  class RunConfig (line 102) | class RunConfig:
    method __post_init__ (line 117) | def __post_init__(self):
  class HmmsearchConfig (line 125) | class HmmsearchConfig:
  class TemplateToolConfig (line 143) | class TemplateToolConfig:
    method __post_init__ (line 151) | def __post_init__(self):
  class TemplateFilterConfig (line 156) | class TemplateFilterConfig:
    method no_op_filter (line 167) | def no_op_filter(cls) -> Self:
  class TemplatesConfig (line 180) | class TemplatesConfig:

FILE: src/alphafold3/data/msa_features.py
  function extract_msa_features (line 71) | def extract_msa_features(
  function extract_species_ids (line 181) | def extract_species_ids(msa_descriptions: Sequence[str]) -> Sequence[str]:

FILE: src/alphafold3/data/msa_identifiers.py
  class Identifiers (line 46) | class Identifiers:
  function _parse_sequence_identifier (line 50) | def _parse_sequence_identifier(msa_sequence_identifier: str) -> Identifi...
  function _extract_sequence_identifier (line 70) | def _extract_sequence_identifier(description: str) -> str | None:
  function get_identifiers (line 79) | def get_identifiers(description: str) -> Identifiers:

FILE: src/alphafold3/data/parsers.py
  function lazy_parse_fasta_string (line 23) | def lazy_parse_fasta_string(fasta_string: str) -> Iterable[tuple[str, st...
  function parse_fasta (line 49) | def parse_fasta(fasta_string: str) -> tuple[Sequence[str], Sequence[str]]:
  function convert_a3m_to_stockholm (line 64) | def convert_a3m_to_stockholm(a3m: str, max_seqs: int | None = None) -> str:
  function convert_stockholm_to_a3m (line 104) | def convert_stockholm_to_a3m(

FILE: src/alphafold3/data/pipeline.py
  function _get_protein_templates (line 30) | def _get_protein_templates(
  function _get_protein_msa_and_templates (line 71) | def _get_protein_msa_and_templates(
  function _get_rna_msa (line 156) | def _get_rna_msa(
  class DataPipelineConfig (line 204) | class DataPipelineConfig:
  class DataPipeline (line 292) | class DataPipeline:
    method __init__ (line 295) | def __init__(self, data_pipeline_config: DataPipelineConfig):
    method process_protein_chain (line 457) | def process_protein_chain(
    method process_rna_chain (line 546) | def process_rna_chain(
    method process (line 576) | def process(self, fold_input: folding_input.Input) -> folding_input.In...

FILE: src/alphafold3/data/structure_stores.py
  class NotFoundError (line 20) | class NotFoundError(KeyError):
  class StructureStore (line 24) | class StructureStore:
    method __init__ (line 27) | def __init__(
    method _tar_members (line 52) | def _tar_members(self) -> Mapping[str, tarfile.TarInfo]:
    method get_mmcif_str (line 61) | def get_mmcif_str(self, target_name: str) -> str:
    method target_names (line 92) | def target_names(self) -> Sequence[str]:

FILE: src/alphafold3/data/template_realign.py
  class AlignmentError (line 16) | class AlignmentError(Exception):
  function realign_hit_to_structure (line 20) | def realign_hit_to_structure(
  function _remap_to_struc_seq (line 107) | def _remap_to_struc_seq(

FILE: src/alphafold3/data/templates.py
  class _Polymer (line 62) | class _Polymer:
  function _encode_restype (line 89) | def _encode_restype(
  class Error (line 145) | class Error(Exception):
  class HitDateError (line 149) | class HitDateError(Error):
  class InvalidTemplateError (line 153) | class InvalidTemplateError(Error):
  class Hit (line 158) | class Hit:
    method query_to_hit_mapping (line 193) | def query_to_hit_mapping(self) -> Mapping[int, int]:
    method matching_sequence (line 241) | def matching_sequence(self) -> str:
    method output_templates_sequence (line 249) | def output_templates_sequence(self) -> str:
    method length_ratio (line 257) | def length_ratio(self) -> float:
    method align_ratio (line 262) | def align_ratio(self) -> float:
    method is_valid (line 267) | def is_valid(self) -> bool:
    method full_name (line 278) | def full_name(self) -> str:
    method __post_init__ (line 282) | def __post_init__(self):
    method keep (line 302) | def keep(
  function _filter_hits (line 362) | def _filter_hits(
  class Templates (line 397) | class Templates:
    method __init__ (line 405) | def __init__(
    method from_seq_and_a3m (line 430) | def from_seq_and_a3m(
    method from_hmmsearch_a3m (line 486) | def from_hmmsearch_a3m(
    method query_sequence (line 573) | def query_sequence(self) -> str:
    method hits (line 577) | def hits(self) -> tuple[Hit, ...]:
    method query_release_date (line 581) | def query_release_date(self) -> datetime.date | None:
    method num_hits (line 585) | def num_hits(self) -> int:
    method release_date_cutoff (line 589) | def release_date_cutoff(self) -> datetime.date:
    method __repr__ (line 598) | def __repr__(self) -> str:
    method filter (line 601) | def filter(
    method get_hits_with_structures (line 644) | def get_hits_with_structures(
    method featurize (line 662) | def featurize(
    method structures (line 721) | def structures(self) -> Iterator[structure.Structure]:
  function _parse_hit_description (line 755) | def _parse_hit_description(description: str) -> tuple[str, str, int, int...
  function _parse_hit_metadata (line 773) | def _parse_hit_metadata(
  function get_polymer_features (line 820) | def get_polymer_features(
  function _get_ligand_features (line 897) | def _get_ligand_features(
  function package_template_features (line 923) | def package_template_features(
  function _resolve_path (line 948) | def _resolve_path(path: os.PathLike[str] | str) -> str:
  function run_hmmsearch_with_a3m (line 959) | def run_hmmsearch_with_a3m(

FILE: src/alphafold3/data/tools/hmmalign.py
  function _to_a3m (line 21) | def _to_a3m(sequences: Sequence[str], name_prefix: str = 'sequence') -> ...
  class Hmmalign (line 28) | class Hmmalign:
    method __init__ (line 31) | def __init__(self, binary_path: str):
    method align_sequences (line 46) | def align_sequences(
    method align (line 59) | def align(
    method align_sequences_to_profile (line 113) | def align_sequences_to_profile(self, profile: str, sequences_a3m: str)...

FILE: src/alphafold3/data/tools/hmmbuild.py
  class Hmmbuild (line 22) | class Hmmbuild(object):
    method __init__ (line 25) | def __init__(
    method build_profile_from_sto (line 52) | def build_profile_from_sto(self, sto: str, model_construction='fast') ...
    method build_profile_from_a3m (line 70) | def build_profile_from_a3m(self, a3m: str) -> str:
    method _build_profile (line 89) | def _build_profile(

FILE: src/alphafold3/data/tools/hmmsearch.py
  class Hmmsearch (line 22) | class Hmmsearch(object):
    method __init__ (line 25) | def __init__(
    method query_with_hmm (line 97) | def query_with_hmm(self, hmm: str) -> str:
    method query_with_a3m (line 134) | def query_with_a3m(self, a3m_in: str) -> str:
    method query_with_sto (line 142) | def query_with_sto(

FILE: src/alphafold3/data/tools/jackhmmer.py
  class Jackhmmer (line 29) | class Jackhmmer(msa_tool.MsaTool):
    method __init__ (line 32) | def __init__(
    method query (line 138) | def query(self, target_sequence: str) -> msa_tool.MsaToolResult:
    method _query_db_shard (line 189) | def _query_db_shard(
  function _merge_jackhmmer_results (line 276) | def _merge_jackhmmer_results(

FILE: src/alphafold3/data/tools/msa_tool.py
  class MsaToolResult (line 18) | class MsaToolResult:
  class MsaTool (line 35) | class MsaTool(Protocol):
    method query (line 38) | def query(self, target_sequence: str) -> MsaToolResult:

FILE: src/alphafold3/data/tools/nhmmer.py
  class Nhmmer (line 35) | class Nhmmer(msa_tool.MsaTool):
    method __init__ (line 38) | def __init__(
    method query (line 139) | def query(self, target_sequence: str) -> msa_tool.MsaToolResult:
    method _query_db_shard (line 191) | def _query_db_shard(
  function _merge_nhmmer_results (line 295) | def _merge_nhmmer_results(

FILE: src/alphafold3/data/tools/rdkit_utils.py
  class MolFromMmcifError (line 42) | class MolFromMmcifError(Exception):
  class UnsupportedMolBondError (line 46) | class UnsupportedMolBondError(Exception):
  function _populate_atoms_in_mol (line 50) | def _populate_atoms_in_mol(
  function _populate_bonds_in_mol (line 104) | def _populate_bonds_in_mol(
  function sanitize_mol (line 131) | def sanitize_mol(mol, sort_alphabetically, remove_hydrogens) -> rd_chem....
  function _add_conformer_to_mol (line 143) | def _add_conformer_to_mol(mol, conformer, force_parse) -> rd_chem.Mol:
  function mol_from_ccd_cif (line 155) | def mol_from_ccd_cif(
  function mol_to_ccd_cif (line 245) | def mol_to_ccd_cif(
  function _format_atom_name (line 350) | def _format_atom_name(atom_name: str, atom_type: str) -> str:
  function parse_atom_data (line 384) | def parse_atom_data(
  function parse_bond_data (line 405) | def parse_bond_data(
  function _parse_ideal_conformer (line 430) | def _parse_ideal_conformer(mol_cif: cif_dict.CifDict) -> rd_chem.Conformer:
  function sort_atoms_by_name (line 460) | def sort_atoms_by_name(mol: rd_chem.Mol) -> rd_chem.Mol:
  function assign_atom_names_from_graph (line 477) | def assign_atom_names_from_graph(
  function get_random_conformer (line 525) | def get_random_conformer(

FILE: src/alphafold3/data/tools/shards.py
  class ShardSpec (line 42) | class ShardSpec:
  function parse_shard_spec (line 48) | def parse_shard_spec(path: str) -> ShardSpec | None:
  function get_sharded_paths (line 77) | def get_sharded_paths(shard_spec: str) -> Sequence[str] | None:

FILE: src/alphafold3/data/tools/subprocess_utils.py
  function create_query_fasta_file (line 22) | def create_query_fasta_file(sequence: str, path: str, linewidth: int = 80):
  function check_binary_exists (line 33) | def check_binary_exists(path: str, name: str) -> None:
  function jackhmmer_seq_limit_supported (line 39) | def jackhmmer_seq_limit_supported(jackhmmer_path: str) -> bool:
  function run (line 53) | def run(

FILE: src/alphafold3/jax/geometry/rigid_matrix_vector.py
  function _compute_covariance_matrix (line 30) | def _compute_covariance_matrix(
  class Rigid3Array (line 100) | class Rigid3Array:
    method __matmul__ (line 106) | def __matmul__(self, other: Self) -> Self:
    method inverse (line 111) | def inverse(self) -> Self:
    method apply_to_point (line 117) | def apply_to_point(self, point: vector.Vec3Array) -> vector.Vec3Array:
    method apply_inverse_to_point (line 121) | def apply_inverse_to_point(self, point: vector.Vec3Array) -> vector.Ve...
    method compose_rotation (line 126) | def compose_rotation(self, other_rotation: rotation_matrix.Rot3Array) ...
    method identity (line 134) | def identity(cls, shape: Any, dtype: jnp.dtype = jnp.float32) -> Self:
    method scale_translation (line 141) | def scale_translation(self, factor: Float) -> Self:
    method to_array (line 145) | def to_array(self):
    method from_array (line 151) | def from_array(cls, array):
    method from_array4x4 (line 157) | def from_array4x4(cls, array: jnp.ndarray) -> Self:
    method from_point_alignment (line 172) | def from_point_alignment(
    method __getstate__ (line 217) | def __getstate__(self):
    method __setstate__ (line 220) | def __setstate__(self, state):

FILE: src/alphafold3/jax/geometry/rotation_matrix.py
  function make_matrix_svd_factors (line 32) | def make_matrix_svd_factors() -> np.ndarray:
  function largest_evec (line 69) | def largest_evec(m):
  function largest_evec_jvp (line 74) | def largest_evec_jvp(primals, tangents):
  class Rot3Array (line 109) | class Rot3Array:
    method inverse (line 124) | def inverse(self) -> Self:
    method apply_to_point (line 132) | def apply_to_point(self, point: vector.Vec3Array) -> vector.Vec3Array:
    method apply_inverse_to_point (line 140) | def apply_inverse_to_point(self, point: vector.Vec3Array) -> vector.Ve...
    method __matmul__ (line 144) | def __matmul__(self, other: Self) -> Self:
    method identity (line 152) | def identity(cls, shape: Any, dtype: jnp.dtype = jnp.float32) -> Self:
    method from_two_vectors (line 159) | def from_two_vectors(cls, e0: vector.Vec3Array, e1: vector.Vec3Array) ...
    method from_array (line 182) | def from_array(cls, array: jnp.ndarray) -> Self:
    method to_array (line 188) | def to_array(self) -> jnp.ndarray:
    method from_quaternion (line 200) | def from_quaternion(
    method from_svd (line 228) | def from_svd(cls, mat: jnp.ndarray, use_quat_formula: bool = True) -> ...
    method random_uniform (line 278) | def random_uniform(cls, key, shape, dtype=jnp.float32) -> Self:
    method __getstate__ (line 284) | def __getstate__(self):
    method __setstate__ (line 287) | def __setstate__(self, state):

FILE: src/alphafold3/jax/geometry/struct_of_array.py
  function get_item (line 18) | def get_item(instance, key):
  function get_shape (line 33) | def get_shape(instance):
  function get_len (line 44) | def get_len(instance):
  function get_dtype (line 54) | def get_dtype(instance):
  function replace (line 79) | def replace(instance, **kwargs):
  function post_init (line 83) | def post_init(instance):
  function flatten (line 134) | def flatten(instance):
  function make_metadata_class (line 150) | def make_metadata_class(cls):
  function get_fields (line 163) | def get_fields(cls_or_instance, filterfn, return_values=False):
  function get_array_fields (line 174) | def get_array_fields(cls, return_values=False):
  function get_metadata_fields (line 182) | def get_metadata_fields(cls, return_values=False):
  class StructOfArray (line 190) | class StructOfArray:
    method __init__ (line 193) | def __init__(self, same_dtype=True):
    method __call__ (line 196) | def __call__(self, cls):

FILE: src/alphafold3/jax/geometry/utils.py
  function unstack (line 19) | def unstack(value: jnp.ndarray, axis: int = -1) -> list[jnp.ndarray]:
  function angdiff (line 26) | def angdiff(alpha: jnp.ndarray, beta: jnp.ndarray) -> jnp.ndarray:
  function weighted_mean (line 33) | def weighted_mean(

FILE: src/alphafold3/jax/geometry/vector.py
  class Vec3Array (line 29) | class Vec3Array:
    method __post_init__ (line 46) | def __post_init__(self):
    method __add__ (line 57) | def __add__(self, other: Self) -> Self:
    method __sub__ (line 60) | def __sub__(self, other: Self) -> Self:
    method __mul__ (line 63) | def __mul__(self, other: Float) -> Self:
    method __rmul__ (line 66) | def __rmul__(self, other: Float) -> Self:
    method __truediv__ (line 69) | def __truediv__(self, other: Float) -> Self:
    method __neg__ (line 72) | def __neg__(self) -> Self:
    method __pos__ (line 75) | def __pos__(self) -> Self:
    method cross (line 78) | def cross(self, other: Self) -> Self:
    method dot (line 85) | def dot(self, other: Self) -> Float:
    method norm (line 89) | def norm(self, epsilon: float = 1e-6) -> Float:
    method norm2 (line 97) | def norm2(self):
    method normalized (line 100) | def normalized(self, epsilon: float = 1e-6) -> Self:
    method zeros (line 105) | def zeros(cls, shape, dtype=jnp.float32):
    method to_array (line 113) | def to_array(self) -> jnp.ndarray:
    method from_array (line 117) | def from_array(cls, array):
    method __getstate__ (line 120) | def __getstate__(self):
    method __setstate__ (line 126) | def __setstate__(self, state):
  function square_euclidean_distance (line 133) | def square_euclidean_distance(
  function dot (line 155) | def dot(vector1: Vec3Array, vector2: Vec3Array) -> Float:
  function cross (line 159) | def cross(vector1: Vec3Array, vector2: Vec3Array) -> Float:
  function norm (line 163) | def norm(vector: Vec3Array, epsilon: float = 1e-6) -> Float:
  function normalized (line 167) | def normalized(vector: Vec3Array, epsilon: float = 1e-6) -> Vec3Array:
  function euclidean_distance (line 171) | def euclidean_distance(
  function dihedral_angle (line 191) | def dihedral_angle(
  function random_gaussian_vector (line 220) | def random_gaussian_vector(shape, key, dtype=jnp.float32) -> Vec3Array:

FILE: src/alphafold3/model/atom_layout/atom_layout.py
  class AtomLayout (line 37) | class AtomLayout:
    method __post_init__ (line 76) | def __post_init__(self):
    method __getitem__ (line 99) | def __getitem__(self, key: NumpyIndex) -> 'AtomLayout':
    method __eq__ (line 113) | def __eq__(self, other: 'AtomLayout') -> bool:
    method copy_and_pad_to (line 138) | def copy_and_pad_to(self, shape: tuple[int, ...]) -> 'AtomLayout':
    method to_array (line 184) | def to_array(self) -> np.ndarray:
    method from_array (line 212) | def from_array(cls, arr: np.ndarray) -> 'AtomLayout':
    method shape (line 231) | def shape(self) -> tuple[int, ...]:
  class Residues (line 236) | class Residues:
    method __post_init__ (line 260) | def __post_init__(self):
    method __getitem__ (line 278) | def __getitem__(self, key: NumpyIndex) -> 'Residues':
    method __eq__ (line 294) | def __eq__(self, other: 'Residues') -> bool:
    method shape (line 301) | def shape(self) -> tuple[int, ...]:
  class GatherInfo (line 306) | class GatherInfo:
    method __post_init__ (line 327) | def __post_init__(self):
    method __getitem__ (line 335) | def __getitem__(self, key: NumpyIndex) -> 'GatherInfo':
    method shape (line 343) | def shape(self) -> tuple[int, ...]:
    method as_np_or_jnp (line 346) | def as_np_or_jnp(self, xnp: types.ModuleType) -> 'GatherInfo':
    method as_dict (line 353) | def as_dict(
    method from_dict (line 365) | def from_dict(
  function fill_in_optional_fields (line 379) | def fill_in_optional_fields(
  function guess_deprotonation (line 428) | def guess_deprotonation(residues: Residues) -> Residues:
  function atom_layout_from_structure (line 455) | def atom_layout_from_structure(
  function residues_from_structure (line 504) | def residues_from_structure(
  function get_link_drop_atoms (line 636) | def get_link_drop_atoms(
  function get_bonded_atoms (line 685) | def get_bonded_atoms(
  function make_flat_atom_layout (line 737) | def make_flat_atom_layout(
  function compute_gather_idxs (line 866) | def compute_gather_idxs(
  function convert (line 906) | def convert(
  function make_structure (line 976) | def make_structure(
  function _assert_all_arrays_have_same_shape (line 1065) | def _assert_all_arrays_have_same_shape(

FILE: src/alphafold3/model/components/haiku_modules.py
  class LayerNorm (line 41) | class LayerNorm(hk.LayerNorm):
    method __init__ (line 53) | def __init__(
    method __call__ (line 82) | def __call__(self, x: jnp.ndarray) -> jnp.ndarray:
  function haiku_linear_get_params (line 115) | def haiku_linear_get_params(
  class Linear (line 188) | class Linear(hk.Module):
    method __init__ (line 199) | def __init__(
    method __call__ (line 244) | def __call__(self, inputs: jnp.ndarray) -> jnp.ndarray:
  function _get_initializer_scale (line 318) | def _get_initializer_scale(initializer_name, input_shape):

FILE: src/alphafold3/model/components/mapping.py
  function _maybe_slice (line 31) | def _maybe_slice(array, i, slice_size, axis):
  function _maybe_get_size (line 40) | def _maybe_get_size(array, axis):
  function _expand_axes (line 47) | def _expand_axes(axes, values, name="sharded_apply"):
  function sharded_map (line 55) | def sharded_map(
  function _set_docstring (line 87) | def _set_docstring(docstr: str) -> Callable[[T], T]:
  function sharded_apply (line 97) | def sharded_apply(
  function inference_subbatch (line 217) | def inference_subbatch(

FILE: src/alphafold3/model/components/utils.py
  function remove_invalidly_typed_feats (line 26) | def remove_invalidly_typed_feats(
  function bfloat16_getter (line 37) | def bfloat16_getter(next_getter, value, context):
  function bfloat16_context (line 46) | def bfloat16_context():
  function mask_mean (line 51) | def mask_mean(mask, value, axis=None, keepdims=False, eps=1e-10):

FILE: src/alphafold3/model/confidence_types.py
  class StructureConfidenceFullEncoder (line 24) | class StructureConfidenceFullEncoder(json.JSONEncoder):
    method __init__ (line 27) | def __init__(self, **kwargs):
    method encode (line 30) | def encode(self, o: 'StructureConfidenceFull'):
  function _dump_json (line 60) | def _dump_json(data: Any, indent: int | None = None) -> str:
  class ConfidenceCategory (line 72) | class ConfidenceCategory(enum.Enum):
    method from_char (line 81) | def from_char(cls, char: str) -> Self:
    method to_char (line 96) | def to_char(self) -> str:
    method from_confidence_score (line 108) | def from_confidence_score(cls, confidence: float) -> Self:
  class AtomConfidence (line 121) | class AtomConfidence:
    method __post_init__ (line 129) | def __post_init__(self):
    method from_inference_result (line 138) | def from_inference_result(
    method from_json (line 167) | def from_json(cls, json_string: str) -> Self:
    method to_json (line 176) | def to_json(self) -> str:
  class StructureConfidenceSummary (line 186) | class StructureConfidenceSummary:
    method from_inference_result (line 212) | def from_inference_result(
    method from_json (line 231) | def from_json(cls, json_string: str) -> Self:
    method to_json (line 235) | def to_json(self) -> str:
  class StructureConfidenceFull (line 249) | class StructureConfidenceFull:
    method from_inference_result (line 260) | def from_inference_result(
    method from_json (line 295) | def from_json(cls, json_string: str) -> Self:
    method to_json (line 299) | def to_json(self) -> str:

FILE: src/alphafold3/model/confidences.py
  function windowed_solvent_accessible_area (line 53) | def windowed_solvent_accessible_area(cif: str, window: int = 25) -> np.n...
  function fraction_disordered (line 90) | def fraction_disordered(
  function has_clash (line 131) | def has_clash(
  function get_ranking_score (line 185) | def get_ranking_score(
  function rank_metric (line 200) | def rank_metric(
  function weighted_mean (line 230) | def weighted_mean(mask, value, axis):
  function pde_single (line 234) | def pde_single(
  function chain_pair_pde (line 290) | def chain_pair_pde(
  function weighted_nanmean (line 324) | def weighted_nanmean(
  function chain_pair_pae (line 346) | def chain_pair_pae(
  function reduce_chain_pair (line 413) | def reduce_chain_pair(
  function pae_metrics (line 476) | def pae_metrics(
  function get_iptm_xchain (line 554) | def get_iptm_xchain(chain_pair_iptm: np.ndarray) -> np.ndarray:
  function predicted_tm_score (line 570) | def predicted_tm_score(
  function chain_pairwise_predicted_tm_scores (line 625) | def chain_pairwise_predicted_tm_scores(

FILE: src/alphafold3/model/data3.py
  function get_profile_features (line 26) | def get_profile_features(
  function fix_template_features (line 41) | def fix_template_features(
  function empty_template_features (line 92) | def empty_template_features(num_res: int) -> FeatureDict:
  function _get_timestamp (line 115) | def _get_timestamp(date_str: str):

FILE: src/alphafold3/model/feat_batch.py
  class Batch (line 20) | class Batch:
    method num_res (line 36) | def num_res(self) -> int:
    method from_data_dict (line 40) | def from_data_dict(cls, batch: features.BatchDict) -> Self:
    method as_data_dict (line 62) | def as_data_dict(self) -> features.BatchDict:

FILE: src/alphafold3/model/features.py
  class PaddingShapes (line 51) | class PaddingShapes:
  function _pad_to (line 59) | def _pad_to(
  function _unwrap (line 95) | def _unwrap(obj):
  class Chains (line 104) | class Chains:
  function _compute_asym_entity_and_sym_id (line 118) | def _compute_asym_entity_and_sym_id(
  function tokenizer (line 163) | def tokenizer(
  class MSA (line 402) | class MSA:
    method compute_features (line 416) | def compute_features(
    method index_msa_rows (line 662) | def index_msa_rows(self, indices: xnp_ndarray) -> Self:
    method from_data_dict (line 675) | def from_data_dict(cls, batch: BatchDict) -> Self:
    method as_data_dict (line 686) | def as_data_dict(self) -> BatchDict:
  class Templates (line 705) | class Templates:
    method compute_features (line 716) | def compute_features(
    method from_data_dict (line 850) | def from_data_dict(cls, batch: BatchDict) -> Self:
    method as_data_dict (line 858) | def as_data_dict(self) -> BatchDict:
  function _reduce_template_features (line 873) | def _reduce_template_features(
  class TokenFeatures (line 892) | class TokenFeatures:
    method compute_features (line 919) | def compute_features(
    method from_data_dict (line 996) | def from_data_dict(cls, batch: BatchDict) -> Self:
    method as_data_dict (line 1014) | def as_data_dict(self) -> BatchDict:
  class PredictedStructureInfo (line 1041) | class PredictedStructureInfo:
    method compute_features (line 1048) | def compute_features(
    method from_data_dict (line 1089) | def from_data_dict(cls, batch: BatchDict) -> Self:
    method as_data_dict (line 1095) | def as_data_dict(self) -> BatchDict:
  class PolymerLigandBondInfo (line 1110) | class PolymerLigandBondInfo:
    method compute_features (line 1119) | def compute_features(
    method from_data_dict (line 1204) | def from_data_dict(cls, batch: BatchDict) -> Self:
    method as_data_dict (line 1214) | def as_data_dict(self) -> BatchDict:
  class LigandLigandBondInfo (line 1233) | class LigandLigandBondInfo:
    method compute_features (line 1239) | def compute_features(
    method from_data_dict (line 1313) | def from_data_dict(cls, batch: BatchDict) -> Self:
    method as_data_dict (line 1320) | def as_data_dict(self) -> BatchDict:
  class PseudoBetaInfo (line 1336) | class PseudoBetaInfo:
    method compute_features (line 1342) | def compute_features(
    method from_data_dict (line 1435) | def from_data_dict(cls, batch: BatchDict) -> Self:
    method as_data_dict (line 1442) | def as_data_dict(self) -> BatchDict:
  function random_rotation (line 1466) | def random_rotation(random_state: np.random.RandomState) -> np.ndarray:
  function random_augmentation (line 1477) | def random_augmentation(
  function _get_reference_positions_from_ccd_cif (line 1492) | def _get_reference_positions_from_ccd_cif(
  function get_reference (line 1531) | def get_reference(
  class RefStructure (line 1658) | class RefStructure:
    method compute_features (line 1675) | def compute_features(
    method from_data_dict (line 1794) | def from_data_dict(cls, batch: BatchDict) -> Self:
    method as_data_dict (line 1804) | def as_data_dict(self) -> BatchDict:
  class ConvertModelOutput (line 1823) | class ConvertModelOutput:
    method compute_features (line 1834) | def compute_features(
    method from_data_dict (line 1860) | def from_data_dict(cls, batch: BatchDict) -> Self:
    method as_data_dict (line 1872) | def as_data_dict(self) -> BatchDict:
  class AtomCrossAtt (line 1891) | class AtomCrossAtt:
    method compute_features (line 1901) | def compute_features(
    method from_data_dict (line 2001) | def from_data_dict(cls, batch: BatchDict) -> Self:
    method as_data_dict (line 2020) | def as_data_dict(self) -> BatchDict:
  class Frames (line 2042) | class Frames:
    method compute_features (line 2048) | def compute_features(
    method from_data_dict (line 2153) | def from_data_dict(cls, batch: BatchDict) -> Self:
    method as_data_dict (line 2156) | def as_data_dict(self) -> BatchDict:

FILE: src/alphafold3/model/merging_features.py
  function _pad_features_to_max (line 33) | def _pad_features_to_max(feat_name: str, chains: list[BatchDict], axis: ...
  function merge_msa_features (line 64) | def merge_msa_features(feat_name: str, chains: list[BatchDict]) -> np.nd...
  function merge_paired_and_unpaired_msa (line 78) | def merge_paired_and_unpaired_msa(example: BatchDict) -> BatchDict:

FILE: src/alphafold3/model/mkdssp_pybind.cc
  type alphafold3 (line 24) | namespace alphafold3 {
    function RegisterModuleMkdssp (line 27) | void RegisterModuleMkdssp(pybind11::module m) {

FILE: src/alphafold3/model/mkdssp_pybind.h
  function namespace (line 17) | namespace alphafold3 {

FILE: src/alphafold3/model/mmcif_metadata.py
  function add_metadata_to_mmcif (line 47) | def add_metadata_to_mmcif(
  function add_legal_comment (line 216) | def add_legal_comment(cif: str) -> str:

FILE: src/alphafold3/model/model.py
  class InferenceResult (line 45) | class InferenceResult:
  function get_predicted_structure (line 70) | def get_predicted_structure(
  function create_target_feat_embedding (line 143) | def create_target_feat_embedding(
  function _compute_ptm (line 174) | def _compute_ptm(
  function _compute_chain_pair_iptm (line 196) | def _compute_chain_pair_iptm(
  class Model (line 216) | class Model(hk.Module):
    class HeadsConfig (line 219) | class HeadsConfig(base_config.BaseConfig):
    class Config (line 224) | class Config(base_config.BaseConfig):
    method __init__ (line 232) | def __init__(self, config: Config, name: str = 'diffuser'):
    method _sample_diffusion (line 241) | def _sample_diffusion(
    method __call__ (line 263) | def __call__(
    method get_inference_result (line 347) | def get_inference_result(

FILE: src/alphafold3/model/model_config.py
  class GlobalConfig (line 22) | class GlobalConfig(base_config.BaseConfig):

FILE: src/alphafold3/model/msa_pairing.py
  function _align_species (line 31) | def _align_species(
  function create_paired_features (line 78) | def create_paired_features(
  function deduplicate_unpaired_sequences (line 210) | def deduplicate_unpaired_sequences(
  function choose_paired_unpaired_msa_crop_sizes (line 238) | def choose_paired_unpaired_msa_crop_sizes(
  function remove_all_gapped_rows_from_all_seqs (line 283) | def remove_all_gapped_rows_from_all_seqs(

FILE: src/alphafold3/model/network/atom_cross_attention.py
  class AtomCrossAttEncoderConfig (line 25) | class AtomCrossAttEncoderConfig(base_config.BaseConfig):
  function _per_atom_conditioning (line 34) | def _per_atom_conditioning(
  class AtomCrossAttEncoderOutput (line 100) | class AtomCrossAttEncoderOutput:
  function atom_cross_att_encoder (line 117) | def atom_cross_att_encoder(
  class AtomCrossAttDecoderConfig (line 354) | class AtomCrossAttDecoderConfig(base_config.BaseConfig):
  function atom_cross_att_decoder (line 361) | def atom_cross_att_decoder(

FILE: src/alphafold3/model/network/confidence_head.py
  function _safe_norm (line 25) | def _safe_norm(x, keepdims, axis, eps=1e-8):
  class ConfidenceHead (line 29) | class ConfidenceHead(hk.Module):
    class PAEConfig (line 32) | class PAEConfig(base_config.BaseConfig):
    class Config (line 36) | class Config(base_config.BaseConfig):
    method __init__ (line 53) | def __init__(
    method _embed_features (line 63) | def _embed_features(
    method __call__ (line 92) | def __call__(
    method _get_tmscore_adjusted_pae (line 272) | def _get_tmscore_adjusted_pae(

FILE: src/alphafold3/model/network/diffusion_head.py
  function random_rotation (line 33) | def random_rotation(key):
  function random_augmentation (line 44) | def random_augmentation(
  function noise_schedule (line 79) | def noise_schedule(t, smin=0.0004, smax=160.0, p=7):
  class ConditioningConfig (line 86) | class ConditioningConfig(base_config.BaseConfig):
  class SampleConfig (line 92) | class SampleConfig(base_config.BaseConfig):
  class DiffusionHead (line 101) | class DiffusionHead(hk.Module):
    class Config (line 104) | class Config(
    method __init__ (line 123) | def __init__(
    method _conditioning (line 134) | def _conditioning(
    method __call__ (line 202) | def __call__(
  function sample (line 297) | def sample(

FILE: src/alphafold3/model/network/diffusion_transformer.py
  function adaptive_layernorm (line 23) | def adaptive_layernorm(x, single_cond, name):
  function adaptive_zero_init (line 54) | def adaptive_zero_init(
  function transition_block (line 78) | def transition_block(
  class SelfAttentionConfig (line 114) | class SelfAttentionConfig(base_config.BaseConfig):
  function self_attention (line 120) | def self_attention(
  class Transformer (line 180) | class Transformer(hk.Module):
    class Config (line 183) | class Config(base_config.BaseConfig):
    method __init__ (line 190) | def __init__(
    method __call__ (line 200) | def __call__(
  class CrossAttentionConfig (line 257) | class CrossAttentionConfig(base_config.BaseConfig):
  function cross_attention (line 263) | def cross_attention(
  class CrossAttTransformer (line 331) | class CrossAttTransformer(hk.Module):
    class Config (line 334) | class Config(base_config.BaseConfig):
    method __init__ (line 339) | def __init__(
    method __call__ (line 349) | def __call__(

FILE: src/alphafold3/model/network/distogram_head.py
  class DistogramHead (line 28) | class DistogramHead(hk.Module):
    class Config (line 31) | class Config(base_config.BaseConfig):
    method __init__ (line 36) | def __init__(
    method __call__ (line 46) | def __call__(

FILE: src/alphafold3/model/network/evoformer.py
  class Evoformer (line 30) | class Evoformer(hk.Module):
    class PairformerConfig (line 33) | class PairformerConfig(modules.PairFormerIteration.Config):  # pytype:...
    class Config (line 37) | class Config(base_config.BaseConfig):
    method __init__ (line 67) | def __init__(
    method _relative_encoding (line 77) | def _relative_encoding(
    method _seq_pair_embedding (line 94) | def _seq_pair_embedding(
    method _embed_bonds (line 120) | def _embed_bonds(
    method _embed_template_pair (line 171) | def _embed_template_pair(
    method _embed_process_msa (line 200) | def _embed_process_msa(
    method __call__ (line 243) | def __call__(

FILE: src/alphafold3/model/network/featurization.py
  function _grid_keys (line 23) | def _grid_keys(key, shape):
  function _padding_consistent_rng (line 44) | def _padding_consistent_rng(f):
  function gumbel_argsort_sample_idx (line 81) | def gumbel_argsort_sample_idx(
  function create_msa_feat (line 111) | def create_msa_feat(msa: features.MSA) -> jax.Array:
  function truncate_msa_batch (line 131) | def truncate_msa_batch(msa: features.MSA, num_msa: int) -> features.MSA:
  function create_target_feat (line 136) | def create_target_feat(
  function create_relative_encoding (line 168) | def create_relative_encoding(
  function shuffle_msa (line 251) | def shuffle_msa(

FILE: src/alphafold3/model/network/modules.py
  function get_shard_size (line 27) | def get_shard_size(
  class TransitionBlock (line 41) | class TransitionBlock(hk.Module):
    class Config (line 44) | class Config(base_config.BaseConfig):
    method __init__ (line 48) | def __init__(
    method __call__ (line 55) | def __call__(self, act, broadcast_dim=0):
  class MSAAttention (line 87) | class MSAAttention(hk.Module):
    class Config (line 90) | class Config(base_config.BaseConfig):
    method __init__ (line 93) | def __init__(
    method __call__ (line 100) | def __call__(self, act, mask, pair_act):
  class GridSelfAttention (line 131) | class GridSelfAttention(hk.Module):
    class Config (line 134) | class Config(base_config.BaseConfig):
    method __init__ (line 137) | def __init__(
    method _attention (line 151) | def _attention(
    method __call__ (line 199) | def __call__(self, act, pair_mask):
  class TriangleMultiplication (line 245) | class TriangleMultiplication(hk.Module):
    class Config (line 248) | class Config(base_config.BaseConfig):
    method __init__ (line 252) | def __init__(
    method __call__ (line 259) | def __call__(self, act, mask):
  class OuterProductMean (line 334) | class OuterProductMean(hk.Module):
    class Config (line 337) | class Config(base_config.BaseConfig):
    method __init__ (line 341) | def __init__(
    method __call__ (line 354) | def __call__(self, act, mask):
  class PairFormerIteration (line 415) | class PairFormerIteration(hk.Module):
    class Config (line 418) | class Config(base_config.BaseConfig):
    method __init__ (line 434) | def __init__(
    method __call__ (line 447) | def __call__(
  class EvoformerIteration (line 535) | class EvoformerIteration(hk.Module):
    class Config (line 538) | class Config(base_config.BaseConfig):
    method __init__ (line 555) | def __init__(
    method __call__ (line 565) | def __call__(self, activations, masks):

FILE: src/alphafold3/model/network/noise_level_embeddings.py
  function noise_embeddings (line 135) | def noise_embeddings(sigma_scaled_noise_level: jnp.ndarray) -> jnp.ndarray:

FILE: src/alphafold3/model/network/template_modules.py
  class DistogramFeaturesConfig (line 27) | class DistogramFeaturesConfig(base_config.BaseConfig):
  function dgram_from_positions (line 37) | def dgram_from_positions(positions, config: DistogramFeaturesConfig):
  function make_backbone_rigid (line 67) | def make_backbone_rigid(
  class TemplateEmbedding (line 109) | class TemplateEmbedding(hk.Module):
    class Config (line 112) | class Config(base_config.BaseConfig):
    method __init__ (line 120) | def __init__(
    method __call__ (line 130) | def __call__(
  class SingleTemplateEmbedding (line 208) | class SingleTemplateEmbedding(hk.Module):
    method __init__ (line 211) | def __init__(
    method __call__ (line 221) | def __call__(

FILE: src/alphafold3/model/params.py
  class RecordError (line 31) | class RecordError(Exception):
  function encode_record (line 35) | def encode_record(scope: str, name: str, arr: np.ndarray) -> bytes:
  function _read_record (line 53) | def _read_record(stream: IO[bytes]) -> tuple[str, str, np.ndarray] | None:
  function read_records (line 80) | def read_records(stream: IO[bytes]) -> Iterator[tuple[str, str, np.ndarr...
  class _MultiFileIO (line 86) | class _MultiFileIO(io.RawIOBase):
    method __init__ (line 89) | def __init__(self, files: list[pathlib.Path]):
    method _abs_to_rel (line 106) | def _abs_to_rel(self, pos: int) -> tuple[int, int]:
    method close (line 110) | def close(self):
    method closed (line 113) | def closed(self) -> bool:
    method fileno (line 116) | def fileno(self) -> int:
    method readable (line 119) | def readable(self) -> bool:
    method tell (line 122) | def tell(self) -> int:
    method seek (line 125) | def seek(self, pos: int, whence: int = os.SEEK_SET, /):
    method readinto (line 138) | def readinto(self, b: bytearray | memoryview) -> int:
  function open_for_reading (line 154) | def open_for_reading(model_files: list[pathlib.Path], is_compressed: bool):
  function _match_model (line 162) | def _match_model(
  function select_model_files (line 174) | def select_model_files(
  function get_model_haiku_params (line 201) | def get_model_haiku_params(model_dir: pathlib.Path) -> hk.Params:

FILE: src/alphafold3/model/pipeline/inter_chain_bonds.py
  class BondAtomArrays (line 28) | class BondAtomArrays(NamedTuple):
  function _get_bond_atom_arrays (line 37) | def _get_bond_atom_arrays(
  function get_polymer_ligand_and_ligand_ligand_bonds (line 51) | def get_polymer_ligand_and_ligand_ligand_bonds(
  function _remove_multi_bonds (line 103) | def _remove_multi_bonds(
  function get_ligand_ligand_bonds (line 126) | def get_ligand_ligand_bonds(
  function get_polymer_ligand_bonds (line 162) | def get_polymer_ligand_bonds(
  function get_bond_layout (line 202) | def get_bond_layout(

FILE: src/alphafold3/model/pipeline/pipeline.py
  function calculate_bucket_size (line 33) | def calculate_bucket_size(
  class NanDataError (line 64) | class NanDataError(Exception):
  class TotalNumResOutOfRangeError (line 68) | class TotalNumResOutOfRangeError(Exception):
  class MmcifNumChainsError (line 72) | class MmcifNumChainsError(Exception):
  class WholePdbPipeline (line 76) | class WholePdbPipeline:
    class Config (line 79) | class Config(base_config.BaseConfig):
    method __init__ (line 151) | def __init__(self, *, config: Config):
    method process_item (line 159) | def process_item(

FILE: src/alphafold3/model/pipeline/structure_cleaning.py
  function _get_leaving_atom_mask (line 27) | def _get_leaving_atom_mask(
  function clean_structure (line 68) | def clean_structure(
  function create_empty_output_struc_and_layout (line 294) | def create_empty_output_struc_and_layout(

FILE: src/alphafold3/model/post_processing.py
  class ProcessedInferenceResult (line 26) | class ProcessedInferenceResult:
  function post_process_inference_result (line 48) | def post_process_inference_result(
  function write_output (line 90) | def write_output(
  function write_embeddings (line 128) | def write_embeddings(

FILE: src/alphafold3/model/protein_data_processing.py
  function _make_restype_rigidgroup_dense_atom_idx (line 29) | def _make_restype_rigidgroup_dense_atom_idx():
  function _make_restype_pseudobeta_idx (line 76) | def _make_restype_pseudobeta_idx():
  function _make_aatype_dense_atom_to_atom37 (line 105) | def _make_aatype_dense_atom_to_atom37():

FILE: src/alphafold3/model/scoring/alignment.py
  function transform_ls (line 16) | def transform_ls(
  function align (line 52) | def align(
  function deviations_from_coords (line 96) | def deviations_from_coords(
  function rmsd_from_coords (line 125) | def rmsd_from_coords(

FILE: src/alphafold3/model/scoring/chirality.py
  function _find_chiral_centres (line 24) | def _find_chiral_centres(mol: rd_chem.Mol) -> dict[str, str]:
  function _chiral_match (line 49) | def _chiral_match(mol1: rd_chem.Mol, mol2: rd_chem.Mol) -> bool:
  function _mol_from_ligand_struc (line 71) | def _mol_from_ligand_struc(
  function _maybe_mol_from_ccd (line 118) | def _maybe_mol_from_ccd(res_name: str) -> rd_chem.Mol | None:
  function compare_chirality (line 140) | def compare_chirality(

FILE: src/alphafold3/model/scoring/covalent_bond_cleaning.py
  class ResIdMapping (line 24) | class ResIdMapping:
  function _count_symmetric_chains (line 29) | def _count_symmetric_chains(struc: structure.Structure) -> Mapping[str, ...
  function has_nonsymmetric_bonds_on_symmetric_polymer_chains (line 45) | def has_nonsymmetric_bonds_on_symmetric_polymer_chains(
  function _has_non_polymer_ligand_ptm_bonds (line 69) | def _has_non_polymer_ligand_ptm_bonds(
  function _combine_polymer_ligand_ptm_chains (line 89) | def _combine_polymer_ligand_ptm_chains(
  function _has_only_single_bond_from_each_chain (line 167) | def _has_only_single_bond_from_each_chain(
  function _get_polymer_and_ligand_chain_ids_and_types (line 179) | def _get_polymer_and_ligand_chain_ids_and_types(
  function _get_polymer_dim (line 202) | def _get_polymer_dim(polymer_ligand_bonds: atom_layout.AtomLayout) -> int:
  function _has_multiple_ligands_bonded_to_one_polymer (line 223) | def _has_multiple_ligands_bonded_to_one_polymer(polymer_ligand_bonds):
  function _has_multiple_polymers_bonded_to_one_ligand (line 234) | def _has_multiple_polymers_bonded_to_one_ligand(polymer_ligand_bonds):
  function _sort_polymer_ligand_bonds_by_polymer_chain_and_res_id (line 246) | def _sort_polymer_ligand_bonds_by_polymer_chain_and_res_id(

FILE: src/alphafold3/model/scoring/scoring.py
  function pseudo_beta_fn (line 21) | def pseudo_beta_fn(

FILE: src/alphafold3/parsers/cpp/cif_dict.pyi
  class CifDict (line 17) | class CifDict:
    class ItemView (line 18) | class ItemView:
      method __iter__ (line 19) | def __iter__(self) -> Iterator[tuple[str, list[str]]]: ...
      method __len__ (line 20) | def __len__(self) -> int: ...
    class KeyView (line 22) | class KeyView:
      method __contains__ (line 24) | def __contains__(self, key: str) -> bool: ...
      method __contains__ (line 26) | def __contains__(self, key: object) -> bool: ...
      method __iter__ (line 27) | def __iter__(self) -> Iterator[str]: ...
      method __len__ (line 28) | def __len__(self) -> int: ...
    class ValueView (line 30) | class ValueView:
      method __iter__ (line 31) | def __iter__(self) -> Iterator[list[str]]: ...
      method __len__ (line 32) | def __len__(self) -> int: ...
    method __init__ (line 34) | def __init__(self, d: dict[str, Iterable[str]]) -> None: ...
    method copy_and_update (line 35) | def copy_and_update(self, d: dict[str, Iterable[str]]) -> CifDict: ...
    method extract_loop_as_dict (line 36) | def extract_loop_as_dict(self, prefix: str, index: str) -> dict:
    method extract_loop_as_list (line 59) | def extract_loop_as_list(self, prefix: str) -> list:
    method get (line 82) | def get(self, key: str, default_value: _T = ...) -> list[str] | _T: ...
    method get_array (line 83) | def get_array(
    method get_data_name (line 108) | def get_data_name(self) -> str: ...
    method items (line 109) | def items(self) -> CifDict.ItemView: ...
    method keys (line 110) | def keys(self) -> CifDict.KeyView: ...
    method to_string (line 111) | def to_string(self) -> str: ...
    method to_dict (line 112) | def to_dict(self) -> dict[str, list[str]]: ...
    method value_length (line 113) | def value_length(self, key: str) -> int: ...
    method values (line 114) | def values(self) -> CifDict.ValueView: ...
    method __bool__ (line 115) | def __bool__(self) -> bool: ...
    method __contains__ (line 116) | def __contains__(self, key: str) -> bool: ...
    method __getitem__ (line 117) | def __getitem__(self, key: str) -> list[str]: ...
    method __getstate__ (line 118) | def __getstate__(self) -> tuple: ...
    method __iter__ (line 119) | def __iter__(self) -> Iterator[str]: ...
    method __len__ (line 120) | def __len__(self) -> int: ...
    method __setstate__ (line 121) | def __setstate__(self, state: tuple) -> None: ...
  function tokenize (line 123) | def tokenize(cif_string: str) -> list[str]: ...
  function split_line (line 124) | def split_line(line: str) -> list[str]: ...
  function from_string (line 125) | def from_string(mmcif_string: str | bytes) -> CifDict: ...
  function parse_multi_data_cif (line 126) | def parse_multi_data_cif(cif_string: str | bytes) -> dict[str, CifDict]:...

FILE: src/alphafold3/parsers/cpp/cif_dict_lib.cc
  type alphafold3 (line 40) | namespace alphafold3 {
    function IsQuote (line 43) | bool IsQuote(const char symbol) { return symbol == '\'' || symbol == '...
    function IsWhitespace (line 44) | bool IsWhitespace(const char symbol) { return symbol == ' ' || symbol ...
    function SplitLineInline (line 47) | bool SplitLineInline(absl::string_view line,
    function TokenizeInternal (line 111) | absl::StatusOr<std::vector<absl::string_view>> TokenizeInternal(
    function IsTrivialToken (line 158) | bool IsTrivialToken(const absl::string_view value) {
    function IsMultiLineToken (line 170) | bool IsMultiLineToken(const absl::string_view value) {
    function GetEscapeQuote (line 185) | absl::string_view GetEscapeQuote(const absl::string_view value) {
    function RecordIndex (line 231) | int RecordIndex(absl::string_view record) {
    type RecordOrder (line 241) | struct RecordOrder {
    function AtomSiteIndex (line 275) | size_t AtomSiteIndex(absl::string_view atom_site) {
    type AtomSiteOrder (line 280) | struct AtomSiteOrder {
    class Column (line 288) | class Column {
      method Column (line 290) | Column(absl::string_view key, const std::vector<std::string>* values)
      method key (line 313) | absl::string_view key() const { return key_; }
      method max_value_length (line 317) | int max_value_length() const { return max_value_length_; }
      method has_newlines (line 319) | bool has_newlines(size_t index) const {
      method quote (line 323) | absl::string_view quote(size_t index) const {
    type GroupedKeys (line 340) | struct GroupedKeys {
    function CheckLoopColumnSizes (line 346) | absl::Status CheckLoopColumnSizes(int num_loop_keys, int num_loop_valu...
    function Tokenize (line 682) | absl::StatusOr<std::vector<std::string>> Tokenize(
    function SplitLine (line 692) | absl::StatusOr<std::vector<absl::string_view>> SplitLine(
    function ParseMultiDataCifDict (line 702) | absl::StatusOr<absl::flat_hash_map<std::string, CifDict>> ParseMultiDa...

FILE: src/alphafold3/parsers/cpp/cif_dict_lib.h
  function namespace (line 28) | namespace alphafold3 {

FILE: src/alphafold3/parsers/cpp/cif_dict_pybind.cc
  type alphafold3 (line 42) | namespace alphafold3 {
    function GatherArray (line 47) | bool GatherArray(size_t num_dims, npy_intp* shape_array, npy_intp* str...
    function Gather (line 96) | bool Gather(PyObject* gather, absl::Span<const std::string> values,
    function PyObject (line 192) | PyObject* ConvertStrings(PyObject* gather, PyArray_Descr* type,
    function PyObject (line 239) | inline PyObject* Convert(PyObject* gather, PyArray_Descr* type,
    function PyObject (line 273) | PyObject* CifDictGetArray(const CifDict& self, absl::string_view key,
    function RegisterModuleCifDict (line 371) | void RegisterModuleCifDict(pybind11::module m) {

FILE: src/alphafold3/parsers/cpp/cif_dict_pybind.h
  function namespace (line 16) | namespace alphafold3 {

FILE: src/alphafold3/parsers/cpp/fasta_iterator.pyi
  class FastaFileIterator (line 11) | class FastaFileIterator:
    method __init__ (line 12) | def __init__(self, fasta_path: str) -> None: ...
    method __iter__ (line 13) | def __iter__(self) -> FastaFileIterator: ...
    method __next__ (line 14) | def __next__(self) -> tuple[str,str]: ...
  class FastaStringIterator (line 16) | class FastaStringIterator:
    method __init__ (line 17) | def __init__(self, fasta_string: str | bytes) -> None: ...
    method __iter__ (line 18) | def __iter__(self) -> FastaStringIterator: ...
    method __next__ (line 19) | def __next__(self) -> tuple[str,str]: ...
  function parse_fasta (line 21) | def parse_fasta(fasta_string: str | bytes) -> list[str]: ...
  function parse_fasta_include_descriptions (line 22) | def parse_fasta_include_descriptions(fasta_string: str | bytes) -> tuple...

FILE: src/alphafold3/parsers/cpp/fasta_iterator_lib.cc
  type alphafold3 (line 27) | namespace alphafold3 {
    function ParseFasta (line 31) | std::vector<std::string> ParseFasta(absl::string_view fasta_string) {
    function ParseFastaIncludeDescriptions (line 48) | std::pair<std::vector<std::string>, std::vector<std::string>>

FILE: src/alphafold3/parsers/cpp/fasta_iterator_lib.h
  function namespace (line 25) | namespace alphafold3 {

FILE: src/alphafold3/parsers/cpp/fasta_iterator_pybind.cc
  type alphafold3 (line 21) | namespace alphafold3 {
    function T (line 27) | T ValueOrThrowValueError(absl::StatusOr<T> value) {
    class PythonFastaStringIterator (line 73) | class PythonFastaStringIterator : public FastaStringIterator {
      method PythonFastaStringIterator (line 75) | explicit PythonFastaStringIterator(py::object fasta_string)
    function RegisterModuleFastaIterator (line 85) | void RegisterModuleFastaIterator(pybind11::module m) {

FILE: src/alphafold3/parsers/cpp/fasta_iterator_pybind.h
  function namespace (line 16) | namespace alphafold3 {

FILE: src/alphafold3/parsers/cpp/msa_conversion.pyi
  function align_sequence_to_gapless_query (line 20) | def align_sequence_to_gapless_query(
  function convert_a3m_to_stockholm (line 26) | def convert_a3m_to_stockholm(a3m_sequences: Iterable[str]) -> list[str]:...

FILE: src/alphafold3/parsers/cpp/msa_conversion_pybind.cc
  function ConvertA3MToStockholm (line 27) | std::vector<std::string> ConvertA3MToStockholm(
  function AlignSequenceToGaplessQuery (line 83) | std::string AlignSequenceToGaplessQuery(absl::string_view sequence,
  type alphafold3 (line 150) | namespace alphafold3 {
    function RegisterModuleMsaConversion (line 152) | void RegisterModuleMsaConversion(pybind11::module m) {

FILE: src/alphafold3/parsers/cpp/msa_conversion_pybind.h
  function namespace (line 16) | namespace alphafold3 {

FILE: src/alphafold3/structure/bioassemblies.py
  class Operation (line 23) | class Operation:
    method apply_to_coords (line 29) | def apply_to_coords(self, coords: np.ndarray) -> np.ndarray:
  class Transform (line 35) | class Transform:
    method apply_to_coords (line 50) | def apply_to_coords(self, coords: np.ndarray) -> np.ndarray:
  function _get_operation (line 57) | def _get_operation(oper_data: Mapping[str, str]) -> Operation:
  class MissingBioassemblyDataError (line 71) | class MissingBioassemblyDataError(Exception):
  class BioassemblyData (line 75) | class BioassemblyData:
    method __init__ (line 108) | def __init__(
    method from_mmcif (line 145) | def from_mmcif(cls, cif: mmcif.Mmcif) -> Self:
    method assembly_ids (line 188) | def assembly_ids(self) -> Sequence[str]:
    method asym_id_by_assembly_chain_id (line 191) | def asym_id_by_assembly_chain_id(self, assembly_id: str) -> Mapping[st...
    method assembly_chain_ids_by_asym_id (line 198) | def assembly_chain_ids_by_asym_id(
    method get_default_assembly_id (line 209) | def get_default_assembly_id(self) -> str:
    method get_assembly_info (line 216) | def get_assembly_info(self, assembly_id: str) -> Mapping[str, str]:
    method get_transforms (line 222) | def get_transforms(self, assembly_id: str) -> Sequence[Transform]:
    method to_mmcif_dict (line 269) | def to_mmcif_dict(self) -> Mapping[str, Sequence[str]]:
    method rename_label_asym_ids (line 283) | def rename_label_asym_ids(

FILE: src/alphafold3/structure/bonds.py
  class Bonds (line 24) | class Bonds(table.Table):
    method make_empty (line 45) | def make_empty(cls) -> Self:
    method get_atom_indices (line 54) | def get_atom_indices(
    method restrict_to_atoms (line 80) | def restrict_to_atoms(self, atom_key: np.ndarray) -> Self:
    method to_mmcif_dict_from_atom_arrays (line 88) | def to_mmcif_dict_from_atom_arrays(
  function concat_with_atom_keys (line 166) | def concat_with_atom_keys(

FILE: src/alphafold3/structure/chemical_components.py
  class ChemCompEntry (line 25) | class ChemCompEntry:
    method __post_init__ (line 40) | def __post_init__(self):
    method extends (line 45) | def extends(self, other: Self) -> bool:
    method rdkit_mol (line 56) | def rdkit_mol(self) -> rd_chem.Mol:
  class MissingChemicalComponentsDataError (line 66) | class MissingChemicalComponentsDataError(Exception):
  class ChemicalComponentsData (line 71) | class ChemicalComponentsData:
    method from_mmcif (line 82) | def from_mmcif(
    method to_mmcif_dict (line 134) | def to_mmcif_dict(self) -> Mapping[str, Sequence[str]]:
  function _value_is_missing (line 156) | def _value_is_missing(value: str) -> bool:
  function get_data_for_ccd_components (line 160) | def get_data_for_ccd_components(
  function populate_missing_ccd_data (line 187) | def populate_missing_ccd_data(
  function get_all_atoms_in_entry (line 233) | def get_all_atoms_in_entry(
  function get_res_atom_names (line 281) | def get_res_atom_names(ccd: chemical_components.Ccd, res_name: str) -> s...

FILE: src/alphafold3/structure/cpp/aggregation.pyi
  function indices_grouped_by_value (line 13) | def indices_grouped_by_value(values: Sequence[int]) -> dict[int, list[in...

FILE: src/alphafold3/structure/cpp/aggregation_pybind.cc
  function IndicesGroupedByValue (line 25) | absl::flat_hash_map<int64_t, std::vector<int64_t>> IndicesGroupedByValue(
  type alphafold3 (line 46) | namespace alphafold3 {
    function RegisterModuleAggregation (line 48) | void RegisterModuleAggregation(py::module m) {

FILE: src/alphafold3/structure/cpp/aggregation_pybind.h
  function namespace (line 16) | namespace alphafold3 {

FILE: src/alphafold3/structure/cpp/membership.pyi
  function isin (line 14) | def isin(

FILE: src/alphafold3/structure/cpp/membership_pybind.cc
  function IsIn (line 26) | py::array_t<bool> IsIn(const py::array_t<int64_t, py::array::c_style>& a...
  type alphafold3 (line 75) | namespace alphafold3 {
    function RegisterModuleMembership (line 77) | void RegisterModuleMembership(pybind11::module m) {

FILE: src/alphafold3/structure/cpp/membership_pybind.h
  function namespace (line 16) | namespace alphafold3 {

FILE: src/alphafold3/structure/cpp/mmcif_altlocs.cc
  type alphafold3 (line 29) | namespace alphafold3 {
    function OccupancyToFloat (line 32) | float OccupancyToFloat(absl::string_view occupancy) {
    function AtomEquiv (line 40) | bool AtomEquiv(absl::string_view lhs, absl::string_view rhs) {
    function GroupBy (line 66) | void GroupBy(absl::Span<const std::string> values, std::size_t start,
    function ProcessAltLocGroupsWhole (line 81) | void ProcessAltLocGroupsWhole(std::size_t alt_loc_start,
    function ProcessAltLocGroupPartial (line 169) | void ProcessAltLocGroupPartial(
    function ResolveMmcifAltLocs (line 202) | std::vector<std::uint64_t> ResolveMmcifAltLocs(

FILE: src/alphafold3/structure/cpp/mmcif_altlocs.h
  function namespace (line 22) | namespace alphafold3 {

FILE: src/alphafold3/structure/cpp/mmcif_atom_site.pyi
  function get_internal_to_author_chain_id_map (line 15) | def get_internal_to_author_chain_id_map(
  function get_or_infer_type_symbol (line 20) | def get_or_infer_type_symbol(

FILE: src/alphafold3/structure/cpp/mmcif_atom_site_pybind.cc
  type alphafold3 (line 24) | namespace alphafold3 {
    function GetOrInferTypeSymbol (line 31) | py::list GetOrInferTypeSymbol(const CifDict& mmcif,
    function GetInternalToAuthorChainIdMap (line 53) | absl::flat_hash_map<absl::string_view, absl::string_view>
    function RegisterModuleMmcifAtomSite (line 75) | void RegisterModuleMmcifAtomSite(pybind11::module m) {

FILE: src/alphafold3/structure/cpp/mmcif_atom_site_pybind.h
  function namespace (line 16) | namespace alphafold3 {

FILE: src/alphafold3/structure/cpp/mmcif_layout.h
  function namespace (line 25) | namespace alphafold3 {

FILE: src/alphafold3/structure/cpp/mmcif_layout.pyi
  class MmcifLayout (line 13) | class MmcifLayout:
    method atom_range (line 14) | def atom_range(self, residue_index: int) -> tuple[int, int]: ...
    method chain_starts (line 15) | def chain_starts(self) -> list[int]: ...
    method chains (line 16) | def chains(self) -> list[int]: ...
    method model_offset (line 17) | def model_offset(self) -> int: ...
    method num_atoms (line 18) | def num_atoms(self) -> int: ...
    method num_chains (line 19) | def num_chains(self) -> int: ...
    method num_models (line 20) | def num_models(self) -> int: ...
    method num_residues (line 21) | def num_residues(self) -> int: ...
    method residue_range (line 22) | def residue_range(self, chain_index: int) -> tuple[int, int]: ...
    method residue_starts (line 23) | def residue_starts(self) -> list[int]: ...
    method residues (line 24) | def residues(self) -> list[int]: ...
  function from_mmcif (line 26) | def from_mmcif(mmcif: cif_dict.CifDict, model_id: str = ...) -> MmcifLay...

FILE: src/alphafold3/structure/cpp/mmcif_layout_lib.cc
  type alphafold3 (line 30) | namespace alphafold3 {

FILE: src/alphafold3/structure/cpp/mmcif_layout_pybind.cc
  type alphafold3 (line 16) | namespace alphafold3 {
    function RegisterModuleMmcifLayout (line 20) | void RegisterModuleMmcifLayout(pybind11::module m) {

FILE: src/alphafold3/structure/cpp/mmcif_layout_pybind.h
  function namespace (line 16) | namespace alphafold3 {

FILE: src/alphafold3/structure/cpp/mmcif_struct_conn.h
  function namespace (line 21) | namespace alphafold3 {

FILE: src/alphafold3/structure/cpp/mmcif_struct_conn.pyi
  function get_bond_atom_indices (line 13) | def get_bond_atom_indices(mmcif_dict: cif_dict.CifDict, model_id: str) -...

FILE: src/alphafold3/structure/cpp/mmcif_struct_conn_lib.cc
  type alphafold3 (line 29) | namespace alphafold3 {
    type AtomId (line 33) | struct AtomId {
      method H (line 42) | H AbslHashValue(H h, const AtomId& m) {
    function AreSameSize (line 54) | bool AreSameSize(const C& c, const Cs&... cs) {
    type ColumnSpec (line 58) | struct ColumnSpec {
    class AtomColumns (line 66) | class AtomColumns {
      method Create (line 68) | static absl::StatusOr<AtomColumns> Create(const CifDict& mmcif,
      method size (line 100) | inline std::size_t size() const { return size_; }
      method GetNormalizedAltId (line 102) | absl::string_view GetNormalizedAltId(const std::size_t index) const {
      method AtomId (line 112) | AtomId GetAtom(const std::size_t index) const {
      method GetAtomString (line 120) | std::string GetAtomString(const std::size_t index) const {
      method AtomColumns (line 136) | AtomColumns(StringArrayRef chain_id, StringArrayRef res_id_1,
    function FillInBondsForAtom (line 157) | absl::Status FillInBondsForAtom(const BondIndexByAtom& bond_index_by_a...
    function HasAllColumns (line 175) | bool HasAllColumns(const CifDict& mmcif, const ColumnSpec& columns) {
    function GetBondAtomIndices (line 240) | absl::StatusOr<std::pair<BondAtomIndices, BondAtomIndices>> GetBondAto...

FILE: src/alphafold3/structure/cpp/mmcif_struct_conn_pybind.cc
  type alphafold3 (line 21) | namespace alphafold3 {
    function RegisterModuleMmcifStructConn (line 53) | void RegisterModuleMmcifStructConn(pybind11::module m) {

FILE: src/alphafold3/structure/cpp/mmcif_struct_conn_pybind.h
  function namespace (line 16) | namespace alphafold3 {

FILE: src/alphafold3/structure/cpp/mmcif_utils.pyi
  function filter (line 19) | def filter(
  function fix_residues (line 29) | def fix_residues(
  function read_layout (line 40) | def read_layout(
  function selected_ligand_residue_mask (line 45) | def selected_ligand_residue_mask(
  function selected_polymer_residue_mask (line 63) | def selected_polymer_residue_mask(

FILE: src/alphafold3/structure/cpp/mmcif_utils_pybind.cc
  type alphafold3 (line 45) | namespace alphafold3 {
    type PyObjectDeleter (line 49) | struct PyObjectDeleter {
    function Indexer (line 59) | Indexer MakeIndex(StringArrayRef col) {
    function AreSameSize (line 70) | bool AreSameSize(C c, const Cs&... cs) {
    type AtomSiteLoop (line 76) | struct AtomSiteLoop {
      method AtomSiteLoop (line 77) | explicit AtomSiteLoop(const CifDict& cif_dict)
    type EntityLoop (line 116) | struct EntityLoop {
      method EntityLoop (line 117) | explicit EntityLoop(const CifDict& cif_dict)
    type EntityPolyLoop (line 131) | struct EntityPolyLoop {
      method EntityPolyLoop (line 132) | explicit EntityPolyLoop(const CifDict& cif_dict)
    function SelectChains (line 148) | absl::flat_hash_set<absl::string_view> SelectChains(const CifDict& mmcif,
    class ProcessResidue (line 227) | class ProcessResidue {
      method ProcessResidue (line 229) | explicit ProcessResidue(const char* residue)
      method IsResidue (line 231) | bool IsResidue(PyObject* residue) {
      method ArePyObjectsEqual (line 235) | static bool ArePyObjectsEqual(PyObject* lhs, PyObject* rhs) {
    type Position3 (line 251) | struct Position3 {
    function DistanceSquared (line 257) | float DistanceSquared(Position3 v1, Position3 v2) {
    class FixArginine (line 264) | class FixArginine : public ProcessResidue {
      method FixArginine (line 266) | FixArginine()
      method Fix (line 275) | void Fix(absl::Span<PyObject*> atom_ids, absl::Span<const float> ato...
    function MmcifLayout (line 347) | inline MmcifLayout ReadMmcifLayout(const CifDict& mmcif,
    function MmcifFilter (line 358) | py::tuple MmcifFilter(         //
    function MmcifFixResidues (line 429) | void MmcifFixResidues(               //
    function SelectedPolymerResidueMask (line 474) | std::vector<bool> SelectedPolymerResidueMask(
    function SelectedLigandResidueMask (line 523) | std::pair<std::vector<bool>, std::vector<bool>> SelectedLigandResidueM...
    function RegisterModuleMmcifUtils (line 727) | void RegisterModuleMmcifUtils(pybind11::module m) {

FILE: src/alphafold3/structure/cpp/mmcif_utils_pybind.h
  function namespace (line 16) | namespace alphafold3 {

FILE: src/alphafold3/structure/cpp/string_array.pyi
  function format_float_array (line 17) | def format_float_array(
  function isin (line 22) | def isin(
  function remap (line 31) | def remap(
  function remap (line 40) | def remap(
  function remap_multiple (line 47) | def remap_multiple(

FILE: src/alphafold3/structure/cpp/string_array_pybind.cc
  function PyObject (line 41) | PyObject* RemapNumpyArrayObjects(PyObject* array, PyObject* mapping,
  function FormatFloatArray (line 131) | std::vector<std::string> FormatFloatArray(absl::Span<const float> values,
  function IsIn (line 143) | py::array_t<bool> IsIn(
  function RemapMultipleArrays (line 174) | py::array RemapMultipleArrays(
  type alphafold3 (line 290) | namespace alphafold3 {
    function RegisterModuleStringArray (line 292) | void RegisterModuleStringArray(pybind11::module m) {

FILE: src/alphafold3/structure/cpp/string_array_pybind.h
  function namespace (line 16) | namespace alphafold3 {

FILE: src/alphafold3/structure/mmcif.py
  function int_id_to_str_id (line 40) | def int_id_to_str_id(num: int) -> str:
  function str_id_to_int_id (line 63) | def str_id_to_int_id(str_id: str) -> int:
  function from_string (line 86) | def from_string(mmcif_string: str | bytes) -> Mmcif:
  function parse_multi_data_cif (line 90) | def parse_multi_data_cif(cif_string: str) -> dict[str, Mmcif]:
  class BondParsingError (line 118) | class BondParsingError(Exception):
  function get_bond_atom_indices (line 122) | def get_bond_atom_indices(
  function get_or_infer_type_symbol (line 154) | def get_or_infer_type_symbol(
  function get_chain_type_by_entity_id (line 175) | def get_chain_type_by_entity_id(mmcif: Mmcif) -> Mapping[str, str]:
  function get_internal_to_author_chain_id_map (line 198) | def get_internal_to_author_chain_id_map(mmcif: Mmcif) -> Mapping[str, str]:
  function get_experimental_method (line 212) | def get_experimental_method(mmcif: Mmcif) -> str | None:
  function get_release_date (line 217) | def get_release_date(mmcif: Mmcif) -> str | None:
  function get_resolution (line 226) | def get_resolution(mmcif: Mmcif) -> float | None:
  function parse_oper_expr (line 252) | def parse_oper_expr(oper_expression: str) -> list[tuple[str, ...]]:
  function format_float_array (line 299) | def format_float_array(

FILE: src/alphafold3/structure/parsing.py
  class NoAtomsError (line 43) | class NoAtomsError(Exception):
  class BondIndices (line 48) | class BondIndices:
  class ModelID (line 54) | class ModelID(enum.Enum):
  class SequenceFormat (line 62) | class SequenceFormat(enum.Enum):
  function _create_bond_lookup (line 70) | def _create_bond_lookup(
  function _get_atom_element (line 93) | def _get_atom_element(
  function _get_representative_atom (line 102) | def _get_representative_atom(
  function _get_first_non_leaving_atom (line 129) | def _get_first_non_leaving_atom(
  function _add_ligand_to_chem_comp (line 142) | def _add_ligand_to_chem_comp(
  function _get_first_model_id (line 162) | def _get_first_model_id(cif: mmcif.Mmcif) -> str:
  function _get_str_model_id (line 169) | def _get_str_model_id(
  function _parse_bonds (line 202) | def _parse_bonds(
  class _MmcifHeader (line 257) | class _MmcifHeader:
  function _get_mmcif_header (line 266) | def _get_mmcif_header(
  function from_parsed_mmcif (line 307) | def from_parsed_mmcif(
  function from_mmcif (line 399) | def from_mmcif(
  function from_res_arrays (line 456) | def from_res_arrays(atom_mask: np.ndarray, **kwargs) -> structure.Struct...
  function expand_sequence (line 591) | def expand_sequence(
  function from_sequences_and_bonds (line 628) | def from_sequences_and_bonds(
  class _ChainResBuilder (line 842) | class _ChainResBuilder:
    method __init__ (line 845) | def __init__(
    method add_residues (line 880) | def add_residues(
    method make_chains_table (line 943) | def make_chains_table(self) -> structure_tables.Chains:
    method make_residues_table (line 966) | def make_residues_table(self) -> structure_tables.Residues:
  function _get_string_array_default (line 1003) | def _get_string_array_default(cif: mmcif.Mmcif, key: str, default: list[...
  function _generate_required_tables_if_missing (line 1010) | def _generate_required_tables_if_missing(
  function _maybe_add_missing_scheme_tables (line 1105) | def _maybe_add_missing_scheme_tables(
  function _get_chain_key_by_chain_id (line 1272) | def _get_chain_key_by_chain_id(
  function get_tables (line 1301) | def get_tables(
  function from_atom_arrays (line 1643) | def from_atom_arrays(
  function _guess_entity_type (line 1772) | def _guess_entity_type(

FILE: src/alphafold3/structure/sterics.py
  function _make_atom_has_clash_mask (line 21) | def _make_atom_has_clash_mask(
  function find_clashing_chains (line 57) | def find_clashing_chains(

FILE: src/alphafold3/structure/structure.py
  class CascadeDelete (line 42) | class CascadeDelete(enum.Enum):
  class _UnsetSentinel (line 49) | class _UnsetSentinel(enum.Enum):
  class Bond (line 56) | class Bond(NamedTuple):
  class MissingAtomError (line 64) | class MissingAtomError(Exception):
  class MissingAuthorResidueIdError (line 68) | class MissingAuthorResidueIdError(Exception):
  function fix_non_standard_polymer_residues (line 166) | def fix_non_standard_polymer_residues(
  function _get_change_indices (line 218) | def _get_change_indices(arr: np.ndarray) -> np.ndarray:
  function _unpack_filter_predicates (line 226) | def _unpack_filter_predicates(
  class StructureTables (line 271) | class StructureTables:
  class ResArrays (line 279) | class ResArrays:
  class Structure (line 296) | class Structure(table.Database):
    method __init__ (line 307) | def __init__(
    method _validate_table_foreign_keys (line 345) | def _validate_table_foreign_keys(self):
    method _validate_consistent_table_ordering (line 367) | def _validate_consistent_table_ordering(self):
    method get_table (line 383) | def get_table(self, table_name: str) -> table.Table:
    method chains_table (line 397) | def chains_table(self) -> structure_tables.Chains:
    method residues_table (line 402) | def residues_table(self) -> structure_tables.Residues:
    method atoms_table (line 407) | def atoms_table(self) -> structure_tables.Atoms:
    method bonds_table (line 412) | def bonds_table(self) -> structure_tables.Bonds:
    method name (line 417) | def name(self) -> str:
    method release_date (line 421) | def release_date(self) -> datetime.date | None:
    method resolution (line 425) | def resolution(self) -> float | None:
    method structure_method (line 429) | def structure_method(self) -> str | None:
    method bioassembly_data (line 433) | def bioassembly_data(self) -> bioassemblies.BioassemblyData | None:
    method chemical_components_data (line 437) | def chemical_components_data(
    method bonds (line 443) | def bonds(self) -> structure_tables.Bonds:
    method author_naming_scheme (line 447) | def author_naming_scheme(self) -> AuthorNamingScheme:
    method all_residues (line 485) | def all_residues(self) -> AllResidues:
    method label_asym_id_to_entity_id (line 499) | def label_asym_id_to_entity_id(self) -> Mapping[str, str]:
    method chain_entity_id (line 503) | def chain_entity_id(self) -> np.ndarray:
    method chain_entity_desc (line 510) | def chain_entity_desc(self) -> np.ndarray:
    method chain_auth_asym_id (line 517) | def chain_auth_asym_id(self) -> np.ndarray:
    method chain_id (line 524) | def chain_id(self) -> np.ndarray:
    method chain_type (line 529) | def chain_type(self) -> np.ndarray:
    method res_id (line 534) | def res_id(self) -> np.ndarray:
    method res_name (line 538) | def res_name(self) -> np.ndarray:
    method res_auth_seq_id (line 542) | def res_auth_seq_id(self) -> np.ndarray:
    method res_insertion_code (line 549) | def res_insertion_code(self) -> np.ndarray:
    method atom_key (line 556) | def atom_key(self) -> np.ndarray:
    method atom_name (line 560) | def atom_name(self) -> np.ndarray:
    method atom_element (line 564) | def atom_element(self) -> np.ndarray:
    method atom_x (line 568) | def atom_x(self) -> np.ndarray:
    method atom_y (line 572) | def atom_y(self) -> np.ndarray:
    method atom_z (line 576) | def atom_z(self) -> np.ndarray:
    method atom_b_factor (line 580) | def atom_b_factor(self) -> np.ndarray:
    method atom_occupancy (line 584) | def atom_occupancy(self) -> np.ndarray:
    method chain_boundaries (line 588) | def chain_boundaries(self) -> np.ndarray:
    method res_boundaries (line 593) | def res_boundaries(self) -> np.ndarray:
    method present_chains (line 598) | def present_chains(self) -> structure_tables.Chains:
    method present_residues (line 604) | def present_residues(self) -> structure_tables.Residues:
    method unresolved_residues (line 612) | def unresolved_residues(self) -> structure_tables.Residues:
    method __getitem__ (line 621) | def __getitem__(self, field: str) -> Any:
    method __getstate__ (line 628) | def __getstate__(self) -> dict[str, Any]:
    method __repr__ (line 641) | def __repr__(self):
    method num_atoms (line 649) | def num_atoms(self) -> int:
    method num_residues (line 652) | def num_residues(self, *, count_unresolved: bool) -> int:
    method num_chains (line 667) | def num_chains(self) -> int:
    method num_models (line 671) | def num_models(self) -> int:
    method _atom_mask (line 675) | def _atom_mask(self, entities: Set[str]) -> np.ndarray:
    method is_protein_mask (line 686) | def is_protein_mask(self) -> np.ndarray:
    method is_dna_mask (line 691) | def is_dna_mask(self) -> np.ndarray:
    method is_rna_mask (line 696) | def is_rna_mask(self) -> np.ndarray:
    method is_nucleic_mask (line 701) | def is_nucleic_mask(self) -> np.ndarray:
    method is_ligand_mask (line 706) | def is_ligand_mask(self) -> np.ndarray:
    method is_water_mask (line 711) | def is_water_mask(self) -> np.ndarray:
    method iter_atoms (line 715) | def iter_atoms(self) -> Iterator[Mapping[str, Any]]:
    method iter_residues (line 765) | def iter_residues(
    method _iter_atom_ranges (line 795) | def _iter_atom_ranges(
    method _iter_residue_ranges (line 804) | def _iter_residue_ranges(
    method iter_chain_ranges (line 816) | def iter_chain_ranges(self) -> Iterator[tuple[int, int]]:
    method iter_residue_ranges (line 826) | def iter_residue_ranges(self) -> Iterator[tuple[int, int]]:
    method iter_chains (line 836) | def iter_chains(self) -> Iterator[Mapping[str, Any]]:
    method iter_bonds (line 847) | def iter_bonds(self) -> Iterator[Bond]:
    method _apply_atom_index_array (line 888) | def _apply_atom_index_array(
    method group_by_residue (line 932) | def group_by_residue(self) -> Self:
    method group_by_chain (line 948) | def group_by_chain(self) -> Self:
    method with_sorted_chains (line 964) | def with_sorted_chains(self) -> Self:
    method atom_ids (line 981) | def atom_ids(self) -> Sequence[tuple[str, str, None, str]]:
    method order_and_drop_atoms_to_match (line 999) | def order_and_drop_atoms_to_match(
    method copy_and_update (line 1131) | def copy_and_update(
    method _copy_and_update (line 1195) | def _copy_and_update(
    method copy_and_update_coords (line 1247) | def copy_and_update_coords(self, coords: np.ndarray) -> Self:
    method copy_and_update_from_res_arrays (line 1256) | def copy_and_update_from_res_arrays(
    method copy_and_update_globals (line 1322) | def copy_and_update_globals(
    method copy_and_update_atoms (line 1361) | def copy_and_update_atoms(
    method copy_and_update_residues (line 1393) | def copy_and_update_residues(
    method _cascade_delete (line 1416) | def _cascade_delete(
    method filter (line 1471) | def filter(
    method filter_out (line 1627) | def filter_out(self, *args, **kwargs) -> Self:
    method filter_to_entity_type (line 1631) | def filter_to_entity_type(
    method get_stoichiometry (line 1672) | def get_stoichiometry(
    method without_hydrogen (line 1708) | def without_hydrogen(self) -> Self:
    method without_terminal_oxygens (line 1714) | def without_terminal_oxygens(self) -> Self:
    method reset_author_naming_scheme (line 1728) | def reset_author_naming_scheme(self) -> Self:
    method filter_residues (line 1752) | def filter_residues(self, res_mask: np.ndarray) -> Self:
    method filter_coords (line 1766) | def filter_coords(
    method filter_polymers_to_single_atom_per_res (line 1791) | def filter_polymers_to_single_atom_per_res(
    method drop_non_standard_protein_atoms (line 1829) | def drop_non_standard_protein_atoms(self, *, drop_oxt: bool = True) ->...
    method drop_non_standard_atoms (line 1850) | def drop_non_standard_atoms(
    method find_chains_with_unknown_sequence (line 1883) | def find_chains_with_unknown_sequence(self) -> Sequence[str]:
    method add_bonds (line 1898) | def add_bonds(
    method coords (line 1963) | def coords(self) -> np.ndarray:
    method chain_single_letter_sequence (line 1967) | def chain_single_letter_sequence(
    method polymer_auth_asym_id_to_label_asym_id (line 2009) | def polymer_auth_asym_id_to_label_asym_id(
    method polymer_author_chain_single_letter_sequence (line 2079) | def polymer_author_chain_single_letter_sequence(
    method chain_res_name_sequence (line 2123) | def chain_res_name_sequence(
    method fix_non_standard_polymer_res (line 2173) | def fix_non_standard_polymer_res(
    method slice_leading_dims (line 2211) | def slice_leading_dims(self) -> '_LeadingDimSlice':
    method unstack (line 2230) | def unstack(self, axis: int = 0) -> Sequence[Self]:
    method split_by_chain (line 2271) | def split_by_chain(self) -> Sequence[Self]:
    method transform_states_to_chains (line 2283) | def transform_states_to_chains(self) -> Self:
    method merge_chains (line 2307) | def merge_chains(
    method to_res_arrays (line 2454) | def to_res_arrays(
    method to_res_atom_lists (line 2503) | def to_res_atom_lists(
    method reorder_chains (line 2536) | def reorder_chains(self, new_order: Sequence[str]) -> Self:
    method rename_auth_asym_ids (line 2591) | def rename_auth_asym_ids(self, new_id_by_old_id: Mapping[str, str]) ->...
    method rename_chain_ids (line 2614) | def rename_chain_ids(self, new_id_by_old_id: Mapping[str, str]) -> Self:
    method chains (line 2669) | def chains(self) -> tuple[str, ...]:
    method rename_res_name (line 2673) | def rename_res_name(
    method remap_res_id (line 2714) | def remap_res_id(self, res_id_map: Mapping[str, Mapping[int, int]]) ->...
    method rename_chains_to_match (line 2769) | def rename_chains_to_match(
    method _apply_bioassembly_transform (line 2832) | def _apply_bioassembly_transform(
    method generate_bioassembly (line 2853) | def generate_bioassembly(self, assembly_id: str | None = None) -> Self:
    method _to_mmcif_header (line 2909) | def _to_mmcif_header(self) -> Mapping[str, Sequence[str]]:
    method to_mmcif_dict (line 2942) | def to_mmcif_dict(
    method to_mmcif (line 2961) | def to_mmcif(
  class _LeadingDimSlice (line 2975) | class _LeadingDimSlice:
    method __init__ (line 2985) | def __init__(self, struc: Structure):
    method __getitem__ (line 2988) | def __getitem__(self, *args, **kwargs) -> Structure:
  function stack (line 3005) | def stack(strucs: Sequence[Structure], axis: int = 0) -> Structure:
  function _assign_unique_chain_ids (line 3062) | def _assign_unique_chain_ids(
  function concat (line 3096) | def concat(
  function multichain_residue_index (line 3210) | def multichain_residue_index(
  function make_empty_structure (line 3247) | def make_empty_structure() -> Structure:
  function enumerate_residues (line 3257) | def enumerate_residues(

FILE: src/alphafold3/structure/structure_tables.py
  function _residue_name_to_record_name (line 34) | def _residue_name_to_record_name(
  class AuthorNamingScheme (line 49) | class AuthorNamingScheme:
  function _default (line 69) | def _default(
  class Atoms (line 78) | class Atoms(table.Table):
    method __post_init__ (line 98) | def __post_init__(self):
    method make_empty (line 111) | def make_empty(cls) -> Self:
    method from_defaults (line 126) | def from_defaults(
    method get_value_by_index (line 157) | def get_value_by_index(
    method copy_and_update_coords (line 165) | def copy_and_update_coords(self, coords: np.ndarray) -> Self:
    method shape (line 179) | def shape(self) -> tuple[int, ...]:
    method ndim (line 183) | def ndim(self) -> int:
    method num_models (line 187) | def num_models(self) -> int:
  class Residues (line 203) | class Residues(table.Table):
    method make_empty (line 213) | def make_empty(cls) -> Self:
    method from_defaults (line 224) | def from_defaults(
  class Chains (line 249) | class Chains(table.Table):
    method make_empty (line 259) | def make_empty(cls) -> Self:
    method from_defaults (line 270) | def from_defaults(
  function to_mmcif_sequence_and_entity_tables (line 297) | def to_mmcif_sequence_and_entity_tables(
  function to_mmcif_atom_site_and_bonds_table (line 411) | def to_mmcif_atom_site_and_bonds_table(
  function _flatten_author_naming_scheme_table (line 523) | def _flatten_author_naming_scheme_table(
  function tables_from_atom_arrays (line 557) | def tables_from_atom_arrays(

FILE: src/alphafold3/structure/table.py
  class RowLookup (line 38) | class RowLookup(Protocol):
    method get_row_by_key (line 40) | def get_row_by_key(
  class Table (line 49) | class Table:
    method __post_init__ (line 67) | def __post_init__(self):
    method __getstate__ (line 82) | def __getstate__(self) -> dict[str, Any]:
    method index_by_key (line 92) | def index_by_key(self) -> np.ndarray:
    method columns (line 105) | def columns(self) -> tuple[str, ...]:
    method items (line 110) | def items(self) -> Mapping[str, np.ndarray]:
    method size (line 115) | def size(self) -> int:
    method __len__ (line 119) | def __len__(self) -> int:
    method get_column (line 122) | def get_column(self, column_name: str) -> np.ndarray:
    method apply_array (line 127) | def apply_array(self, arr: np.ndarray) -> Self:
    method apply_index (line 137) | def apply_index(self, index_arr: np.ndarray) -> Self:
    method apply_array_to_column (line 146) | def apply_array_to_column(
    method get_value_by_index (line 157) | def get_value_by_index(self, column_name: str, index: int) -> Any:
    method get_value_by_key (line 160) | def get_value_by_key(
    method __getitem__ (line 169) | def __getitem__(self, key: str) -> np.ndarray:
    method __getitem__ (line 173) | def __getitem__(self, key: np.ndarray) -> 'Table':
    method __getitem__ (line 177) | def __getitem__(self, key: tuple[str, int | np.integer]) -> TableEntry:
    method __getitem__ (line 181) | def __getitem__(self, key: tuple[str, np.ndarray]) -> np.ndarray:
    method __getitem__ (line 184) | def __getitem__(self, key):
    method get_row_by_key (line 201) | def get_row_by_key(
    method get_row_by_index (line 211) | def get_row_by_index(
    method iterrows (line 225) | def iterrows(
    method with_column_names (line 262) | def with_column_names(
    method make_filter_mask (line 268) | def make_filter_mask(
    method filter (line 333) | def filter(
    method _validate_keys_are_column_names (line 388) | def _validate_keys_are_column_names(self, keys: Collection[str]) -> None:
    method copy_and_update (line 393) | def copy_and_update(self, **new_column_by_column_name: np.ndarray) -> ...
    method copy_and_remap (line 405) | def copy_and_remap(
  class RenamedTableView (line 433) | class RenamedTableView:
    method __init__ (line 436) | def __init__(self, table: Table, column_name_map: Mapping[str, str]):
    method get_row_by_key (line 440) | def get_row_by_key(
  class Database (line 454) | class Database(abc.ABC):
    method tables (line 459) | def tables(self) -> Collection[str]:
    method get_table (line 463) | def get_table(self, table_name: str) -> Table:
    method foreign_keys (line 468) | def foreign_keys(self) -> Mapping[str, Collection[tuple[str, str]]]:
    method copy_and_update (line 479) | def copy_and_update(
  function table_dependency_order (line 486) | def table_dependency_order(db: Database) -> Iterable[str]:
  function concat_databases (line 505) | def concat_databases(dbs: Sequence[_DatabaseT]) -> _DatabaseT:

FILE: src/alphafold3/structure/test_utils.py
  class StructureTestCase (line 22) | class StructureTestCase(parameterized.TestCase):
    method assertAuthorNamingSchemeEqual (line 25) | def assertAuthorNamingSchemeEqual(self, ans1, ans2):  # pylint: disabl...
    method assertAllResiduesEqual (line 38) | def assertAllResiduesEqual(self, all_res1, all_res2):  # pylint: disab...
    method assertBioassemblyDataEqual (line 48) | def assertBioassemblyDataEqual(self, data1, data2):  # pylint: disable...
    method assertChemicalComponentsDataEqual (line 55) | def assertChemicalComponentsDataEqual(  # pylint: disable=invalid-name
    method assertBondsEqual (line 88) | def assertBondsEqual(self, bonds1, bonds2, atom_key1, atom_key2):  # p...
    method assertStructuresEqual (line 104) | def assertStructuresEqual(  # pylint: disable=invalid-name