boltz-vsynthes 1.0.9__py3-none-any.whl → 1.0.10__py3-none-any.whl

boltz/data/parse/sdf.py

@@ -0,0 +1,60 @@
+from pathlib import Path
+from typing import Optional
+
+from rdkit import Chem
+from rdkit.Chem.rdchem import Mol
+
+from boltz.data.types import Target
+from boltz.data.parse.yaml import parse_boltz_schema
+
+
+def parse_sdf(
+    path: Path,
+    ccd: dict[str, Mol],
+    mol_dir: Path,
+    boltz2: bool = False,
+) -> Target:
+    """Parse an SDF file.
+
+    Parameters
+    ----------
+    path : Path
+        Path to the SDF file.
+    ccd : Dict
+        Dictionary of CCD components.
+    mol_dir : Path
+        Path to the directory containing the molecules.
+    boltz2 : bool
+        Whether to parse the input for Boltz2.
+
+    Returns
+    -------
+    Target
+        The parsed target.
+    """
+    # Read SDF file
+    supplier = Chem.SDMolSupplier(str(path))
+    
+    # Convert to yaml format
+    sequences = []
+    for i, mol in enumerate(supplier):
+        if mol is not None:
+            # Get SMILES
+            smiles = Chem.MolToSmiles(mol)
+            
+            molecule = {
+                "ligand": {
+                    "id": f"L{i+1}",  # Use L1, L2, etc. as chain IDs
+                    "smiles": smiles,
+                },
+            }
+            sequences.append(molecule)
+
+    data = {
+        "sequences": sequences,
+        "bonds": [],
+        "version": 1,
+    }
+
+    name = path.stem
+    return parse_boltz_schema(name, data, ccd, mol_dir, boltz2) 

boltz/main.py

@@ -27,6 +27,9 @@ from boltz.data.msa.mmseqs2 import run_mmseqs2
 from boltz.data.parse.a3m import parse_a3m
 from boltz.data.parse.csv import parse_csv
 from boltz.data.parse.fasta import parse_fasta
+from boltz.data.parse.pdb import parse_pdb
+from boltz.data.parse.pdb_download import parse_pdb_id
+from boltz.data.parse.sdf import parse_sdf
 from boltz.data.parse.yaml import parse_yaml
 from boltz.data.types import MSA, Manifest, Record
 from boltz.data.write.writer import BoltzAffinityWriter, BoltzWriter
@@ -289,44 +292,31 @@ def check_inputs(data: Path) -> list[Path]:
 
     # Check if data is a directory
     if data.is_dir():
-        # Get all files recursively
-        valid_data = []
-        for ext in (".fa", ".fas", ".fasta", ".yml", ".yaml"):
-            valid_data.extend(data.glob(f"**/*{ext}"))
-        
-        if not valid_data:
-            msg = f"No .fasta or .yaml files found in {data}"
-            raise RuntimeError(msg)
-
-        # Filter out directories and invalid file types
-        filtered_data = []
-        for d in valid_data:
+        data: list[Path] = list(data.glob("*"))
+
+        # Filter out non .fasta, .yaml, .pdb, or .sdf files, raise
+        # an error on directory and other file types
+        for d in data:
             if d.is_dir():
-                msg = f"Found directory {d} instead of .fasta or .yaml."
-                click.echo(f"Warning: {msg}")
-                continue
-            if d.suffix not in (".fa", ".fas", ".fasta", ".yml", ".yaml"):
-                msg = f"Warning: Skipping file with unsupported extension {d.suffix}"
-                click.echo(msg)
-                continue
-            filtered_data.append(d)
-        
-        if not filtered_data:
-            msg = "No valid input files found after filtering."
-            raise RuntimeError(msg)
-            
-        data = filtered_data
+                msg = f"Found directory {d} instead of .fasta, .yaml, .pdb, or .sdf."
+                raise RuntimeError(msg)
+            if d.suffix not in (".fa", ".fas", ".fasta", ".yml", ".yaml", ".pdb", ".sdf"):
+                msg = (
+                    f"Unable to parse filetype {d.suffix}, "
+                    "please provide a .fasta, .yaml, .pdb, or .sdf file."
+                )
+                raise RuntimeError(msg)
     else:
-        # Single file case
-        if data.suffix not in (".fa", ".fas", ".fasta", ".yml", ".yaml"):
-            msg = (
-                f"Unable to parse filetype {data.suffix}, "
-                "please provide a .fasta or .yaml file."
-            )
-            raise RuntimeError(msg)
-        data = [data]
+        # Check if input is a PDB ID (4 characters)
+        if len(data.stem) == 4 and data.stem.isalnum():
+            # Create a temporary file to store the PDB ID
+            temp_file = data.parent / f"{data.stem}.pdb"
+            with temp_file.open("w") as f:
+                f.write(data.stem)
+            data = [temp_file]
+        else:
+            data = [data]
 
-    click.echo(f"Found {len(data)} valid input files.")
     return data
 
 
@@ -518,13 +508,23 @@ def process_input(  # noqa: C901, PLR0912, PLR0915, D103
             target = parse_fasta(path, ccd, mol_dir, boltz2)
         elif path.suffix in (".yml", ".yaml"):
             target = parse_yaml(path, ccd, mol_dir, boltz2)
+        elif path.suffix == ".pdb":
+            # Check if this is a PDB ID file
+            if path.stat().st_size <= 4:  # File only contains PDB ID
+                with path.open("r") as f:
+                    pdb_id = f.read().strip()
+                target = parse_pdb_id(pdb_id, ccd, mol_dir, path.parent, boltz2)
+            else:
+                target = parse_pdb(path, ccd, mol_dir, boltz2)
+        elif path.suffix == ".sdf":
+            target = parse_sdf(path, ccd, mol_dir, boltz2)
         elif path.is_dir():
-            msg = f"Found directory {path} instead of .fasta or .yaml, skipping."
+            msg = f"Found directory {path} instead of .fasta, .yaml, .pdb, or .sdf, skipping."
             raise RuntimeError(msg)  # noqa: TRY301
         else:
             msg = (
                 f"Unable to parse filetype {path.suffix}, "
-                "please provide a .fasta or .yaml file."
+                "please provide a .fasta, .yaml, .pdb, or .sdf file."
             )
             raise RuntimeError(msg)  # noqa: TRY301
 
@@ -626,6 +626,7 @@ def process_input(  # noqa: C901, PLR0912, PLR0915, D103
         print(f"Failed to process {path}. Skipping. Error: {e}.")  # noqa: T201
 
 
+@rank_zero_only
 def process_inputs(
     data: list[Path],
     out_dir: Path,
@@ -663,106 +664,87 @@ def process_inputs(
         The manifest of the processed input data.
 
     """
-    all_records = []
-    
-    # Create processed directory
-    processed_dir = out_dir / "processed"
-    processed_dir.mkdir(parents=True, exist_ok=True)
-    
-    # Create central directories
-    structure_dir = processed_dir / "structures"
-    msa_dir = processed_dir / "msa"
-    records_dir = processed_dir / "records"
-    processed_msa_dir = processed_dir / "processed" / "msa"
-    processed_constraints_dir = processed_dir / "processed" / "constraints"
-    processed_templates_dir = processed_dir / "processed" / "templates"
-    processed_mols_dir = processed_dir / "processed" / "mols"
-    predictions_dir = processed_dir / "predictions"
-    
-    # Create all central directories
-    structure_dir.mkdir(parents=True, exist_ok=True)
+    # Check if records exist at output path
+    records_dir = out_dir / "processed" / "records"
+    if records_dir.exists():
+        # Load existing records
+        existing = [Record.load(p) for p in records_dir.glob("*.json")]
+        processed_ids = {record.id for record in existing}
+
+        # Filter to missing only
+        data = [d for d in data if d.stem not in processed_ids]
+
+        # Nothing to do, update the manifest and return
+        if data:
+            click.echo(
+                f"Found {len(existing)} existing processed inputs, skipping them."
+            )
+        else:
+            click.echo("All inputs are already processed.")
+            updated_manifest = Manifest(existing)
+            updated_manifest.dump(out_dir / "processed" / "manifest.json")
+
+    # Create output directories
+    msa_dir = out_dir / "msa"
+    records_dir = out_dir / "processed" / "records"
+    structure_dir = out_dir / "processed" / "structures"
+    processed_msa_dir = out_dir / "processed" / "msa"
+    processed_constraints_dir = out_dir / "processed" / "constraints"
+    processed_templates_dir = out_dir / "processed" / "templates"
+    processed_mols_dir = out_dir / "processed" / "mols"
+    predictions_dir = out_dir / "predictions"
+
+    out_dir.mkdir(parents=True, exist_ok=True)
     msa_dir.mkdir(parents=True, exist_ok=True)
     records_dir.mkdir(parents=True, exist_ok=True)
+    structure_dir.mkdir(parents=True, exist_ok=True)
     processed_msa_dir.mkdir(parents=True, exist_ok=True)
     processed_constraints_dir.mkdir(parents=True, exist_ok=True)
     processed_templates_dir.mkdir(parents=True, exist_ok=True)
     processed_mols_dir.mkdir(parents=True, exist_ok=True)
     predictions_dir.mkdir(parents=True, exist_ok=True)
-    
-    # Process each input file in its own directory
-    for input_file in data:
-        # Create a subdirectory for this input file
-        file_out_dir = out_dir / input_file.stem
-        file_out_dir.mkdir(parents=True, exist_ok=True)
-
-        # Create output directories for this file
-        file_msa_dir = file_out_dir / "msa"
-        file_records_dir = file_out_dir / "processed" / "records"
-        file_processed_msa_dir = file_out_dir / "processed" / "msa"
-        file_processed_constraints_dir = file_out_dir / "processed" / "constraints"
-        file_processed_templates_dir = file_out_dir / "processed" / "templates"
-        file_processed_mols_dir = file_out_dir / "processed" / "mols"
-        file_predictions_dir = file_out_dir / "predictions"
-
-        # Create all file-specific directories
-        file_out_dir.mkdir(parents=True, exist_ok=True)
-        file_msa_dir.mkdir(parents=True, exist_ok=True)
-        file_records_dir.mkdir(parents=True, exist_ok=True)
-        file_processed_msa_dir.mkdir(parents=True, exist_ok=True)
-        file_processed_constraints_dir.mkdir(parents=True, exist_ok=True)
-        file_processed_templates_dir.mkdir(parents=True, exist_ok=True)
-        file_processed_mols_dir.mkdir(parents=True, exist_ok=True)
-        file_predictions_dir.mkdir(parents=True, exist_ok=True)
-
-        # Load CCD
-        if boltz2:
-            ccd = load_canonicals(mol_dir)
-        else:
-            with ccd_path.open("rb") as file:
-                ccd = pickle.load(file)  # noqa: S301
-
-        # Create partial function
-        process_input_partial = partial(
-            process_input,
-            ccd=ccd,
-            msa_dir=file_msa_dir,
-            mol_dir=mol_dir,
-            boltz2=boltz2,
-            use_msa_server=use_msa_server,
-            msa_server_url=msa_server_url,
-            msa_pairing_strategy=msa_pairing_strategy,
-            max_msa_seqs=max_msa_seqs,
-            processed_msa_dir=file_processed_msa_dir,
-            processed_constraints_dir=file_processed_constraints_dir,
-            processed_templates_dir=file_processed_templates_dir,
-            processed_mols_dir=file_processed_mols_dir,
-            structure_dir=structure_dir,  # Use the central structure directory
-            records_dir=file_records_dir,
-        )
 
-        # Process this input file
-        click.echo(f"Processing {input_file.name}")
-        try:
-            process_input_partial(input_file)
-        except Exception as e:
-            click.echo(f"Error processing {input_file.name}: {str(e)}")
-            continue
-
-        # Copy MSA files to central MSA directory
-        for msa_file in file_processed_msa_dir.glob("*.npz"):
-            target_msa_file = msa_dir / msa_file.name
-            if not target_msa_file.exists():
-                import shutil
-                shutil.copy2(msa_file, target_msa_file)
-
-        # Load records for this file
-        records = [Record.load(p) for p in file_records_dir.glob("*.json")]
-        all_records.extend(records)
-
-    # Create combined manifest
-    manifest = Manifest(all_records)
-    manifest.dump(processed_dir / "manifest.json")
-    return manifest
+    # Load CCD
+    if boltz2:
+        ccd = load_canonicals(mol_dir)
+    else:
+        with ccd_path.open("rb") as file:
+            ccd = pickle.load(file)  # noqa: S301
+
+    # Create partial function
+    process_input_partial = partial(
+        process_input,
+        ccd=ccd,
+        msa_dir=msa_dir,
+        mol_dir=mol_dir,
+        boltz2=boltz2,
+        use_msa_server=use_msa_server,
+        msa_server_url=msa_server_url,
+        msa_pairing_strategy=msa_pairing_strategy,
+        max_msa_seqs=max_msa_seqs,
+        processed_msa_dir=processed_msa_dir,
+        processed_constraints_dir=processed_constraints_dir,
+        processed_templates_dir=processed_templates_dir,
+        processed_mols_dir=processed_mols_dir,
+        structure_dir=structure_dir,
+        records_dir=records_dir,
+    )
+
+    # Parse input data
+    preprocessing_threads = min(preprocessing_threads, len(data))
+    click.echo(f"Processing {len(data)} inputs with {preprocessing_threads} threads.")
+
+    if preprocessing_threads > 1 and len(data) > 1:
+        with Pool(preprocessing_threads) as pool:
+            list(tqdm(pool.imap(process_input_partial, data), total=len(data)))
+    else:
+        for path in tqdm(data):
+            process_input_partial(path)
+
+    # Load all records and write manifest
+    records = [Record.load(p) for p in records_dir.glob("*.json")]
+    manifest = Manifest(records)
+    manifest.dump(out_dir / "processed" / "manifest.json")
 
 
 @click.group()
@@ -1065,7 +1047,7 @@ def predict(  # noqa: C901, PLR0915, PLR0912
     # Process inputs
     ccd_path = cache / "ccd.pkl"
     mol_dir = cache / "mols"
-    manifest = process_inputs(
+    process_inputs(
         data=data,
         out_dir=out_dir,
         ccd_path=ccd_path,
@@ -1078,6 +1060,9 @@ def predict(  # noqa: C901, PLR0915, PLR0912
         max_msa_seqs=max_msa_seqs,
     )
 
+    # Load manifest
+    manifest = Manifest.load(out_dir / "processed" / "manifest.json")
+
     # Filter out existing predictions
     filtered_manifest = filter_inputs_structure(
         manifest=manifest,
@@ -1235,89 +1220,72 @@ def predict(  # noqa: C901, PLR0915, PLR0912
         # Print header
         click.echo("\nPredicting property: affinity\n")
 
-        # Group records by protein-ligand pairs
-        affinity_groups = {}
-        for record in manifest.records:
-            if record.affinity:
-                key = (record.affinity["binder"], record.affinity["ligand"])
-                if key not in affinity_groups:
-                    affinity_groups[key] = []
-                affinity_groups[key].append(record)
-
-        # Process each protein-ligand pair
-        for (binder, ligand), records in affinity_groups.items():
-            # Create subfolder for this protein-ligand pair
-            pair_dir = out_dir / "predictions" / f"{binder}_{ligand}"
-            pair_dir.mkdir(parents=True, exist_ok=True)
-
-            # Create manifest for this pair
-            pair_manifest = Manifest(records)
-
-            # Validate inputs
-            pair_manifest_filtered = filter_inputs_affinity(
-                manifest=pair_manifest,
-                outdir=pair_dir,
-                override=override,
-            )
-            if not pair_manifest_filtered.records:
-                click.echo(f"Found existing affinity predictions for {binder}_{ligand}, skipping.")
-                continue
+        # Validate inputs
+        manifest_filtered = filter_inputs_affinity(
+            manifest=manifest,
+            outdir=out_dir,
+            override=override,
+        )
+        if not manifest_filtered.records:
+            click.echo("Found existing affinity predictions for all inputs, skipping.")
+            return
 
-            msg = f"Running affinity prediction for {binder} with {ligand}"
-            click.echo(msg)
+        msg = f"Running affinity prediction for {len(manifest_filtered.records)} input"
+        msg += "s." if len(manifest_filtered.records) > 1 else "."
+        click.echo(msg)
 
-            pred_writer = BoltzAffinityWriter(
-                data_dir=processed.targets_dir,
-                output_dir=pair_dir,
-            )
+        pred_writer = BoltzAffinityWriter(
+            data_dir=processed.targets_dir,
+            output_dir=out_dir / "predictions",
+        )
 
-            data_module = Boltz2InferenceDataModule(
-                manifest=pair_manifest_filtered,
-                target_dir=out_dir / "predictions",
-                msa_dir=processed.msa_dir,
-                mol_dir=mol_dir,
-                num_workers=num_workers,
-                constraints_dir=processed.constraints_dir,
-                template_dir=processed.template_dir,
-                extra_mols_dir=processed.extra_mols_dir,
-                override_method="other",
-                affinity=True,
-            )
+        data_module = Boltz2InferenceDataModule(
+            manifest=manifest_filtered,
+            target_dir=out_dir / "predictions",
+            msa_dir=processed.msa_dir,
+            mol_dir=mol_dir,
+            num_workers=num_workers,
+            constraints_dir=processed.constraints_dir,
+            template_dir=processed.template_dir,
+            extra_mols_dir=processed.extra_mols_dir,
+            override_method="other",
+            affinity=True,
+        )
 
-            predict_affinity_args = {
-                "recycling_steps": 5,
-                "sampling_steps": sampling_steps_affinity,
-                "diffusion_samples": diffusion_samples_affinity,
-                "max_parallel_samples": 1,
-                "write_confidence_summary": False,
-                "write_full_pae": False,
-                "write_full_pde": False,
-            }
-
-            # Load affinity model
-            if affinity_checkpoint is None:
-                affinity_checkpoint = cache / "boltz2_aff.ckpt"
-
-            model_module = Boltz2.load_from_checkpoint(
-                affinity_checkpoint,
-                strict=True,
-                predict_args=predict_affinity_args,
-                map_location="cpu",
-                diffusion_process_args=asdict(diffusion_params),
-                ema=False,
-                pairformer_args=asdict(pairformer_args),
-                msa_args=asdict(msa_args),
-                steering_args={"fk_steering": False, "guidance_update": False},
-                affinity_mw_correction=affinity_mw_correction,
-            )
-            model_module.eval()
+        predict_affinity_args = {
+            "recycling_steps": 5,
+            "sampling_steps": sampling_steps_affinity,
+            "diffusion_samples": diffusion_samples_affinity,
+            "max_parallel_samples": 1,
+            "write_confidence_summary": False,
+            "write_full_pae": False,
+            "write_full_pde": False,
+        }
 
-            trainer.callbacks[0] = pred_writer
-            trainer.predict(
-                model_module,
-                datamodule=data_module,
-                return_predictions=False,
-            )
+        # Load affinity model
+        if affinity_checkpoint is None:
+            affinity_checkpoint = cache / "boltz2_aff.ckpt"
+
+        model_module = Boltz2.load_from_checkpoint(
+            affinity_checkpoint,
+            strict=True,
+            predict_args=predict_affinity_args,
+            map_location="cpu",
+            diffusion_process_args=asdict(diffusion_params),
+            ema=False,
+            pairformer_args=asdict(pairformer_args),
+            msa_args=asdict(msa_args),
+            steering_args={"fk_steering": False, "guidance_update": False},
+            affinity_mw_correction=affinity_mw_correction,
+        )
+        model_module.eval()
+
+        trainer.callbacks[0] = pred_writer
+        trainer.predict(
+            model_module,
+            datamodule=data_module,
+            return_predictions=False,
+        )
 
 
 if __name__ == "__main__":

{boltz_vsynthes-1.0.9.dist-info → boltz_vsynthes-1.0.10.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: boltz-vsynthes
-Version: 1.0.9
-Summary: Boltz for V-Synthes
+Version: 1.0.10
+Summary: Boltz for VSYNTHES
 Requires-Python: <3.13,>=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE

{boltz_vsynthes-1.0.9.dist-info → boltz_vsynthes-1.0.10.dist-info}/RECORD

@@ -1,8 +1,8 @@
 boltz/__init__.py,sha256=F_-so3S40iZrSZ89Ge4TS6aZqwWyZXq_H4AXGDlbA_g,187
-boltz/main.py,sha256=VpCVMACmYA4nsJ9XFuh6JUFR0pdaZuqPWefjF5-Uh7U,42439
+boltz/main.py,sha256=fFXeW6PmVsbZtx0EVGBiczf3ulncuheeai1wpRVEhOI,40803
 boltz/data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 boltz/data/const.py,sha256=1M-88Z6HkfKY6MkNtqcj3b9P-oX9xEXluh3qM_u8dNU,26779
-boltz/data/mol.py,sha256=kPytx81filtBASGp7BOf9INvMqIijQaSh8HgU7JQsJ0,34398
+boltz/data/mol.py,sha256=maOpPHEGX1VVXCIFY6pQNGF7gUBZPAfgSvuPf2QO1yc,34268
 boltz/data/pad.py,sha256=O4CGOOc5TwFuuWeP7hKjMIIsljdfLj-VJtXQeVXFx8s,2066
 boltz/data/types.py,sha256=4w9brpOCQe16AyByNrxz7pjIzrgzFNihtik3aaHvKaE,21965
 boltz/data/crop/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -32,13 +32,16 @@ boltz/data/module/training.py,sha256=iNzmq9ufs20S4M947CCzdYzGTFjmCTf2tFExJ2PtXnA
 boltz/data/module/trainingv2.py,sha256=ZsYUHYXxfuPgIpbTwCj5QLO0XK__xjsqIw6GARSNGW0,21276
 boltz/data/msa/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 boltz/data/msa/mmseqs2.py,sha256=Im3s0h9lQVl-bXDfn4T6X6bxhLyF3XEyUXDjWFCjsvs,8202
-boltz/data/parse/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+boltz/data/parse/__init__.py,sha256=28ltwqi_0kqIjgnjUr7b730rqcEykh73rTYph7Mt3n8,642
 boltz/data/parse/a3m.py,sha256=I5nD16kYVW1NPKeLEMm7I4GnEQrtZk9bFtxw89wmKi0,3318
 boltz/data/parse/csv.py,sha256=Hcq8rJW2njczahEr8jfd_o-zxLaNSgJ3YIoC9srIqpw,2518
 boltz/data/parse/fasta.py,sha256=taI4s_CqPtyF0XaLJAsVAJHCL0GXm2g1g8Qeccdxikk,3906
 boltz/data/parse/mmcif.py,sha256=25kEXCkx-OuaawAs7cdz0fxdRu5_CCO0AV00u84PrjQ,36822
 boltz/data/parse/mmcif_with_constraints.py,sha256=WHYZckSqUwu-Nb9vmVmxHmC7uxwVrF7AVUeVKsc5wGQ,51473
-boltz/data/parse/schema.py,sha256=5VANtvxFZ0FTelESWHA58QJ810XVfSdXHSB8YtJVCuw,37097
+boltz/data/parse/pdb.py,sha256=2Xurs2uzgNcwz_TsGYw0UhTkVdVGFTBbRz6HWledTBM,1793
+boltz/data/parse/pdb_download.py,sha256=JapOOccbxT84964VRZiZ8NEzWbKdiWVpA0UbWhVSsZE,2916
+boltz/data/parse/schema.py,sha256=gnHZBy0Io2Ecrw3KAD1lE1-cKnWL4ypKUI3EmeV5FDQ,59566
+boltz/data/parse/sdf.py,sha256=myFA3bL6MkdPdMFfZHotxJ8yNMGpsc_u6w06YFadeiw,1364
 boltz/data/parse/yaml.py,sha256=GRFRMtDD4PQ4PIpA_S1jj0vRaEu2LlZd_g4rN1zUrNo,1505
 boltz/data/sample/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 boltz/data/sample/cluster.py,sha256=9Sx8qP7zGZOAyEspwYFtCTbGTBZnuN-zfCKFbbA_6oI,8175
@@ -104,9 +107,9 @@ boltz/model/optim/scheduler.py,sha256=nB4jz0CZ4pR4n08LQngExL_pNycIdYI8AXVoHPnZWQ
 boltz/model/potentials/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 boltz/model/potentials/potentials.py,sha256=vev8Vjfs-ML1hyrdv_R8DynG4wSFahJ6nzPWp7CYQqw,17507
 boltz/model/potentials/schedules.py,sha256=m7XJjfuF9uTX3bR9VisXv1rvzJjxiD8PobXRpcBBu1c,968
-boltz_vsynthes-1.0.9.dist-info/licenses/LICENSE,sha256=8GZ_1eZsUeG6jdqgJJxtciWzADfgLEV4LY8sKUOsJhc,1102
-boltz_vsynthes-1.0.9.dist-info/METADATA,sha256=_HnBtfMTbZT71l94bMVcMEEKq0InYcmMnuVFO0NQSHc,7171
-boltz_vsynthes-1.0.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-boltz_vsynthes-1.0.9.dist-info/entry_points.txt,sha256=n5a5I35ntu9lmyr16oZgHPFY0b0YxjiixY7m7nbMTLc,41
-boltz_vsynthes-1.0.9.dist-info/top_level.txt,sha256=MgU3Jfb-ctWm07YGMts68PMjSh9v26D0gfG3dFRmVFA,6
-boltz_vsynthes-1.0.9.dist-info/RECORD,,
+boltz_vsynthes-1.0.10.dist-info/licenses/LICENSE,sha256=8GZ_1eZsUeG6jdqgJJxtciWzADfgLEV4LY8sKUOsJhc,1102
+boltz_vsynthes-1.0.10.dist-info/METADATA,sha256=Xwu6e2a0v7LV6dLrEZpRt869aeHDgPhGJ8lbRDkXtY0,7171
+boltz_vsynthes-1.0.10.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+boltz_vsynthes-1.0.10.dist-info/entry_points.txt,sha256=n5a5I35ntu9lmyr16oZgHPFY0b0YxjiixY7m7nbMTLc,41
+boltz_vsynthes-1.0.10.dist-info/top_level.txt,sha256=MgU3Jfb-ctWm07YGMts68PMjSh9v26D0gfG3dFRmVFA,6
+boltz_vsynthes-1.0.10.dist-info/RECORD,,