rowan-python 2.1.6__py3-none-any.whl → 2.1.8__py3-none-any.whl

rowan/rowan_rdkit/chem_utils.py

@@ -844,7 +844,7 @@ async def _single_conformers(
         raise NoConformersError("This molecule has no conformers")
 
     sorted_data = sorted(
-        zip(data["energies"], data["conformer_uuids"]),
+        zip(data["energies"], data["conformer_uuids"], strict=True),
         key=lambda x: x[0],
     )
 

rowan/workflow.py

@@ -1,14 +1,20 @@
+import logging
 import time
 from datetime import datetime
+from pathlib import Path
 from typing import Any, Literal, Self, TypeAlias
 
 import stjames
 from pydantic import BaseModel, Field
 from rdkit import Chem
+from stjames.optimization.freezing_string_method import FSMSettings
 
 from .protein import Protein
 from .utils import api_client
 
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+
 RdkitMol: TypeAlias = Chem.rdchem.Mol | Chem.rdchem.RWMol
 StJamesMolecule: TypeAlias = stjames.Molecule
 
@@ -215,6 +221,25 @@ class Workflow(BaseModel):
             response = client.delete(f"/workflow/{self.uuid}/delete_workflow_data")
             response.raise_for_status()
 
+    def download_msa_files(self, msa_format: stjames.MSAFormat, path: Path | None = None) -> None:
+        if self.workflow_type != "msa":
+            raise ValueError("This workflow is not an MSA workflow.")
+
+        if path is None:
+            path = Path.cwd()
+
+        if not path.exists():
+            path.mkdir(parents=True, exist_ok=True)
+
+        with api_client() as client:
+            response = client.get(
+                f"/workflow/{self.uuid}/get_msa_files", params={"msa_format": msa_format.value}
+            )
+            response.raise_for_status()
+
+        with open(path / f"{self.name}-msa.tar.gz", "wb") as f:
+            f.write(response.content)
+
 
 def submit_workflow(
     workflow_type: stjames.WORKFLOW_NAME,
@@ -271,6 +296,75 @@ def submit_workflow(
         return Workflow(**response.json())
 
 
+def batch_submit_workflow(
+    workflow_type: stjames.WORKFLOW_NAME,
+    workflow_data: dict[str, Any] | None = None,
+    initial_molecules: list[dict[str, Any] | StJamesMolecule | RdkitMol] | None = None,
+    initial_smileses: list[str] | None = None,
+    names: list[str] | None = None,
+    folder_uuid: str | None = None,
+    max_credits: int | None = None,
+) -> list[Workflow]:
+    """
+    Submits a batch of workflows to the API. Each workflow will be submitted with the
+    same workflow type, workflow data, and folder UUID, but with different initial molecules and/or
+    SMILES strings.
+
+    :param workflow_type: The type of workflow to submit.
+    :param workflow_data: A dictionary containing the data required to run the workflow.
+    :param initial_molecules: A list of molecule objects to use as the initial molecules in the
+    workflows.
+    At least one of a molecule or SMILES must be provided.
+    :param initial_smileses: A list of SMILES strings to use as the initial molecules in the
+    workflows.
+    At least one of a molecule or SMILES must be provided.
+    :param names: A list of names to give to the workflows.
+    :param folder_uuid: The UUID of the folder to store the workflow in.
+    :param max_credits: The maximum number of credits to use for the workflow. This applies per
+    workflow, not for the batch.
+    :return: A list of Workflow objects representing the submitted workflows.
+    :raises ValueError: If neither `initial_smiles` nor a valid `initial_molecule` is provided.
+    :raises HTTPError: If the API request fails.
+    """
+    if workflow_type not in stjames.WORKFLOW_MAPPING:
+        raise ValueError(
+            "Invalid workflow type. Must be one of:\n    " + "\n    ".join(stjames.WORKFLOW_MAPPING)
+        )
+
+    if initial_molecules and initial_smileses:
+        raise ValueError(
+            "You must provide either `initial_molecules` or `initial_smileses`, but not both."
+        )
+
+    if names:
+        if initial_molecules and len(names) != len(initial_molecules):
+            logger.warning(
+                "The number of names is not the same as the number of initial "
+                "molecules. Generic names of the form 'Batch Workflow {i}' "
+                "will be used."
+            )
+        if initial_smileses and len(names) != len(initial_smileses):
+            logger.warning(
+                "The number of names is not the same as the number of initial SMILES."
+                "Generic names of the form 'Batch Workflow {i}' will be used."
+            )
+
+    data = {
+        "names": names,
+        "folder_uuid": folder_uuid,
+        "workflow_type": workflow_type,
+        "workflow_data": workflow_data,
+        "max_credits": max_credits,
+        "initial_molecules": initial_molecules,
+        "initial_smileses": initial_smileses,
+    }
+
+    with api_client() as client:
+        response = client.post("/workflow/batch_submit", json=data)
+        response.raise_for_status()
+        return [Workflow(**workflow_data) for workflow_data in response.json()]
+
+
 def retrieve_workflow(uuid: str) -> Workflow:
     """
     Retrieves a workflow from the API.
@@ -285,16 +379,21 @@ def retrieve_workflow(uuid: str) -> Workflow:
         return Workflow(**response.json())
 
 
-def retrieve_calculation_molecules(uuid: str) -> list[dict[str, Any]]:
+def retrieve_calculation_molecules(
+    uuid: str, return_frequencies: bool = False
+) -> list[dict[str, Any]]:
     """
     Retrieves a list of molecules from a calculation.
 
     :param uuid: The UUID of the calculation to retrieve molecules from.
+    :param return_frequencies: Whether to return the frequencies of the molecules.
     :return: A list of dictionaries representing the molecules in the calculation.
     :raises HTTPError: If the API request fails.
     """
     with api_client() as client:
-        response = client.get(f"/calculation/{uuid}/molecules")
+        response = client.get(
+            f"/calculation/{uuid}/molecules", params={"return_frequencies": return_frequencies}
+        )
         response.raise_for_status()
         return response.json()
 
@@ -352,9 +451,10 @@ def list_workflows(
 def submit_basic_calculation_workflow(
     initial_molecule: dict[str, Any] | StJamesMolecule | RdkitMol,
     method: stjames.Method | str = "uma_m_omol",
+    basis_set: stjames.BasisSet | str | None = None,
     tasks: list[str] | None = None,
     mode: str = "auto",
-    engine: str = "omol25",
+    engine: str | None = None,
     name: str = "Basic Calculation Workflow",
     folder_uuid: str | None = None,
     max_credits: int | None = None,
@@ -364,7 +464,7 @@ def submit_basic_calculation_workflow(
 
     :param initial_molecule: The molecule to perform the calculation on.
     :param method: The method to use for the calculation.
-    See [list of available methods](https://github.com/rowansci/stjames-public/blob/master/stjames/method.py)
+    :param basis_set: The basis_set to use (if any).
     for options.
     :param tasks: A list of tasks to perform for the calculation.
     :param mode: The mode to run the calculation in. See [list of available modes](https://github.com/rowansci/stjames-public/blob/master/stjames/mode.py)
@@ -391,10 +491,11 @@ def submit_basic_calculation_workflow(
         initial_molecule=initial_molecule,
         settings=stjames.Settings(
             method=method,
+            basis_set=basis_set,
             tasks=tasks,
             mode=mode,
         ),
-        engine=engine,
+        engine=engine or method.default_engine(),
     )
 
     data = {
@@ -543,8 +644,10 @@ def submit_solubility_workflow(
 
 
 def submit_pka_workflow(
-    initial_molecule: dict[str, Any] | StJamesMolecule | RdkitMol,
+    initial_molecule: dict[str, Any] | StJamesMolecule | RdkitMol | str,
     pka_range: tuple[int, int] = (2, 12),
+    method: Literal["aimnet2_wagen2024", "chemprop_nevolianis2025"] = "aimnet2_wagen2024",
+    solvent: str = "water",
     deprotonate_elements: list[int] | None = None,
     protonate_elements: list[int] | None = None,
     mode: str = "careful",
@@ -556,7 +659,10 @@ def submit_pka_workflow(
     Submits a pKa workflow to the API.
 
     :param initial_molecule: The molecule to calculate the pKa of.
+        Valid input types include `stjames.Molecule`, RDKit molecule, and SMILES.
     :param pka_range: The range of pKa values to calculate.
+    :param method: The algorithm used to compute pKa values.
+    :param solvent: The solvent in which pKa values will be computed.
     :param deprotonate_elements: The elements to deprotonate. Given by atomic number.
     :param protonate_elements: The elements to protonate. Given by atomic number.
     :param mode: The mode to run the calculation in. See
@@ -568,20 +674,30 @@ def submit_pka_workflow(
     :return: A Workflow object representing the submitted workflow.
     :raises requests.HTTPError: if the request to the API fails.
     """
-    if isinstance(initial_molecule, StJamesMolecule):
-        initial_molecule = initial_molecule.model_dump()
+    initial_smiles: str = ""
+    initial_stjames_mol: StJamesMolecule | None = None
+
+    if isinstance(initial_molecule, dict):
+        initial_stjames_mol = StJamesMolecule.model_validate(initial_molecule)
+    elif isinstance(initial_molecule, StJamesMolecule):
+        initial_stjames_mol = initial_molecule
     elif isinstance(initial_molecule, RdkitMol):
-        initial_molecule = StJamesMolecule.from_rdkit(initial_molecule, cid=0)
+        initial_stjames_mol = StJamesMolecule.from_rdkit(initial_molecule, cid=0)
+    elif isinstance(initial_molecule, str):
+        initial_smiles = initial_molecule
 
     protonate_elements = protonate_elements or [7]
     deprotonate_elements = deprotonate_elements or [7, 8, 16]
 
     workflow = stjames.pKaWorkflow(
-        initial_molecule=initial_molecule,
+        initial_molecule=initial_stjames_mol,
+        initial_smiles=initial_smiles,
         pka_range=pka_range,
         deprotonate_elements=deprotonate_elements,
         protonate_elements=protonate_elements,
         mode=mode,
+        solvent=solvent,
+        microscopic_pka_method=method,
     )
 
     data = {
@@ -589,7 +705,8 @@ def submit_pka_workflow(
         "folder_uuid": folder_uuid,
         "workflow_type": "pka",
         "workflow_data": workflow.model_dump(),
-        "initial_molecule": initial_molecule,
+        "initial_molecule": initial_stjames_mol.model_dump() if initial_stjames_mol else None,
+        "initial_smiles": initial_smiles,
         "max_credits": max_credits,
     }
 
@@ -792,7 +909,7 @@ def submit_descriptors_workflow(
 def submit_scan_workflow(
     initial_molecule: dict[str, Any] | StJamesMolecule | RdkitMol,
     scan_settings: stjames.ScanSettings | dict[str, Any] | None = None,
-    calculation_engine: str = "omol25",
+    calculation_engine: str | None = None,
     calculation_method: stjames.Method | str = "uma_m_omol",
     wavefront_propagation: bool = True,
     name: str = "Scan Workflow",
@@ -835,7 +952,7 @@ def submit_scan_workflow(
         initial_molecule=initial_molecule,
         scan_settings=scan_settings,
         calc_settings=calc_settings,
-        calc_engine=calculation_engine,
+        calc_engine=calculation_engine or calculation_method.default_engine(),
         wavefront_propagation=wavefront_propagation,
     )
 
@@ -911,7 +1028,6 @@ def submit_macropka_workflow(
 def submit_irc_workflow(
     initial_molecule: dict[str, Any] | StJamesMolecule | RdkitMol | None = None,
     method: stjames.Method | str = "uma_m_omol",
-    engine: str = "omol25",
     preopt: bool = True,
     step_size: float = 0.05,
     max_irc_steps: int = 30,
@@ -926,7 +1042,6 @@ def submit_irc_workflow(
     :param method: The computational method to use for the IRC calculation.
     See [list of available methods](https://github.com/rowansci/stjames-public/blob/master/stjames/method.py)
     for options.
-    :param engine: The computational engine to use for the calculation. See [list of available engines](https://github.com/rowansci/stjames-public/blob/master/stjames/engine.py)
     :param preopt: Whether to perform a pre-optimization of the molecule.
     :param step_size: The step size to use for the IRC calculation.
     :param max_irc_steps: The maximum number of IRC steps to perform.
@@ -953,12 +1068,12 @@ def submit_irc_workflow(
             corrections=[],
             mode="auto",
         ),
-        engine=engine,
         preopt=preopt,
         step_size=step_size,
         max_irc_steps=max_irc_steps,
         mode="manual",
     )
+
     data = {
         "name": name,
         "folder_uuid": folder_uuid,
@@ -1034,6 +1149,9 @@ def submit_docking_workflow(
     protein: str | Protein,
     pocket: list[list[float]],
     initial_molecule: dict[str, Any] | StJamesMolecule | RdkitMol | None = None,
+    executable: str = "vina",
+    scoring_function: str = "vinardo",
+    exhaustiveness: float = 8,
     do_csearch: bool = False,
     do_optimization: bool = False,
     do_pose_refinement: bool = False,
@@ -1044,15 +1162,18 @@ def submit_docking_workflow(
     """
     Submits a Docking workflow to the API.
 
-    :param protein: The protein to dock. Can be fed as a uuid or a Protein object.
+    :param protein: The protein to dock. Can be input as a uuid or a Protein object.
     :param initial_molecule: The initial molecule to be docked
+    :param executable: Which docking implementation to use.
+    :param scoring_function: Which docking scoring function to use.
+    :param exhaustiveness: Which exhaustiveness to employ.
     :param do_csearch: Whether to perform a conformational search on the ligand.
     :param do_optimization: Whether to perform an optimization on the ligand.
     :param do_pose_refinement: Whether or not to optimize output poses.
     :param name: The name of the workflow.
     :param folder_uuid: The UUID of the folder to place the workflow in.
     :param max_credits: The maximum number of credits to use for the workflow.
-    :return: A Workflow object representing the submitted IRC workflow.
+    :return: A Workflow object representing the submitted docking workflow.
     :raises requests.HTTPError: if the request to the API fails.
     """
 
@@ -1064,6 +1185,12 @@ def submit_docking_workflow(
     if isinstance(protein, Protein):
         protein = protein.uuid
 
+    docking_settings = {
+        "executable": executable,
+        "exhaustiveness": exhaustiveness,
+        "scoring_function": scoring_function,
+    }
+
     workflow = stjames.DockingWorkflow(
         initial_molecule=initial_molecule,
         target_uuid=protein,
@@ -1071,6 +1198,7 @@ def submit_docking_workflow(
         do_csearch=do_csearch,
         do_optimization=do_optimization,
         do_pose_refinement=do_pose_refinement,
+        docking_settings=docking_settings,
     )
 
     data = {
@@ -1229,3 +1357,185 @@ def submit_strain_workflow(
         response = client.post("/workflow", json=data)
         response.raise_for_status()
         return Workflow(**response.json())
+
+
+def submit_double_ended_ts_search_workflow(
+    reactant: dict[str, Any] | StJamesMolecule,
+    product: dict[str, Any] | StJamesMolecule,
+    calculation_settings: stjames.Settings | dict[str, Any] | None = None,
+    search_settings: FSMSettings | dict[str, Any] | None = None,
+    optimize_inputs: bool = False,
+    optimize_ts: bool = True,
+    name: str = "Double-Ended TS Search Workflow",
+    folder_uuid: str | None = None,
+    max_credits: int | None = None,
+) -> Workflow:
+    """
+    Submits a double-ended transition state search workflow to the API.
+
+    :param reactant: reactant Molecule.
+    :param product: product Molecule.
+    :param calculation_settings: Settings to use for calculations.
+    :param search_settings: settings to use for the transition state search.
+    :param optimize_inputs: Whether to optimize the reactant and product before the search.
+    :param optimize_ts: Whether to optimize the found transition state.
+    :param name: name of the workflow.
+    :param folder_uuid: The UUID of the folder to place the workflow in.
+    :param max_credits: The maximum number of credits to use for the workflow.
+    :return: Workflow object representing the submitted workflow.
+    """
+    workflow = stjames.DoubleEndedTSSearchWorkflow(
+        reactant=reactant,
+        product=product,
+        calculation_settings=calculation_settings,
+        search_settings=search_settings,
+        optimize_inputs=optimize_inputs,
+        optimize_ts=optimize_ts,
+    )
+    data = {
+        "name": name,
+        "folder_uuid": folder_uuid,
+        "workflow_type": "double_ended_ts_search",
+        "workflow_data": workflow.model_dump(),
+        "initial_molecule": reactant if isinstance(reactant, dict) else reactant.model_dump(),
+        "max_credits": max_credits,
+    }
+
+    with api_client() as client:
+        response = client.post("/workflow", json=data)
+        response.raise_for_status()
+        return Workflow(**response.json())
+
+
+def submit_pose_analysis_md_workflow(
+    protein: str | Protein,
+    initial_smiles: str,
+    num_trajectories: int = 1,
+    simulation_time_ns: int = 10,
+    ligand_residue_name: str = "LIG",
+    name: str = "Pose-Analysis MD Workflow",
+    folder_uuid: str | None = None,
+    max_credits: int | None = None,
+) -> Workflow:
+    """
+    Submits a pose-analysis MD workflow to the API.
+
+    :param protein: The *holo* protein on which MD will be run.
+        Can be input as a uuid or a Protein object.
+    :param initial_smiles: The SMILES for the ligand.
+    :param num_trajectories: The number of trajectories to run.
+    :param simulation_time_ns: How long to run the simulation for, in nanoseconds.
+    :param ligand_residue_name: The name of the residue corresponding to the ligand.
+    :param name: The name of the workflow.
+    :param folder_uuid: The UUID of the folder to place the workflow in.
+    :param max_credits: The maximum number of credits to use for the workflow.
+    :return: A Workflow object representing the submitted workflow.
+    :raises requests.HTTPError: if the request to the API fails.
+    """
+
+    if isinstance(protein, Protein):
+        protein = protein.uuid
+
+    workflow = stjames.PoseAnalysisMolecularDynamicsWorkflow(
+        protein_uuid=protein,
+        initial_smiles=initial_smiles,
+        num_trajectories=num_trajectories,
+        simulation_time_ns=simulation_time_ns,
+        ligand_residue_name=ligand_residue_name,
+    )
+
+    data = {
+        "name": name,
+        "folder_uuid": folder_uuid,
+        "workflow_type": "pose_analysis_md",
+        "workflow_data": workflow.model_dump(serialize_as_any=True),
+        "initial_smiles": initial_smiles,
+        "max_credits": max_credits,
+    }
+
+    with api_client() as client:
+        response = client.post("/workflow", json=data)
+        response.raise_for_status()
+        return Workflow(**response.json())
+
+
+def submit_batch_docking_workflow(
+    smiles_list: list[str],
+    protein: str | Protein,
+    pocket: list[list[float]],
+    executable: str = "qvina2",
+    scoring_function: str = "vina",
+    exhaustiveness: float = 8,
+    name: str = "Batch Docking Workflow",
+    folder_uuid: str | None = None,
+    max_credits: int | None = None,
+) -> Workflow:
+    """
+    Submits a batch docking workflow to the API.
+
+    :param smiles_list: The SMILES strings to dock.
+    :param protein: The protein to dock. Can be input as a uuid or a Protein object.
+    :param executable: Which docking implementation to use.
+    :param scoring_function: Which docking scoring function to use.
+    :param exhaustiveness: Which exhaustiveness to employ.
+    :param name: The name of the workflow.
+    :param folder_uuid: The UUID of the folder to place the workflow in.
+    :param max_credits: The maximum number of credits to use for the workflow.
+    :return: A Workflow object representing the submitted batch docking workflow.
+    :raises requests.HTTPError: if the request to the API fails.
+    """
+
+    docking_settings = {
+        "executable": executable,
+        "exhaustiveness": exhaustiveness,
+        "scoring_function": scoring_function,
+    }
+
+    workflow = stjames.BatchDockingWorkflow(
+        initial_smiles_list=smiles_list,
+        target=protein,
+        pocket=pocket,
+        docking_settings=docking_settings,
+    )
+
+    data = {
+        "name": name,
+        "folder_uuid": folder_uuid,
+        "workflow_type": "batch_docking",
+        "workflow_data": workflow.model_dump(serialize_as_any=True),
+        "max_credits": max_credits,
+    }
+
+    with api_client() as client:
+        response = client.post("/workflow", json=data)
+        response.raise_for_status()
+        return Workflow(**response.json())
+
+
+def submit_msa_workflow(
+    initial_protein_sequences: list[stjames.ProteinSequence | str],
+    output_formats: list[stjames.MSAFormat],
+    name: str = "MSA Workflow",
+    folder_uuid: str | None = None,
+    max_credits: int | None = None,
+) -> Workflow:
+    """
+    Submits an MSA workflow to the API.
+    """
+    workflow = stjames.MSAWorkflow(
+        initial_protein_sequences=initial_protein_sequences,
+        output_formats=output_formats,
+    )
+
+    data = {
+        "name": name,
+        "folder_uuid": folder_uuid,
+        "workflow_type": "msa",
+        "workflow_data": workflow.model_dump(serialize_as_any=True),
+        "max_credits": max_credits,
+    }
+
+    with api_client() as client:
+        response = client.post("/workflow", json=data)
+        response.raise_for_status()
+        return Workflow(**response.json())

{rowan_python-2.1.6.dist-info → rowan_python-2.1.8.dist-info}/METADATA

@@ -1,17 +1,17 @@
 Metadata-Version: 2.4
 Name: rowan-python
-Version: 2.1.6
+Version: 2.1.8
 Summary: Rowan Python Library
 Project-URL: Homepage, https://github.com/rowansci/rowan-client
 Project-URL: Bug Tracker, https://github.com/rowansci/rowan-client/issues
 Author-email: Corin Wagen <corin@rowansci.com>
 License-File: LICENSE
-Requires-Python: >=3.9
+Requires-Python: >=3.11
 Requires-Dist: httpx
 Requires-Dist: nest-asyncio
 Requires-Dist: rdkit
 Requires-Dist: setuptools
-Requires-Dist: stjames>=0.0.109
+Requires-Dist: stjames>=0.0.125
 Description-Content-Type: text/markdown
 
 # Rowan Python Library

{rowan_python-2.1.6.dist-info → rowan_python-2.1.8.dist-info}/RECORD

@@ -6,10 +6,10 @@ rowan/protein.py,sha256=bMemvLZua_pnTrYOxHFZ4jFlRH9KgpYvtjj5M2__28k,8026
 rowan/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 rowan/user.py,sha256=Dl--NPUPATKCs2VmILsW8HnLiunG0Lxr0n6mKuHm21U,3891
 rowan/utils.py,sha256=64II-cPOe_SFJK302Bm8hP62d_3_CgnTVYCbn3zKT7U,3334
-rowan/workflow.py,sha256=EGcqPv2K-CCt8t_FSVAGTaI7QCM4BJdY--kN4PHvhOo,46749
+rowan/workflow.py,sha256=tPvFXYC9O8Qr_9HVGDzYTgW-3MrFcDLGqbGDzlOq5tI,58562
 rowan/rowan_rdkit/__init__.py,sha256=EATX2VRzywzKxqkpCUMTf7RNQLkWsfi5VcCNDW6EIiw,503
-rowan/rowan_rdkit/chem_utils.py,sha256=i7-EmAcmvHYtc9NiZblLY_k2DoQKofAZo5KT2qtkUCI,34775
-rowan_python-2.1.6.dist-info/METADATA,sha256=rNw5EUh2Dz3xfBKUtFHtIPykxSVegqydghdhhq-q3XI,1599
-rowan_python-2.1.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-rowan_python-2.1.6.dist-info/licenses/LICENSE,sha256=i05z7xEhyrg6f8j0lR3XYjShnF-MJGFQ-DnpsZ8yiVI,1084
-rowan_python-2.1.6.dist-info/RECORD,,
+rowan/rowan_rdkit/chem_utils.py,sha256=sKCzul2e0ldVYTBImhTwso7ddNgPKmvS-OmvCEjVJH0,34788
+rowan_python-2.1.8.dist-info/METADATA,sha256=H4imf_mPDAVYyT8l7AYJsC947qE2yfu0labnvuhDdX4,1600
+rowan_python-2.1.8.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+rowan_python-2.1.8.dist-info/licenses/LICENSE,sha256=i05z7xEhyrg6f8j0lR3XYjShnF-MJGFQ-DnpsZ8yiVI,1084
+rowan_python-2.1.8.dist-info/RECORD,,