Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,48 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+.msc filter=lfs diff=lfs merge=lfs -text
+flax_model/alphafold3/_data/libcifpp/components.cif filter=lfs diff=lfs merge=lfs -text
+flax_model/alphafold3/_tools/hmmer/bin/alimask filter=lfs diff=lfs merge=lfs -text
+flax_model/alphafold3/_tools/hmmer/bin/easel filter=lfs diff=lfs merge=lfs -text
+flax_model/alphafold3/_tools/hmmer/bin/esl-afetch filter=lfs diff=lfs merge=lfs -text
+flax_model/alphafold3/_tools/hmmer/bin/esl-alimanip filter=lfs diff=lfs merge=lfs -text
+flax_model/alphafold3/_tools/hmmer/bin/esl-alimap filter=lfs diff=lfs merge=lfs -text
+flax_model/alphafold3/_tools/hmmer/bin/esl-alimask filter=lfs diff=lfs merge=lfs -text
+flax_model/alphafold3/_tools/hmmer/bin/esl-alimerge filter=lfs diff=lfs merge=lfs -text
+flax_model/alphafold3/_tools/hmmer/bin/esl-alipid filter=lfs diff=lfs merge=lfs -text
+flax_model/alphafold3/_tools/hmmer/bin/esl-alirev filter=lfs diff=lfs merge=lfs -text
+flax_model/alphafold3/_tools/hmmer/bin/esl-alistat filter=lfs diff=lfs merge=lfs -text
+flax_model/alphafold3/_tools/hmmer/bin/esl-compalign filter=lfs diff=lfs merge=lfs -text
+flax_model/alphafold3/_tools/hmmer/bin/esl-compstruct filter=lfs diff=lfs merge=lfs -text
+flax_model/alphafold3/_tools/hmmer/bin/esl-construct filter=lfs diff=lfs merge=lfs -text
+flax_model/alphafold3/_tools/hmmer/bin/esl-histplot filter=lfs diff=lfs merge=lfs -text
+flax_model/alphafold3/_tools/hmmer/bin/esl-mask filter=lfs diff=lfs merge=lfs -text
+flax_model/alphafold3/_tools/hmmer/bin/esl-mixdchlet filter=lfs diff=lfs merge=lfs -text
+flax_model/alphafold3/_tools/hmmer/bin/esl-reformat filter=lfs diff=lfs merge=lfs -text
+flax_model/alphafold3/_tools/hmmer/bin/esl-seqrange filter=lfs diff=lfs merge=lfs -text
+flax_model/alphafold3/_tools/hmmer/bin/esl-seqstat filter=lfs diff=lfs merge=lfs -text
+flax_model/alphafold3/_tools/hmmer/bin/esl-sfetch filter=lfs diff=lfs merge=lfs -text
+flax_model/alphafold3/_tools/hmmer/bin/esl-shuffle filter=lfs diff=lfs merge=lfs -text
+flax_model/alphafold3/_tools/hmmer/bin/esl-ssdraw filter=lfs diff=lfs merge=lfs -text
+flax_model/alphafold3/_tools/hmmer/bin/esl-translate filter=lfs diff=lfs merge=lfs -text
+flax_model/alphafold3/_tools/hmmer/bin/esl-weight filter=lfs diff=lfs merge=lfs -text
+flax_model/alphafold3/_tools/hmmer/bin/hmmalign filter=lfs diff=lfs merge=lfs -text
+flax_model/alphafold3/_tools/hmmer/bin/hmmbuild filter=lfs diff=lfs merge=lfs -text
+flax_model/alphafold3/_tools/hmmer/bin/hmmconvert filter=lfs diff=lfs merge=lfs -text
+flax_model/alphafold3/_tools/hmmer/bin/hmmemit filter=lfs diff=lfs merge=lfs -text
+flax_model/alphafold3/_tools/hmmer/bin/hmmfetch filter=lfs diff=lfs merge=lfs -text
+flax_model/alphafold3/_tools/hmmer/bin/hmmlogo filter=lfs diff=lfs merge=lfs -text
+flax_model/alphafold3/_tools/hmmer/bin/hmmpgmd filter=lfs diff=lfs merge=lfs -text
+flax_model/alphafold3/_tools/hmmer/bin/hmmpgmd_shard filter=lfs diff=lfs merge=lfs -text
+flax_model/alphafold3/_tools/hmmer/bin/hmmpress filter=lfs diff=lfs merge=lfs -text
+flax_model/alphafold3/_tools/hmmer/bin/hmmscan filter=lfs diff=lfs merge=lfs -text
+flax_model/alphafold3/_tools/hmmer/bin/hmmsearch filter=lfs diff=lfs merge=lfs -text
+flax_model/alphafold3/_tools/hmmer/bin/hmmsim filter=lfs diff=lfs merge=lfs -text
+flax_model/alphafold3/_tools/hmmer/bin/hmmstat filter=lfs diff=lfs merge=lfs -text
+flax_model/alphafold3/_tools/hmmer/bin/jackhmmer filter=lfs diff=lfs merge=lfs -text
+flax_model/alphafold3/_tools/hmmer/bin/makehmmerdb filter=lfs diff=lfs merge=lfs -text
+flax_model/alphafold3/_tools/hmmer/bin/nhmmer filter=lfs diff=lfs merge=lfs -text
+flax_model/alphafold3/_tools/hmmer/bin/nhmmscan filter=lfs diff=lfs merge=lfs -text
+flax_model/alphafold3/_tools/hmmer/bin/phmmer filter=lfs diff=lfs merge=lfs -text
+flax_model/alphafold3/cpp.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text

.msc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6129f311c9362dd58261a8352929e2f2dbeed73bbe7364170648ca396cb152ed
+size 196183

.mv

@@ -0,0 +1 @@
+Revision:master,CreatedAt:1784688613

LICENSE

@@ -0,0 +1,10 @@
+AlphaFold3 source files in this split retain the license headers from the
+upstream AlphaFold 3 implementation integrated in OneScience.
+
+The copied AlphaFold3 source headers state that AlphaFold 3 source code is
+licensed under CC BY-NC-SA 4.0 and refer to:
+
+https://creativecommons.org/licenses/by-nc-sa/4.0/
+
+Model parameters are not included in this repository and are subject to their
+own terms of use.

README.md

@@ -0,0 +1,277 @@
+---
+license: cc-by-nc-sa-4.0
+tasks:
+  - protein-complex-structure-prediction
+frameworks:
+  - jax
+language:
+  - en
+  - zh
+tags:
+  - OneScience
+  - Life Sciences
+  - Protein Structure Prediction
+  - Biomolecular Interactions
+  - Complex Structure Prediction
+  - AlphaFold3
+datasets:
+  - OneScience/AlphaFold3_dataset
+---
+
+<p align="center">
+  <strong>
+    <span style="font-size: 30px;">AlphaFold3</span>
+  </strong>
+</p>
+
+# Model Introduction
+
+AlphaFold3 is a biomolecular structure prediction model proposed by Google DeepMind and Isomorphic Labs. It can predict the three-dimensional structures and interactions of molecules and their complexes, including proteins, DNA, RNA, and small-molecule ligands.
+
+Paper: Accurate structure prediction of biomolecular interactions with AlphaFold 3  
+https://www.nature.com/articles/s41586-024-07487-w
+
+# Model Description
+
+AlphaFold3 uses Pairformer and diffusion models to predict biomolecular complex structures. This model package provides a JAX / Flax inference project and data search scripts, and is released together with the ModelScope dataset `OneScience/AlphaFold3_dataset`.
+
+# Applicable Scenarios
+
+| Scenario | Description |
+| :---: | :--- |
+| Direct inference with existing features | Input an AlphaFold3 JSON containing features such as MSA / template, and output structure prediction results |
+| Protein structure prediction | Input a protein sequence, generate features together with search databases, and predict the structure |
+| Biomolecular complex modeling | Input multi-component objects such as proteins, DNA, RNA, and ligands, and predict the spatial conformation of the complex |
+| Data search workflow verification | Use Jackhmmer / Nhmmer or MMseqs workflows to check database paths and search tool connectivity |
+| ModelScope / OneCode runtime | After downloading the model project and complete dataset, quickly verify script connectivity in a biology-domain runtime environment |
+
+
+
+# Usage Instructions
+
+## 1. OneCode Usage
+
+You can experience intelligent one-click AI4S programming through the OneCode online environment:
+
+[Click to experience intelligent one-click AI4S programming](https://web-2069360198568017922-iaaj.ksai.scnet.cn:58043/home)
+
+## 2. Manual Installation and Usage
+
+**Hardware Requirements**
+
+- GPU or DCU runtime is recommended.
+- CPU can be used for import checks and small-configuration connectivity verification, but full training and inference are slow.
+- DCU users need to install DTK in advance. DTK 25.04.2 or later is recommended, or the OneScience-recommended version matching the current cluster.
+
+
+
+
+
+**Environment Check**
+
+- NVIDIA GPU:
+
+```bash
+nvidia-smi
+```
+
+- Hygon DCU:
+
+```bash
+hy-smi
+```
+
+### Download the Model Package
+
+```bash
+modelscope download --model OneScience/AlphaFold3 --local_dir ./AlphaFold3
+cd AlphaFold3
+```
+
+### Install the Runtime Environment
+
+**DCU Environment**
+
+```bash
+# First activate DTK and Conda
+conda create -n onescience311 python=3.11 -y
+conda activate onescience311
+# Supports uv installation
+pip install onescience[bio-dcu] -i http://mirrors.onescience.ai:3141/pypi/simple/  --trusted-host mirrors.onescience.ai
+```
+
+After installation, return to the model package directory:
+
+```bash
+cd ./AlphaFold3
+```
+
+If the current environment has not yet built the AlphaFold3 C++ extension and runtime data files, execute:
+
+```bash
+python -m onescience.flax_model.alphafold3.build_extension
+python -m onescience.flax_models.alphafold3.build_data
+```
+
+### Training and Inference Data Introduction
+
+The OneScience community has uploaded the complete data required for AlphaFold3 inference and data search to ModelScope: [OneScience/AlphaFold3_dataset](https://modelscope.cn/datasets/OneScience/AlphaFold3_dataset). This model package does not include a training entry point; this dataset is mainly used for MSA / template feature construction and pre-inference data search.
+
+```bash
+modelscope download --dataset OneScience/AlphaFold3_dataset --local_dir ./data/alphafold3
+```
+### Training Weights
+
+Weights will be uploaded soon.
+
+### Prepare Weights
+
+Place the AlphaFold3 model weights in the following directory, or specify them through an environment variable:
+
+```text
+weight/
+  AlphaFold3/
+    ...
+```
+
+The default lookup order is:
+
+- `ALPHAFOLD3_MODEL_DIR`
+- `${ONESCIENCE_MODELS_DIR}/AlphaFold3`
+- `weight/AlphaFold3`
+
+Example:
+
+```bash
+export ALPHAFOLD3_MODEL_DIR=/path/to/AlphaFold3
+```
+
+### Direct Inference
+
+When the input JSON already contains features such as MSA and template, you can run directly:
+
+```bash
+bash scripts/infer.sh
+```
+
+Equivalent Python command example:
+
+```bash
+python scripts/run_alphafold.py \
+  --json_path inputs/7r6r_data.json \
+  --model_dir weight/AlphaFold3 \
+  --output_dir outputs \
+  --run_data_pipeline=false \
+  --flash_attention_implementation=triton
+```
+
+The output will be written to `outputs/`, including the best structure, structure results for different seeds / samples, the ranking score CSV, and a copy of the input JSON.
+
+### Jackhmmer / Nhmmer Data Search
+
+When the input JSON contains only sequences and requires local database search, use:
+
+```bash
+bash scripts/infer_jackhmmer.sh
+```
+
+Common environment variables:
+
+```bash
+export ALPHAFOLD3_DATASET_ROOT=/path/to/alphafold3
+export ALPHAFOLD3_MODEL_DIR=/path/to/AlphaFold3
+export ALPHAFOLD3_JSON_PATH=inputs/t1119_search.json
+export ALPHAFOLD3_OUTPUT_DIR=outputs
+export ALPHAFOLD3_RUN_INFERENCE=false
+```
+
+Here, `ALPHAFOLD3_DATASET_ROOT` is expected by default to contain database directories such as `public_databases/`, `jackhmmer_split/`, and `mmseqsDB/`.
+
+### MMseqs Data Search
+
+If the runtime environment provides the MMseqs program and MMseqs database, use:
+
+```bash
+bash scripts/infer_mmseqs.sh
+```
+
+Common environment variables:
+
+```bash
+export ALPHAFOLD3_MMSEQS_HOME=/path/to/mmseqs
+export ALPHAFOLD3_DATASET_ROOT=/path/to/alphafold3
+export ALPHAFOLD3_MMSEQS_DB_DIR=/path/to/alphafold3/mmseqsDB
+export ALPHAFOLD3_RUN_INFERENCE=false
+```
+
+To continue inference after searching, set `ALPHAFOLD3_RUN_INFERENCE` to `true` and make sure the weight directory is available.
+
+# Data Format
+
+AlphaFold3 input uses JSON format. The basic structure is as follows:
+
+```json
+{
+  "dialect": "alphafold3",
+  "version": 1,
+  "name": "example",
+  "sequences": [
+    {
+      "protein": {
+        "id": "A",
+        "sequence": "..."
+      }
+    }
+  ],
+  "modelSeeds": [100],
+  "bondedAtomPairs": null,
+  "userCCD": null
+}
+```
+
+This repository provides two examples:
+
+- `inputs/7r6r_data.json`: Contains information such as sequence, MSA, and template, and is suitable for direct inference.
+- `inputs/t1119_search.json`: Contains only sequence and is suitable for data search workflow verification.
+
+The complete ModelScope dataset `OneScience/AlphaFold3_dataset` is recommended to be downloaded to `data/alphafold3/` under the model package. The relative structure read by the data search workflow by default is as follows:
+
+```text
+data/
+  alphafold3/
+    public_databases/
+      mmcif_files/
+      pdb_seqres_2022_09_28.fasta
+      ...
+    jackhmmer_split/
+      bfd-first_non_consensus_sequences.fasta@64
+      mgy_clusters_2022_05.fa@512
+      uniprot_cluster_annot_2021_04.fa@256
+      uniref90_2022_05.fa@128
+    mmseqsDB/
+      small_bfd_db
+      mgnify_db
+      uniprot_cluster_annot_db
+      uniref90_db
+```
+
+# Verification
+
+Static import check:
+
+```bash
+python tests/check_import_boundaries.py
+```
+
+# Official OneScience Information
+
+| Platform | OneScience Main Repository | Skills Repository |
+| --- | --- | --- |
+| Gitee | https://gitee.com/onescience-ai/onescience | https://gitee.com/onescience-ai/oneskills |
+| GitHub | https://github.com/onescience-ai/OneScience | https://github.com/onescience-ai/oneskills |
+
+# Citations and License
+
+- This repository is based on the AlphaFold3 open-source model and provides DCU adaptation.
+- AlphaFold3 source code uses the CC BY-NC-SA 4.0 license; model parameters are subject to separate terms of use.
+- For scientific research, cite the original paper: [Accurate structure prediction of biomolecular interactions with AlphaFold 3](https://www.nature.com/articles/s41586-024-07487-w).

configuration.json

@@ -0,0 +1 @@
+{"framework":"JAX","task":"protein-structure-prediction"}

data/README.md

@@ -0,0 +1,14 @@
+This model repository does not upload the AlphaFold3 dataset payload.
+
+Download the required dataset separately:
+
+```bash
+modelscope download --dataset OneScience/AlphaFold3_dataset
+```
+
+Then link the dataset package data directory into this model package:
+
+```bash
+mkdir -p data
+ln -s /path/to/AlphaFold3_dataset/data data/alphafold3_dataset
+```

flax_model/__init__.py

@@ -0,0 +1 @@
+"""Local flax model namespace for the split AlphaFold3 project."""

flax_model/alphafold3/CMakeLists.txt

@@ -0,0 +1,161 @@
+# Copyright 2024 DeepMind Technologies Limited
+#
+# AlphaFold 3 source code is licensed under CC BY-NC-SA 4.0. To view a copy of
+# this license, visit https://creativecommons.org/licenses/by-nc-sa/4.0/
+#
+# To request access to the AlphaFold 3 model parameters, follow the process set
+# out at https://github.com/google-deepmind/alphafold3. You may only use these
+# if received directly from Google. Use is subject to terms of use available at
+# https://github.com/google-deepmind/alphafold3/blob/main/WEIGHTS_TERMS_OF_USE.md
+
+cmake_minimum_required(VERSION 3.24)
+project(
+  "${SKBUILD_PROJECT_NAME}"
+  LANGUAGES CXX
+  VERSION "${SKBUILD_PROJECT_VERSION}")
+
+include(FetchContent)
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_POSITION_INDEPENDENT_CODE TRUE)
+set(ABSL_PROPAGATE_CXX_STD ON)
+
+# Remove support for scan deps, which is only useful when using C++ modules.
+unset(CMAKE_CXX_SCANDEP_SOURCE)
+
+set(ENV{GIT_CONFIG_PARAMETERS} "'init.defaultRefFormat=files'")
+
+if(DEFINED ENV{ALPHAFOLD3_DEP_DIR})
+   set(DEP_BASE_DIR "$ENV{ALPHAFOLD3_DEP_DIR}")
+endif()
+
+function(declare_af3_dependency dep_name local_path_env repo_env tag_env)
+  if(DEFINED ENV{${local_path_env}} AND EXISTS "$ENV{${local_path_env}}")
+    message(STATUS "Using local dependency for ${dep_name}: $ENV{${local_path_env}}")
+    FetchContent_Declare(
+      ${dep_name}
+      SOURCE_DIR $ENV{${local_path_env}}
+      ${ARGN})
+  else()
+    message(STATUS "Fetching remote dependency for ${dep_name}: $ENV{${repo_env}} @ $ENV{${tag_env}}")
+    FetchContent_Declare(
+      ${dep_name}
+      GIT_REPOSITORY $ENV{${repo_env}}
+      GIT_TAG $ENV{${tag_env}}
+      ${ARGN})
+  endif()
+endfunction()
+
+
+declare_af3_dependency(
+  abseil-cpp
+  ABSEIL_LOCAL_PATH
+  ABSEIL_REPO
+  ABSEIL_TAG
+  EXCLUDE_FROM_ALL)
+
+declare_af3_dependency(
+  pybind11
+  PYBIND11_LOCAL_PATH
+  PYBIND11_REPO
+  PYBIND11_TAG
+  EXCLUDE_FROM_ALL)
+
+declare_af3_dependency(
+  pybind11_abseil
+  PYBIND11_ABSEIL_LOCAL_PATH
+  PYBIND11_ABSEIL_REPO
+  PYBIND11_ABSEIL_TAG
+  EXCLUDE_FROM_ALL)
+
+declare_af3_dependency(
+  cifpp
+  CIFPP_LOCAL_PATH
+  CIFPP_REPO
+  CIFPP_TAG)
+
+declare_af3_dependency(
+  dssp
+  DSSP_LOCAL_PATH
+  DSSP_REPO
+  DSSP_TAG
+  EXCLUDE_FROM_ALL)
+
+if(DEFINED ENV{ALPHAFOLD3_INSTALL_PREFIX})
+    set(CMAKE_INSTALL_PREFIX $ENV{ALPHAFOLD3_INSTALL_PREFIX} CACHE PATH "Install prefix" FORCE)
+    message(STATUS "Setting install prefix to AlphaFold3 package directory: $ENV{ALPHAFOLD3_INSTALL_PREFIX}")
+elseif(DEFINED ENV{CONDA_PREFIX})
+    set(CMAKE_INSTALL_PREFIX $ENV{CONDA_PREFIX} CACHE PATH "Install prefix" FORCE)
+    message(STATUS "Setting install prefix to conda environment: $ENV{CONDA_PREFIX}")
+endif()
+
+if(DEFINED ENV{ALPHAFOLD3_CIFPP_DATA_DIR})
+    set(CIFPP_DATA_DIR "$ENV{ALPHAFOLD3_CIFPP_DATA_DIR}" CACHE PATH "CIFPP data directory" FORCE)
+    message(STATUS "Setting CIFPP_DATA_DIR to ${CIFPP_DATA_DIR}")
+elseif(DEFINED ENV{CONDA_PREFIX})
+    execute_process(
+        COMMAND python -c "import site; print(site.getsitepackages()[0])"
+        OUTPUT_VARIABLE PYTHON_SITE_PACKAGES
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+        ERROR_QUIET
+    )
+
+    if(PYTHON_SITE_PACKAGES)
+        set(CIFPP_DATA_DIR "${PYTHON_SITE_PACKAGES}/share/libcifpp" CACHE PATH "CIFPP data directory" FORCE)
+        message(STATUS "Setting CIFPP_DATA_DIR to Python site-packages: ${CIFPP_DATA_DIR}")
+    endif()
+endif()
+
+FetchContent_MakeAvailable(pybind11 abseil-cpp pybind11_abseil cifpp dssp)
+
+find_package(
+  Python3
+  COMPONENTS Interpreter Development NumPy
+  REQUIRED)
+
+message(STATUS "AF3 Python3_EXECUTABLE=${Python3_EXECUTABLE}")
+message(STATUS "AF3 Python3_VERSION=${Python3_VERSION}")
+message(STATUS "AF3 Python3_INCLUDE_DIRS=${Python3_INCLUDE_DIRS}")
+message(STATUS "AF3 Python3_SITELIB=${Python3_SITELIB}")
+message(STATUS "AF3 Python3_SITEARCH=${Python3_SITEARCH}")
+message(STATUS "AF3 Python3_NumPy_INCLUDE_DIRS=${Python3_NumPy_INCLUDE_DIRS}")
+
+include_directories(${Python3_INCLUDE_DIRS})
+include_directories(${Python3_NumPy_INCLUDE_DIRS})
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/..)
+
+# Only compile AF3's own C++ sources.
+file(GLOB_RECURSE cpp_srcs ${CMAKE_CURRENT_SOURCE_DIR}/*.cc)
+# Drop any third-party / build-time sources such as benchmarks/tests/examples.
+list(FILTER cpp_srcs EXCLUDE REGEX ".*/_deps/.*")
+list(FILTER cpp_srcs EXCLUDE REGEX ".*/mirror_deps/.*")
+list(FILTER cpp_srcs EXCLUDE REGEX ".*/CMake/install_test_project/.*")
+list(FILTER cpp_srcs EXCLUDE REGEX "${CMAKE_CURRENT_SOURCE_DIR}/test/.*")
+#list(FILTER cpp_srcs EXCLUDE REGEX ".*\\(_test\\|_main\\|_benchmark\\).cc$")
+list(FILTER cpp_srcs EXCLUDE REGEX ".*(_test|_main|_benchmark)\\.cc$")
+message(STATUS "AF3 cpp_srcs after filter: ${cpp_srcs}")
+
+add_compile_definitions(NPY_NO_DEPRECATED_API=NPY_1_7_API_VERSION)
+
+pybind11_add_module(cpp ${cpp_srcs})
+
+
+
+target_link_libraries(
+  cpp
+  PRIVATE absl::check
+          absl::flat_hash_map
+          absl::node_hash_map
+          absl::strings
+          absl::status
+          absl::statusor
+          absl::log
+          pybind11_abseil::absl_casters
+          Python3::NumPy
+          dssp::dssp
+          cifpp::cifpp)
+
+target_compile_definitions(cpp PRIVATE VERSION_INFO=${PROJECT_VERSION})
+install(TARGETS cpp LIBRARY DESTINATION .)
+
+

flax_model/alphafold3/README.md

@@ -0,0 +1,81 @@
+# AlphaFold 3 Integration for OneScience
+
+This is the AlphaFold 3 implementation integrated into the OneScience framework as a submodule.
+
+## Overview
+
+AlphaFold 3 is a state-of-the-art machine learning model for predicting protein structure, developed by DeepMind. This submodule integrates AlphaFold 3 into the OneScience framework, allowing it to be used as part of larger scientific computing workflows.
+
+## Installation
+
+### As Part of OneScience
+
+The recommended way to install alphafold3 is as part of the complete OneScience package:
+
+```bash
+# Install OneScience with alphafold3 support
+
+# install jackhmmer
+# mkdir ~/hmmer_build ~/hmmer
+# wget http://eddylab.org/software/hmmer/hmmer-3.4.tar.gz --directory-prefix ~/hmmer_build
+# cd ~/hmmer_build &&  tar zxf hmmer-3.4.tar.gz && rm hmmer-3.4.tar.gz
+# patch -p0 < jackhmmer_seq_limit.patch
+# cd ~/hmmer-3.4
+# ./configure --prefix ~/hmmer
+# make -j && make install && cd ./easel && make install
+# rm -R ~/hmmer_build
+
+# # install extension
+# pip install .[bio] -c constraints.txt
+# cp -r /public/onestore/onedatasets/alphafold3/_dep xxx/
+# export ALPHAFOLD3_DEP_DIR=/public/onestore/onedatasets/alphafold3/_dep
+# cd src/onescience/flax_models/alphafold3/
+# python build_extension.py
+
+# optional create mmseqs2 database (please contact ai4s@sugon.com for mmseqs2 program)
+export mmfasta=/root/public_databases
+cd /root/public_databases && mkdir mmseqsDB
+export mmdb=/root/public_databases/mmseqsDB
+export CUDA_VISIBLE_DEVICES=0
+mmseqs createdb $mmfasta/bfd-first_non_consensus_sequences.fasta $mmdb/small_bfd_db --gpu 1 --threads 32 --createdb-mode 2
+mmseqs createdb $mmfasta/mgy_clusters_2022_05.fa $mmdb/mgnify_db --gpu 1 --threads 32 --createdb-mode 2
+mmseqs createdb $mmfasta/uniprot_all_2021_04.fa $mmdb/uniprot_cluster_annot_db --gpu 1 --threads 32 --createdb-mode 2
+mmseqs createdb $mmfasta/uniref90_2022_05.fa $mmdb/uniref90_db --gpu 1 --threads 32 --createdb-mode 2
+```
+
+## Usage
+
+```python
+# Import alphafold3 as part of onescience
+import flax_model.alphafold3 as af3
+
+# Access alphafold3 components
+from flax_model.alphafold3 import structure, model, data
+
+# Use alphafold3 functionality
+print(f"AlphaFold3 version: {af3.__version__}")
+```
+
+## Requirements
+
+- Python 3.11+
+- JAX with CUDA support (optional, for GPU acceleration)
+- CMake 3.28+ (for building C++ extensions)
+- Additional dependencies listed in pyproject.toml
+
+## License
+
+This code is licensed under CC BY-NC-SA 4.0. See the original AlphaFold 3 repository for more details on usage restrictions and licensing terms.
+
+## Citation
+
+If you use this code in your research, please cite the AlphaFold 3 paper:
+
+```
+Abramson, J., Adler, J., Dunger, J. et al. Accurate structure prediction of biomolecular interactions with AlphaFold 3. Nature 630, 493�?00 (2024).
+```
+
+## Links
+
+- [Original AlphaFold 3 Repository](https://github.com/google-deepmind/alphafold3)
+- [AlphaFold 3 Paper](https://www.nature.com/articles/s41586-024-07487-w) 

flax_model/alphafold3/__init__.py

@@ -0,0 +1,26 @@
+
+
+"""An implementation of the inference pipeline of AlphaFold 3."""
+from importlib import resources
+from pathlib import Path
+import os
+import warnings
+
+
+def _data_artifacts_exist() -> bool:
+    try:
+        root = Path(
+            resources.files(__name__ + ".constants.converters")
+        )
+    except Exception:
+        return False
+    return (root / "ccd.pickle").exists() and (root / "chemical_component_sets.pickle").exists()
+
+
+if not _data_artifacts_exist():
+    warnings.warn(
+        "AlphaFold3 data files (ccd.pickle, chemical_component_sets.pickle) are missing.\n"
+        "Please run the following command once to build local artifacts:\n\n"
+        "    python -m flax_model.alphafold3.build_extension\n",
+        stacklevel=1,
+    )

flax_model/alphafold3/_build.py

@@ -0,0 +1,649 @@
+import json
+import os
+import shutil
+import subprocess
+import sys
+import sysconfig
+import tarfile
+import tempfile
+import urllib.request
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[2]
+MIRROR_CONFIG_PATH = ROOT / "docs" / "af3_dependency_mirrors.template.json"
+AF3_DIR = Path(__file__).resolve().parent
+CONVERTERS_DIR = AF3_DIR / "constants" / "converters"
+TMP_ROOT = Path(os.environ.get("ALPHAFOLD3_TMP_ROOT", tempfile.gettempdir())).resolve() / "alphafold3_split_af3"
+BUILD_DIR = TMP_ROOT / "build"
+REMOTE_DEPS_DIR = TMP_ROOT / "mirror_deps"
+HMMER_INSTALL_DIR = AF3_DIR / "_tools" / "hmmer"
+HMMER_BIN_DIR = HMMER_INSTALL_DIR / "bin"
+HMMER_PATCH_PATH = AF3_DIR / "jackhmmer_seq_limit.patch"
+HMMER_SOURCE_URL = "https://gitee.com/zhang-yuqi-sudo/hmmer-github/releases/download/hmmer-3.4/hmmer-3.4.tar.gz"
+HMMER_ARCHIVE_NAME = "hmmer-3.4.tar.gz"
+HMMER_SOURCE_DIRNAME = "hmmer-3.4"
+HMMER_BINARIES = ("jackhmmer", "nhmmer", "hmmalign", "hmmsearch", "hmmbuild")
+HMMER_BUILD_ROOT = TMP_ROOT / "hmmer_build"
+HMMER_BUILD_DIR = HMMER_BUILD_ROOT / HMMER_SOURCE_DIRNAME
+HMMER_ARCHIVE_PATH = HMMER_BUILD_ROOT / HMMER_ARCHIVE_NAME
+HMMER_PATCH_MARKER = HMMER_BUILD_ROOT / ".patch_applied"
+HMMER_BUILD_MARKER = HMMER_INSTALL_DIR / ".built"
+DATA_FILES = (
+    CONVERTERS_DIR / "ccd.pickle",
+    CONVERTERS_DIR / "chemical_component_sets.pickle",
+)
+LIB_PATTERNS = ("cpp*.so", "cpp*.pyd", "cpp*.dll", "cpp*.dylib")
+
+TOP_LEVEL_MIRROR_MAP = {
+    "abseil-cpp": "ABSEIL",
+    "pybind11": "PYBIND11",
+    "pybind11_abseil": "PYBIND11_ABSEIL",
+    "libcifpp": "CIFPP",
+    "dssp": "DSSP",
+}
+
+DEFAULT_DOWNSTREAM_TAGS = {
+    "boost-regex": "boost-1.87.0",
+    "libmcfp": "v1.4.2",
+    "catch2": "v3.4.0",
+}
+
+PREPARED_ENV: dict[str, str] | None = None
+PREPARED_DEP_DIR: Path | None = None
+PREPARED_REMOTE = False
+
+
+class AF3BuildError(RuntimeError):
+    pass
+
+
+def _env_flag(name: str, default: str = "auto") -> str:
+    return os.environ.get(name, default).strip().lower()
+
+
+def load_mirror_config() -> dict:
+    if not MIRROR_CONFIG_PATH.exists():
+        return {}
+    return json.loads(MIRROR_CONFIG_PATH.read_text())
+
+
+def mirror_value(name: str, field: str, default: str | None = None) -> str | None:
+    entry = load_mirror_config().get(name, {})
+    value = entry.get(field)
+    if isinstance(value, str) and value.strip() and "<fill-" not in value and "<your-org>" not in value:
+        return value.strip()
+    return default
+
+
+def reset_prepared_state() -> None:
+    global PREPARED_ENV, PREPARED_DEP_DIR, PREPARED_REMOTE
+    PREPARED_ENV = None
+    PREPARED_DEP_DIR = None
+    PREPARED_REMOTE = False
+
+
+def should_build() -> bool:
+    if _env_flag("ALPHAFOLD3_SKIP_BUILD", "0") in {"1", "true", "on", "yes"}:
+        return False
+    if _env_flag("ONESCIENCE_SKIP_AF3_BUILD", "0") in {"1", "true", "on", "yes"}:
+        return False
+    mode = _env_flag("ALPHAFOLD3_BUILD", _env_flag("ONESCIENCE_BUILD_AF3", "auto"))
+    if mode in {"0", "false", "off", "no"}:
+        return False
+    if mode in {"1", "true", "on", "yes", "force"}:
+        return True
+    return AF3_DIR.exists()
+
+
+def is_strict() -> bool:
+    return _env_flag("ALPHAFOLD3_STRICT", _env_flag("ONESCIENCE_AF3_STRICT", "0")) in {"1", "true", "on", "yes"}
+
+
+def force_rebuild() -> bool:
+    return _env_flag("ALPHAFOLD3_FORCE_REBUILD", _env_flag("ONESCIENCE_AF3_FORCE_REBUILD", "0")) in {"1", "true", "on", "yes"}
+
+
+def resolve_dep_dir() -> Path | None:
+    dep_dir = os.environ.get("ALPHAFOLD3_DEP_DIR")
+    if dep_dir:
+        return Path(dep_dir).expanduser().resolve()
+    candidate = ROOT / "third_party" / "alphafold3_deps"
+    if candidate.exists():
+        return candidate
+    return None
+
+
+def using_remote_dependencies() -> bool:
+    return resolve_dep_dir() is None
+
+
+def install_destination() -> Path:
+    return AF3_DIR
+
+
+def build_data_output_dir() -> Path:
+    return CONVERTERS_DIR
+
+
+def cifpp_data_dir() -> Path | None:
+    env_path = os.environ.get("ALPHAFOLD3_CIFPP_DATA_DIR")
+    if env_path:
+        return Path(env_path)
+    return AF3_DIR / "_data" / "libcifpp"
+
+
+def cifpp_components_path() -> Path | None:
+    data_dir = cifpp_data_dir()
+    if data_dir is None:
+        return None
+    return data_dir / "components.cif"
+
+
+def current_python_include_dir() -> str:
+    paths = sysconfig.get_paths()
+    return paths.get("include", "")
+
+
+def current_numpy_include_dir() -> str | None:
+    try:
+        import numpy
+        return numpy.get_include()
+    except Exception:
+        return None
+
+
+def _lib_exists() -> bool:
+    return any(AF3_DIR.glob(pattern) for pattern in LIB_PATTERNS)
+
+
+def _data_exists() -> bool:
+    return all(path.exists() for path in DATA_FILES)
+
+
+def artifacts_exist() -> bool:
+    return _lib_exists() and _data_exists()
+
+
+def hmmer_binaries_exist() -> bool:
+    return all((HMMER_BIN_DIR / name).exists() for name in HMMER_BINARIES)
+
+
+def download_hmmer_source() -> None:
+    if HMMER_ARCHIVE_PATH.exists():
+        return
+    HMMER_BUILD_ROOT.mkdir(parents=True, exist_ok=True)
+    print(f"[AF3] downloading HMMER source from {HMMER_SOURCE_URL}")
+    urllib.request.urlretrieve(HMMER_SOURCE_URL, HMMER_ARCHIVE_PATH)
+
+
+def extract_hmmer_source() -> None:
+    if HMMER_BUILD_DIR.exists():
+        return
+    HMMER_BUILD_ROOT.mkdir(parents=True, exist_ok=True)
+    with tarfile.open(HMMER_ARCHIVE_PATH, "r:gz") as tar:
+        tar.extractall(HMMER_BUILD_ROOT)
+
+
+def apply_hmmer_patch() -> None:
+    if HMMER_PATCH_MARKER.exists():
+        return
+    subprocess.run(
+        ["patch", "-p0", "-i", str(HMMER_PATCH_PATH.resolve())],
+        cwd=HMMER_BUILD_ROOT,
+        check=True,
+    )
+    HMMER_PATCH_MARKER.write_text("patched\n")
+
+
+def build_hmmer_tools() -> None:
+    if hmmer_binaries_exist() and HMMER_BUILD_MARKER.exists():
+        return
+    if shutil.which("make") is None and shutil.which("gmake") is None:
+        raise AF3BuildError("make or gmake is required to build HMMER tools.")
+    make_program = shutil.which("gmake") or shutil.which("make")
+    download_hmmer_source()
+    extract_hmmer_source()
+    apply_hmmer_patch()
+    HMMER_INSTALL_DIR.mkdir(parents=True, exist_ok=True)
+    print(f"[AF3] building HMMER tools into {HMMER_INSTALL_DIR}")
+    try:
+        subprocess.run(["./configure", f"--prefix={HMMER_INSTALL_DIR}"], cwd=HMMER_BUILD_DIR, check=True)
+        build_parallelism = min(os.cpu_count() or 8, 64)
+        subprocess.run([make_program, "-j", str(build_parallelism)], cwd=HMMER_BUILD_DIR, check=True)
+        subprocess.run([make_program, "install"], cwd=HMMER_BUILD_DIR, check=True)
+        subprocess.run([make_program, "install"], cwd=HMMER_BUILD_DIR / "easel", check=True)
+    except subprocess.CalledProcessError as exc:
+        raise AF3BuildError(
+            f"HMMER tools build failed with exit code {exc.returncode}. "
+            f"Check HMMER build logs under {HMMER_BUILD_DIR} for details."
+        ) from exc
+    HMMER_BUILD_MARKER.write_text("built\n")
+    print(f"[AF3] HMMER tools ready at {HMMER_BIN_DIR}")
+
+def ensure_hmmer_tools_ready() -> None:
+    if hmmer_binaries_exist():
+        return
+    if shutil.which("patch") is None:
+        raise AF3BuildError("patch is required to build HMMER tools.")
+    build_hmmer_tools()
+
+
+def ensure_dependencies_ready() -> None:
+    dep_dir = resolve_dep_dir()
+    if dep_dir is None:
+        return
+    required = ("abseil-cpp", "pybind11", "pybind11_abseil", "libcifpp", "dssp")
+    missing = [name for name in required if not (dep_dir / name).exists()]
+    if missing:
+        raise AF3BuildError(
+            f"AlphaFold3 dependency directories are missing under {dep_dir}: {', '.join(missing)}"
+        )
+
+
+def ensure_build_prerequisites() -> None:
+    if shutil.which("cmake") is None:
+        raise AF3BuildError("CMake is required to build AlphaFold3.")
+    if using_remote_dependencies() and shutil.which("git") is None:
+        raise AF3BuildError(
+            "Git is required for remote AlphaFold3 dependency fetching when no local dependency directory is configured."
+        )
+    ensure_dependencies_ready()
+    ensure_hmmer_tools_ready()
+
+
+def resolve_fetch_base() -> str:
+    return os.environ.get("ALPHAFOLD3_FETCH_BASE", "https://gitee.com/zhang-yuqi-sudo").rstrip("/")
+
+
+def dependency_specs() -> dict[str, dict[str, str]]:
+    base = resolve_fetch_base()
+    return {
+        "ABSEIL": {"repo": f"{base}/abseil-cpp", "tag": "d7aaad83b488fd62bd51c81ecf16cd938532cc0a", "local_path": "abseil-cpp"},
+        "PYBIND11": {"repo": f"{base}/pybind11", "tag": "2e0815278cb899b20870a67ca8205996ef47e70f", "local_path": "pybind11"},
+        "PYBIND11_ABSEIL": {"repo": f"{base}/pybind11_abseil", "tag": "bddf30141f9fec8e577f515313caec45f559d319", "local_path": "pybind11_abseil"},
+        "CIFPP": {"repo": f"{base}/libcifpp", "tag": "ac98531a2fc8daf21131faa0c3d73766efa46180", "local_path": "libcifpp"},
+        "DSSP": {"repo": f"{base}/dssp", "tag": "57560472b4260dc41f457706bc45fc6ef0bc0f10", "local_path": "dssp"},
+    }
+
+
+def announce_build_mode() -> None:
+    if PREPARED_DEP_DIR is not None and PREPARED_REMOTE:
+        print(f"Using prepared mirrored dependencies from {PREPARED_DEP_DIR}.")
+    elif PREPARED_DEP_DIR is not None:
+        print(f"Using local AlphaFold3 dependencies from {PREPARED_DEP_DIR}.")
+    elif using_remote_dependencies():
+        print(f"Using remote AlphaFold3 dependencies from {resolve_fetch_base()}.")
+    else:
+        print(f"Using local AlphaFold3 dependencies from {resolve_dep_dir()}.")
+
+
+def announce_install_destination() -> None:
+    print(f"Installing AlphaFold3 artifacts into {install_destination()}.")
+
+
+def announce_data_destination() -> None:
+    print(f"Writing AlphaFold3 data files into {build_data_output_dir()}.")
+
+
+def announce_cifpp_data_location() -> None:
+    data_dir = cifpp_data_dir()
+    if data_dir is not None:
+        print(f"Using libcifpp data directory {data_dir}.")
+
+
+def announce_mirror_overrides() -> None:
+    config = load_mirror_config()
+    active = []
+    for name, entry in config.items():
+        mirror = entry.get("mirror")
+        if isinstance(mirror, str) and mirror.strip() and "<your-org>" not in mirror:
+            active.append(f"{name} -> {mirror}")
+    if active:
+        print("Using dependency mirror config:")
+        for item in active:
+            print(f"  {item}")
+
+
+def announce_hmmer_location() -> None:
+    print(f"Using HMMER tool directory {HMMER_BIN_DIR}.")
+
+
+def ensure_install_dirs() -> None:
+    install_destination().mkdir(parents=True, exist_ok=True)
+    build_data_output_dir().mkdir(parents=True, exist_ok=True)
+
+
+def prepare_install_layout() -> None:
+    ensure_install_dirs()
+    announce_build_mode()
+    announce_install_destination()
+    announce_data_destination()
+    announce_cifpp_data_location()
+    announce_hmmer_location()
+    announce_mirror_overrides()
+
+
+def ensure_local_components_file() -> None:
+    components_path = cifpp_components_path()
+    if components_path is None or components_path.exists():
+        return
+    if shutil.which("wget") is None:
+        return
+    components_path.parent.mkdir(parents=True, exist_ok=True)
+    try:
+        subprocess.run(
+            [
+                "wget",
+                "-O",
+                str(components_path),
+                "https://files.wwpdb.org/pub/pdb/data/monomers/components.cif",
+            ],
+            check=True,
+        )
+    except subprocess.CalledProcessError as exc:
+        raise AF3BuildError(f"Failed to download components.cif with wget: {exc}") from exc
+
+
+def ensure_components_file_available() -> None:
+    components_path = cifpp_components_path()
+    if components_path is None:
+        return
+    if components_path.exists():
+        return
+    raise AF3BuildError(
+        f"Expected libcifpp components file at {components_path}, but it was not created during dependency install."
+    )
+
+
+def finalise_install_layout() -> None:
+    ensure_components_file_available()
+
+
+def patch_text(path: Path, old: str, new: str) -> None:
+    if not path.exists() or not new:
+        return
+    text = path.read_text()
+    if old in text:
+        path.write_text(text.replace(old, new))
+
+
+def clone_or_update_repo(dep_name: str, repo: str, tag: str) -> Path:
+    target = REMOTE_DEPS_DIR / dep_name
+    if target.exists():
+        shutil.rmtree(target, ignore_errors=True)
+    target.parent.mkdir(parents=True, exist_ok=True)
+    subprocess.run(["git", "clone", repo, str(target)], check=True)
+    subprocess.run(["git", "-C", str(target), "checkout", tag], check=True)
+    return target
+
+
+def disable_tests(source_dir: Path) -> None:
+    patch_text(
+        source_dir / "CMakeLists.txt",
+        "if(BUILD_TESTING AND PROJECT_IS_TOP_LEVEL)",
+        "if(FALSE AND BUILD_TESTING AND PROJECT_IS_TOP_LEVEL)",
+    )
+    patch_text(
+        source_dir / "CMakeLists.txt",
+        "if(BUILD_PYTHON_MODULE)",
+        "if(FALSE AND BUILD_PYTHON_MODULE)",
+    )
+
+
+def patch_catch2_sources(test_cmake: Path, env: dict[str, str]) -> None:
+    patch_text(test_cmake, "https://github.com/catchorg/Catch2.git", env.get("ALPHAFOLD3_CATCH2_REPO", ""))
+    patch_text(test_cmake, "v3.4.0", env.get("ALPHAFOLD3_CATCH2_TAG", ""))
+
+
+def patch_regex_sources(source_dir: Path, env: dict[str, str]) -> None:
+    patch_text(source_dir / "CMakeLists.txt", "https://github.com/boostorg/regex", env.get("ALPHAFOLD3_BOOST_REGEX_REPO", ""))
+    patch_text(source_dir / "CMakeLists.txt", "boost-1.87.0", env.get("ALPHAFOLD3_BOOST_REGEX_TAG", ""))
+
+
+# def patch_archive_urls(source_dir: Path, env: dict[str, str]) -> None:
+#     patch_text(
+#         source_dir / "pcre2-simple" / "CMakeLists.txt",
+#         "https://github.com/PCRE2Project/pcre2/releases/download/pcre2-10.46/pcre2-10.46.tar.gz",
+#         env.get("ALPHAFOLD3_PCRE2_URL", ""),
+#     )
+
+
+def patch_eigen_sources(source_dir: Path, env: dict[str, str]) -> None:
+    cmake_path = source_dir / "CMakeLists.txt"
+    patch_text(
+        cmake_path,
+        "https://gitlab.com/libeigen/eigen.git",
+        env.get("ALPHAFOLD3_EIGEN_REPO", ""),
+    )
+    patch_text(
+        cmake_path,
+        "GIT_TAG 3.4.0",
+        f"GIT_TAG {env.get('ALPHAFOLD3_EIGEN_TAG', '')}",
+    )
+    patch_text(
+        cmake_path,
+        "\t# Create a private copy of eigen3 and populate it only, no need to build\n",
+        "\t# Create a private copy of eigen3 and populate it only, no need to build\n\tmessage(STATUS \"AF3 libcifpp: Eigen3 not found locally, populating my-eigen3 from GIT repository\")\n\tmessage(STATUS \"AF3 libcifpp: my-eigen3 repo=$ENV{ALPHAFOLD3_EIGEN_REPO} tag=$ENV{ALPHAFOLD3_EIGEN_TAG}\")\n",
+    )
+    patch_text(
+        cmake_path,
+        "\tFetchContent_GetProperties(my-eigen3)\n",
+        "\tFetchContent_GetProperties(my-eigen3)\n\tmessage(STATUS \"AF3 libcifpp: my-eigen3 populated=${my-eigen3_POPULATED}\")\n",
+    )
+    patch_text(
+        cmake_path,
+        "\tif(NOT my-eigen3_POPULATED)\n\t\tFetchContent_Populate(my-eigen3)\n\tendif()\n",
+        "\tif(NOT my-eigen3_POPULATED)\n\t\tmessage(STATUS \"AF3 libcifpp: starting FetchContent_Populate(my-eigen3)\")\n\t\tFetchContent_Populate(my-eigen3)\n\t\tmessage(STATUS \"AF3 libcifpp: finished FetchContent_Populate(my-eigen3), source=${my-eigen3_SOURCE_DIR}\")\n\tendif()\n",
+    )
+    patch_text(
+        cmake_path,
+        "\tset(EIGEN_INCLUDE_DIR ${my-eigen3_SOURCE_DIR})\n",
+        "\tset(EIGEN_INCLUDE_DIR ${my-eigen3_SOURCE_DIR})\n\tmessage(STATUS \"AF3 libcifpp: EIGEN_INCLUDE_DIR=${EIGEN_INCLUDE_DIR}\")\n",
+    )
+
+
+def patch_all_known_downstream_sources(source_dir: Path, env: dict[str, str]) -> None:
+    disable_tests(source_dir)
+    patch_regex_sources(source_dir, env)
+    # patch_archive_urls(source_dir, env)
+    patch_eigen_sources(source_dir, env)
+    test_cmake = source_dir / "test" / "CMakeLists.txt"
+    if test_cmake.exists():
+        patch_catch2_sources(test_cmake, env)
+
+
+def patch_libcifpp_sources(source_dir: Path, env: dict[str, str]) -> None:
+    patch_all_known_downstream_sources(source_dir, env)
+
+
+def patch_dssp_sources(source_dir: Path, env: dict[str, str]) -> None:
+    patch_all_known_downstream_sources(source_dir, env)
+    patch_text(source_dir / "CMakeLists.txt", "https://github.com/mhekkel/libmcfp", env.get("ALPHAFOLD3_LIBMCFP_REPO", ""))
+    patch_text(source_dir / "CMakeLists.txt", "v1.4.2", env.get("ALPHAFOLD3_LIBMCFP_TAG", ""))
+    patch_text(source_dir / "CMakeLists.txt", "https://github.com/PDB-REDO/libcifpp", env.get("CIFPP_REPO", ""))
+    patch_text(source_dir / "CMakeLists.txt", "v10.0.1", env.get("CIFPP_TAG", ""))
+
+
+def prepare_remote_dependency_sources(env: dict[str, str]) -> Path:
+    if REMOTE_DEPS_DIR.exists():
+        shutil.rmtree(REMOTE_DEPS_DIR, ignore_errors=True)
+    REMOTE_DEPS_DIR.mkdir(parents=True, exist_ok=True)
+
+    specs = dependency_specs()
+    prepared = {}
+    clone_order = ["ABSEIL", "PYBIND11", "PYBIND11_ABSEIL", "CIFPP", "DSSP"]
+    for key_prefix in clone_order:
+        spec = specs[key_prefix]
+        dep_name = spec["local_path"]
+        repo = env[f"{key_prefix}_REPO"]
+        tag = env[f"{key_prefix}_TAG"]
+        prepared[dep_name] = clone_or_update_repo(dep_name, repo, tag)
+        if dep_name == "libcifpp":
+            patch_libcifpp_sources(prepared[dep_name], env)
+        elif dep_name == "dssp":
+            patch_dssp_sources(prepared[dep_name], env)
+
+    return REMOTE_DEPS_DIR
+
+
+def prepare_build_env_once() -> dict[str, str]:
+    global PREPARED_ENV, PREPARED_DEP_DIR, PREPARED_REMOTE
+    if PREPARED_ENV is not None:
+        return PREPARED_ENV
+
+    env = os.environ.copy()
+    env["PATH"] = str(HMMER_BIN_DIR) + os.pathsep + env.get("PATH", "")
+    specs = dependency_specs()
+    for prefix, spec in specs.items():
+        env[f"{prefix}_REPO"] = mirror_value(spec["local_path"], "mirror", spec["repo"]) or spec["repo"]
+        env[f"{prefix}_TAG"] = mirror_value(spec["local_path"], "tag", spec["tag"]) or spec["tag"]
+
+    env["ALPHAFOLD3_BOOST_REGEX_REPO"] = mirror_value("boost-regex", "mirror", "https://github.com/boostorg/regex") or "https://github.com/boostorg/regex"
+    env["ALPHAFOLD3_BOOST_REGEX_TAG"] = mirror_value("boost-regex", "tag", DEFAULT_DOWNSTREAM_TAGS["boost-regex"]) or DEFAULT_DOWNSTREAM_TAGS["boost-regex"]
+    env["ALPHAFOLD3_LIBMCFP_REPO"] = mirror_value("libmcfp", "mirror", "https://github.com/mhekkel/libmcfp") or "https://github.com/mhekkel/libmcfp"
+    env["ALPHAFOLD3_LIBMCFP_TAG"] = mirror_value("libmcfp", "tag", DEFAULT_DOWNSTREAM_TAGS["libmcfp"]) or DEFAULT_DOWNSTREAM_TAGS["libmcfp"]
+    env["ALPHAFOLD3_CATCH2_REPO"] = mirror_value("catch2", "mirror", "https://github.com/catchorg/Catch2.git") or "https://github.com/catchorg/Catch2.git"
+    env["ALPHAFOLD3_CATCH2_TAG"] = mirror_value("catch2", "tag", DEFAULT_DOWNSTREAM_TAGS["catch2"]) or DEFAULT_DOWNSTREAM_TAGS["catch2"]
+    pcre2_url = mirror_value("pcre2", "mirror")
+    if pcre2_url:
+        env["ALPHAFOLD3_PCRE2_URL"] = pcre2_url
+    eigen_repo = mirror_value("eigen", "mirror", "https://gitlab.com/libeigen/eigen.git") or "https://gitlab.com/libeigen/eigen.git"
+    eigen_tag = mirror_value("eigen", "tag", "3.4.0") or "3.4.0"
+    env["ALPHAFOLD3_EIGEN_REPO"] = eigen_repo
+    env["ALPHAFOLD3_EIGEN_TAG"] = eigen_tag
+    dep_dir = resolve_dep_dir()
+    if dep_dir is None and using_remote_dependencies():
+        dep_dir = prepare_remote_dependency_sources(env)
+        PREPARED_REMOTE = True
+    if dep_dir is not None:
+        PREPARED_DEP_DIR = dep_dir
+        env["ALPHAFOLD3_DEP_DIR"] = str(dep_dir)
+        for prefix, spec in specs.items():
+            env[f"{prefix}_LOCAL_PATH"] = str(dep_dir / spec["local_path"])
+
+    env["ALPHAFOLD3_INSTALL_PREFIX"] = str(install_destination())
+    env["ALPHAFOLD3_DATA_OUTPUT_DIR"] = str(build_data_output_dir())
+    data_dir = cifpp_data_dir()
+    components_path = cifpp_components_path()
+    if data_dir is not None:
+        env["ALPHAFOLD3_CIFPP_DATA_DIR"] = str(data_dir)
+    if components_path is not None:
+        env["ALPHAFOLD3_CIFPP_COMPONENTS"] = str(components_path)
+    env["ALPHAFOLD3_PYTHON_EXECUTABLE"] = sys.executable
+    python_include_dir = current_python_include_dir()
+    if python_include_dir:
+        env["ALPHAFOLD3_PYTHON_INCLUDE_DIR"] = python_include_dir
+    numpy_include_dir = current_numpy_include_dir()
+    if numpy_include_dir:
+        env["ALPHAFOLD3_NUMPY_INCLUDE_DIR"] = numpy_include_dir
+    pythonpath_entries = [str(ROOT)]
+    existing_pythonpath = env.get("PYTHONPATH")
+    if existing_pythonpath:
+        pythonpath_entries.append(existing_pythonpath)
+    env["PYTHONPATH"] = os.pathsep.join(pythonpath_entries)
+
+    PREPARED_ENV = env
+    return env
+
+
+def _build_env() -> dict[str, str]:
+    return prepare_build_env_once().copy()
+
+
+def _run(command: list[str], cwd: Path) -> None:
+    env = _build_env()
+    if command and command[0] == "cmake":
+        resolved_cmake = shutil.which("cmake", path=env.get("PATH"))
+        print(f"[AF3] build python executable: {sys.executable}")
+        print(f"[AF3] build cwd: {cwd}")
+        print(f"[AF3] build PATH: {env.get('PATH', '')}")
+        print(f"[AF3] resolved cmake: {resolved_cmake}")
+        print(f"[AF3] build PYTHONPATH: {env.get('PYTHONPATH', '')}")
+        print(f"[AF3] build CONDA_PREFIX: {env.get('CONDA_PREFIX', '')}")
+        print(f"[AF3] build VIRTUAL_ENV: {env.get('VIRTUAL_ENV', '')}")
+        print(f"[AF3] ALPHAFOLD3_PYTHON_EXECUTABLE: {env.get('ALPHAFOLD3_PYTHON_EXECUTABLE', '')}")
+        print(f"[AF3] ALPHAFOLD3_PYTHON_INCLUDE_DIR: {env.get('ALPHAFOLD3_PYTHON_INCLUDE_DIR', '')}")
+        print(f"[AF3] ALPHAFOLD3_NUMPY_INCLUDE_DIR: {env.get('ALPHAFOLD3_NUMPY_INCLUDE_DIR', '')}")
+    subprocess.run(command, cwd=cwd, env=env, check=True)
+
+
+def build_cpp_extension() -> None:
+    BUILD_DIR.mkdir(exist_ok=True)
+    try:
+        cmake_configure_command = [
+            "cmake",
+            str(AF3_DIR),
+            "-DCMAKE_BUILD_TYPE=Release",
+            "-DCMAKE_CXX_STANDARD=20",
+            "-DCMAKE_POSITION_INDEPENDENT_CODE=ON",
+            "-DBUILD_TESTING=OFF",
+            "-DCMAKE_CXX_SCAN_FOR_MODULES=OFF",
+            "-DSKBUILD_PROJECT_NAME=cpp",
+            "-DSKBUILD_PROJECT_VERSION=0.3.0",
+            f"-DPython3_EXECUTABLE={sys.executable}",
+            "-DPython3_FIND_STRATEGY=LOCATION",
+        ]
+        python_include_dir = current_python_include_dir()
+        if python_include_dir:
+            cmake_configure_command.append(f"-DPython3_INCLUDE_DIR={python_include_dir}")
+        numpy_include_dir = current_numpy_include_dir()
+        if numpy_include_dir:
+            cmake_configure_command.append(f"-DPython3_NumPy_INCLUDE_DIR={numpy_include_dir}")
+        _run(cmake_configure_command, cwd=BUILD_DIR)
+        build_parallelism = min(os.cpu_count() or 8, 64)
+        _run(["cmake", "--build", ".", "--parallel", str(build_parallelism)], cwd=BUILD_DIR)
+        _run(["cmake", "--install", ".", "--prefix", str(install_destination())], cwd=BUILD_DIR)
+    except FileNotFoundError as exc:
+        raise AF3BuildError(f"CMake not found: {exc}") from exc
+    except subprocess.CalledProcessError as exc:
+        raise AF3BuildError(f"Failed to build AlphaFold3 C++ extension: {exc}") from exc
+    finally:
+        cleanup_build_artifacts()
+
+
+def build_data_files() -> None:
+    try:
+        from flax_model.alphafold3.build_data import build_data
+        build_data()
+    except Exception as exc:
+        raise AF3BuildError(f"Failed to build AlphaFold3 data files: {exc}") from exc
+
+
+def cleanup_build_artifacts() -> None:
+    for path in (
+        BUILD_DIR,
+        AF3_DIR / "include",
+        AF3_DIR / "lib",
+        AF3_DIR / "lib64",
+        AF3_DIR / "var",
+        AF3_DIR / "etc",
+    ):
+        if path.exists():
+            shutil.rmtree(path, ignore_errors=True)
+
+
+def cleanup_prepared_remote_deps() -> None:
+    if PREPARED_REMOTE and REMOTE_DEPS_DIR.exists():
+        shutil.rmtree(REMOTE_DEPS_DIR, ignore_errors=True)
+
+
+def build_all() -> None:
+    reset_prepared_state()
+    ensure_build_prerequisites()
+    prepare_build_env_once()
+    ensure_local_components_file()
+    prepare_install_layout()
+    print("Building AlphaFold3 C++ extension...")
+    build_cpp_extension()
+    finalise_install_layout()
+    print("Building AlphaFold3 data files...")
+    build_data_files()
+    cleanup_prepared_remote_deps()
+
+
+def build_if_needed() -> None:
+    if not should_build():
+        return
+    if artifacts_exist() and not force_rebuild():
+        return
+    build_all()

flax_model/alphafold3/_data/libcifpp/components.cif

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:07589b2cff5cae2cc8847a03cf8354a80c3bbc618aedda80f4d05ccaf8b5a85c
+size 508121501

flax_model/alphafold3/_tools/hmmer/.built

@@ -0,0 +1 @@
+built

flax_model/alphafold3/_tools/hmmer/bin/alimask

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3829f1617d978132264285088fa1876cc576e468586d8cf88660748ae2b13e34
+size 472688

flax_model/alphafold3/_tools/hmmer/bin/easel

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:46ba04bd13c9931f11fa14a1f3f3fdc0c650c05aac20de74f6dcb0288fe4be2d
+size 574504

flax_model/alphafold3/_tools/hmmer/bin/esl-afetch

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d770ea581ec2bd42c684837d5f8414b3e2f4f8e561c28ae594d35a8855510be0
+size 366424

flax_model/alphafold3/_tools/hmmer/bin/esl-alimanip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9e9639fa2303da69519e9b06f631850bb081a3bca0f457f05ae331f484f66057
+size 601624

flax_model/alphafold3/_tools/hmmer/bin/esl-alimap

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:303169914a002be9658a626a5767ac1e332a01f8497aafc2a0fb786d94bd1166
+size 373920

flax_model/alphafold3/_tools/hmmer/bin/esl-alimask

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8e3d36892dbce11b74cba9f7eec125b633ac3def9f3777ff52a712b2a13715ec
+size 427360

flax_model/alphafold3/_tools/hmmer/bin/esl-alimerge

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:74301a1a9a1e6d1be2b34ff85147f4609373922df4911d8fcd89af9d0f41e20a
+size 421184

flax_model/alphafold3/_tools/hmmer/bin/esl-alipid

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4fdb5baa1a9e5579f0e542a0eb006cc432181dcc12107c27c84cb2998e2ee66e
+size 384080

flax_model/alphafold3/_tools/hmmer/bin/esl-alirev

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b27dd80cb51b2aba859bdf162aeaddd32f61d340cdadc21ce14b93e31f37ca86
+size 352920

flax_model/alphafold3/_tools/hmmer/bin/esl-alistat

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f3d6c6cad3da0e37905979950871183d89bef3dc8fccd5c36a0722b34914659f
+size 434608

flax_model/alphafold3/_tools/hmmer/bin/esl-compalign

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d5875b268e83742fb7accad9e44e57c6567285d874ec8574a6bb34e6401b8a9c
+size 370608

flax_model/alphafold3/_tools/hmmer/bin/esl-compstruct

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:864b1fde43e2603340d666eb3b2e382b57556b65d68416ea8bec59888516f18a
+size 357136

flax_model/alphafold3/_tools/hmmer/bin/esl-construct

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:016ef82d9c226ab2dfa96a6d34e45b903e5de66cf2055396f622f978d5c2255c
+size 374472

flax_model/alphafold3/_tools/hmmer/bin/esl-histplot

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9f64c1da60a62e2cd4e6c09d89512e28a31b824115ff43c5f4ffdfb2b431f0e2
+size 175248

flax_model/alphafold3/_tools/hmmer/bin/esl-mask

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:71aa5ec2f448fd03390551b56e0bec104294f96ebca830b71a5ad48a78a62c1b
+size 466512

flax_model/alphafold3/_tools/hmmer/bin/esl-mixdchlet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:485ba00164847ae5b3c7b3d9252c893731d5457bd3b9a107bf8328a6dab7607a
+size 166744

flax_model/alphafold3/_tools/hmmer/bin/esl-reformat

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:04f041b4b5291ff000d1dd4ad36e291257fb1cc5ee87438c382a681805d4e871
+size 480000

flax_model/alphafold3/_tools/hmmer/bin/esl-seqrange

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8c632736b7e228ff8b1dafd196a975699dc4fe3e328469eb7912adf5ab7b6407
+size 457152

flax_model/alphafold3/_tools/hmmer/bin/esl-seqstat

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a98388deebbaf07421a880ac69f3938101f241e471d5e53fb208b053f6820811
+size 466104

flax_model/alphafold3/_tools/hmmer/bin/esl-sfetch

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:860fcf585ba9bccff9e77d23061a95d878e226b0013dc810d0dafb7716727a72
+size 488216

flax_model/alphafold3/_tools/hmmer/bin/esl-shuffle

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8769d54193fe004f33ec80f5cda4828760ed173fb4359b020997dd21ed8d2825
+size 475808

flax_model/alphafold3/_tools/hmmer/bin/esl-ssdraw

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:683b7b21d1382a09ef0795e2ef06fb3dc0f2fab4503c032da79271771a2d5b1d
+size 538912

flax_model/alphafold3/_tools/hmmer/bin/esl-translate

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:959313addd5ce794b977bfb03daafcc6c0f2974a5dec0f198f7a46822a3c483b
+size 501024

flax_model/alphafold3/_tools/hmmer/bin/esl-weight

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:439fec1b9e7c3fda0d66e578f2edeae1b7d886693fe4d459588b2943e92f4b76
+size 442000

flax_model/alphafold3/_tools/hmmer/bin/hmmalign

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:41d61aa0607f1276a60885aa7bf6211eeb82b0025af14fdc8e065603641822c4
+size 825160

flax_model/alphafold3/_tools/hmmer/bin/hmmbuild

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0d77e1ec8f1cbbbd8f422e4c9086df14827c330571441a643b0e000dffdd3cfa
+size 961776

flax_model/alphafold3/_tools/hmmer/bin/hmmconvert

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:94492f28b9bd0bf189e8939250fd4e17334f438f1fbd5a28d7961c8372560964
+size 522376

flax_model/alphafold3/_tools/hmmer/bin/hmmemit

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d95014dd6782eda7230deaa99ea69797b2d2f91974562490beb26435fcb342cc
+size 825632

flax_model/alphafold3/_tools/hmmer/bin/hmmfetch

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:868bffcb8ae9da213e12e57848c0e1a33c8089b5c8e9a46be00ef94b5b96db90
+size 531312

flax_model/alphafold3/_tools/hmmer/bin/hmmlogo

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bcfe77862766daec5dbe81fbf4c54a5fb143206de97c48f6f8e970e07ab09e9c
+size 522504

flax_model/alphafold3/_tools/hmmer/bin/hmmpgmd

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c1241da11803085fda21c80ec674d73f483e25e317248e0ac73210156ae500af
+size 1218768

flax_model/alphafold3/_tools/hmmer/bin/hmmpgmd_shard

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f1567ab0cc18dfe3018a7e6cd9c0cacc74ae7da0853f0dcec625b6df48dee7b9
+size 1227248