### Importing Example Data Directory - Deep Origin Python

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/dd/tutorial/getting-started.md

Imports the `EXAMPLE_DATA_DIR` constant from the `deeporigin.drug_discovery` module, providing a path to built-in example data for testing and exploration.

```python
from deeporigin.drug_discovery import EXAMPLE_DATA_DIR
```

--------------------------------

### Example Output of Deep Origin Tool Run Command (Bash)

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/tools/ligand-prep-meeko.md

This bash snippet shows the typical console output message displayed after successfully starting a tool run using the `deeporigin.tools.run` function in Python. It confirms that the job has started and provides its unique identifier (Job ID).

```bash
🧬 Job started with ID: 9f7a3741-e392-45fb-a349-804b7fca07d7
```

--------------------------------

### Connecting Complex to Deep Origin - Python

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/dd/tutorial/getting-started.md

Calls the `connect` method on the `Complex` object. This method uploads the ligand SDF files to Deep Origin and assigns unique IDs to the ligands, preparing the complex for subsequent operations like docking or simulations.

```python
sim.connect()
```

--------------------------------

### Viewing Ligands in 3D Table - Deep Origin Python

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/dd/tutorial/getting-started.md

Calls the `show_ligands` method with the argument "3D" to display a table of 3D structures for all ligands in the complex, providing a different visualization perspective compared to the default 2D view.

```python
sim.show_ligands("3D")
```

--------------------------------

### Example Tool Run Output Message (Bash)

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/tools/pdb-to-pdbqt.md

This Bash snippet shows an example of the output message printed to the console when the `run.pdb_pdbqt_converter` function successfully starts a job on Deep Origin. The message includes the unique ID assigned to the tool run.

```bash
🧬 Job started with ID: 9f7a3741-e392-45fb-a349-804b7fca07d7
```

--------------------------------

### Creating Complex Object from Directory - Deep Origin Python

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/dd/tutorial/getting-started.md

Creates an instance of the `Complex` class by loading data from a specified directory, typically containing protein and ligand files. Uses the `EXAMPLE_DATA_DIR` constant for demonstration.

```python
# here, we're using the example data directory
sim = Complex.from_dir(EXAMPLE_DATA_DIR)
```

--------------------------------

### Example Output of Deep Origin Variables Install (Bash)

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/compute-hub/how-to/variables.md

Illustrates the typical output displayed after successfully running the `deeporigin variables install` command. The output summarizes the changes made to variables, indicating how many were modified, added, deleted, or remained unmodified.

```bash
No variables were modified
No variables were added
No variables were deleted
1 variables were unmodified:
  EnvironmentVariable: foo
```

--------------------------------

### Example Output of Deep Origin Run Start (Bash)

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/tools/vina.md

Shows the typical output message printed to the console when a Deep Origin tool run is successfully started. It includes the unique job ID assigned to the run.

```bash
🧬 Job started with ID: 9f7a3741-e392-45fb-a349-804b7fca07d7
```

--------------------------------

### Viewing Ligands in 2D Table - Deep Origin Python

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/dd/tutorial/getting-started.md

Calls the `show_ligands` method on the `Complex` object to display a table of 2D structures and associated properties for all ligands in the complex, useful for quick visual inspection.

```python
sim.show_ligands()
```

--------------------------------

### Installing Deep Origin Client for Development (Make)

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/README.md

Set up the development environment by creating a virtual environment and installing the package using the make command. Requires make v4.4 or higher.

```bash
make install
```

--------------------------------

### Example Running Draco Tool with Specific Parameters (Python)

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/tools/draco.md

Provides a concrete example of how to initiate a Draco tool run using specific database, row, and column names as shown in the documentation's example setup.

```python
from deeporigin.tools import run

job_id = run.draco(
    database_id="draco_use_case",
    row_id="draco-use-case-1",
    input_file_column_name="Document"
    output_column_name="Result"
)
```

--------------------------------

### Creating Project Directory (Windows)

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/install.md

Creates a new directory for the project and navigates into it. This directory will contain the project files and the uv environment.

```bash
mkdir do-client
cd do-client
```

--------------------------------

### Serving Deep Origin Client Documentation

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/install.md

Compiles and serves the documentation for the Deep Origin client package locally using make. This allows developers to preview documentation changes.

```bash
make docs-serve
```

--------------------------------

### Installing Deep Origin as uv Tool (Windows)

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/install.md

Installs the `deeporigin` package as a uv tool, allowing it to be run directly from the command line using `uv tool run deeporigin ...`.

```bash
uv tool install deeporigin
```

--------------------------------

### Viewing Protein Structure - Deep Origin Python

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/dd/tutorial/getting-started.md

Calls the `show` method on the `protein` attribute of the `Complex` object to generate a 3D visualization of the protein structure, typically in a Jupyter environment.

```python
sim.protein.show()
```

--------------------------------

### Creating Project Directory (macOS/Linux)

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/install.md

Creates a new directory for the project and navigates into it. This directory will contain the project files and the uv environment.

```bash
mkdir do-client
cd do-client
```

--------------------------------

### Inspecting Complex Object - Deep Origin Python

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/dd/tutorial/getting-started.md

Displays the string representation of the `Complex` object, showing a summary of its contents, such as the protein file and the number of ligands loaded.

```python
sim
```

--------------------------------

### Installing uv via PowerShell (Windows)

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/install.md

Downloads and executes the uv installer script using PowerShell. This command installs the uv package and environment manager on Windows.

```bash
powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"
```

--------------------------------

### Installing Deep Origin Client via Script (macOS/Linux)

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/install.md

Downloads and executes an installation script from the Deep Origin client documentation site. This script is used for the recommended installation method on macOS/Linux.

```bash
curl -LsSf https://client-docs.deeporigin.io/install.sh | sh
```

--------------------------------

### Initializing uv Environment (Windows)

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/install.md

Initializes a new uv environment in the current directory. This sets up the necessary files for uv to manage dependencies and Python versions.

```bash
uv init
```

--------------------------------

### Running Deep Origin Client Tests

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/install.md

Executes the test suite for the Deep Origin client package using make. This verifies the functionality after installation or code changes.

```bash
make test
```

--------------------------------

### Importing Complex Class - Deep Origin Python

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/dd/tutorial/getting-started.md

Imports the `Complex` class from the `deeporigin.drug_discovery` module, which is central to the Drug Discovery toolbox functionality.

```python
from deeporigin.drug_discovery import Complex
```

--------------------------------

### Listing Ligands - Deep Origin Python

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/dd/tutorial/getting-started.md

Accesses the `ligands` attribute of the `Complex` object, which returns a list of `Ligand` objects contained within the complex, allowing for inspection of individual ligand details.

```python
sim.ligands
```

--------------------------------

### Running Jupyter Lab with uv (Windows)

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/install.md

Launches a Jupyter Lab instance using the Python environment managed by uv in the current directory. The `--with jupyter` flag ensures Jupyter is available in the environment.

```bash
uv run --with jupyter jupyter lab
```

--------------------------------

### Installing Deep Origin Python Client (pip)

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/README.md

Install the deeporigin package using pip. It is recommended to do this within a virtual environment.

```bash
pip install deeporigin
```

--------------------------------

### Example Draco Job ID Output (Bash)

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/tools/draco.md

Shows an example of the output message printed to the console when a Draco job is successfully started, including the generated job ID.

```bash
🧬 Job started with ID: 9f7a3741-e392-45fb-a349-804b7fca07d7
```

--------------------------------

### Installing Deep Origin Client in Editable Mode

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/install.md

Installs the Deep Origin client package from the cloned source code in 'editable' mode using make. Changes to the source code will be reflected immediately.

```bash
make install
```

--------------------------------

### Running Jupyter Lab with uv (macOS/Linux)

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/install.md

Launches a Jupyter Lab instance using the Python environment managed by uv in the current directory. The `--with jupyter` flag ensures Jupyter is available in the environment.

```bash
uv run --with jupyter jupyter lab
```

--------------------------------

### Adding Deep Origin Package with uv (Windows)

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/install.md

Adds the `deeporigin` package to the current uv environment. This installs the Deep Origin Python client and its dependencies.

```bash
uv add deeporigin
```

--------------------------------

### Example RBFE Tool Parameters (JSON)

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/dd/tutorial/rbfe.md

This JSON object provides an example structure and default values for the parameters used by the end-to-end RBFE tool. It details settings for complex, ligand, and solvation system preparation, as well as the RBFE simulation itself, including FEP windows and MD options.

```json
{
    "complex_prep": {
        "include_ligands": 1,
        "include_protein": 1,
        "sysprep_params": {
            "charge_method": "bcc",
            "do_loop_modelling": false,
            "force_field": "ff14SB",
            "is_lig_protonated": false,
            "is_protein_protonated": false,
            "keep_waters": false,
            "lig_force_field": "gaff2",
            "padding": 1.0,
            "save_gmx_files": false
        },
        "test_run": 0,
        "thread_pinning": 1,
        "thread_pinning_offset": 0
    },
    "ligand1_prep": {
        "include_ligands": 1,
        "include_protein": 0,
        "sysprep_params": {
            "charge_method": "bcc",
            "do_loop_modelling": false,
            "force_field": "ff14SB",
            "is_lig_protonated": false,
            "is_protein_protonated": false,
            "keep_waters": false,
            "lig_force_field": "gaff2",
            "padding": 1.0,
            "save_gmx_files": false
        },
        "test_run": 0,
        "thread_pinning": 1,
        "thread_pinning_offset": 0
    },
    "ligand2_prep": {
        "include_ligands": 1,
        "include_protein": 0,
        "sysprep_params": {
            "charge_method": "bcc",
            "do_loop_modelling": false,
            "force_field": "ff14SB",
            "is_lig_protonated": false,
            "is_protein_protonated": false,
            "keep_waters": false,
            "lig_force_field": "gaff2",
            "padding": 1.0,
            "save_gmx_files": false
        },
        "test_run": 0,
        "thread_pinning": 1,
        "thread_pinning_offset": 0
    },
    "rbfe": {
        "add_fep_repeats": 0,
        "amend": "__NO_AMEND",
        "annihilate": true,
        "atom_mapping_threshold": 0.01,
        "em_all": true,
        "em_solvent": true,
        "emeq_md_options": {
            "T": 298.15,
            "cutoff": 0.9,
            "fourier_spacing": 0.12,
            "hydrogen_mass": 2.0,
            "Δt": 0.004
        },
        "fep_windows": [
            {
                "restraints_A": [
                    0.0,
                    0.01,
                    0.025,
                    0.05,
                    0.1,
                    0.35,
                    0.5,
                    0.75,
                    1.0
                ]
            },
            {
                "coul_A": [
                    1.0,
                    0.8,
                    0.6,
                    0.4,
                    0.2,
                    0.0
                ]
            },
            {
                "vdw_A": [
                    1.0,
                    0.9,
                    0.8,
                    0.7,
                    0.6,
                    0.5,
                    0.4,
                    0.3,
                    0.2,
                    0.1,
                    0.0
                ]
            }
        ],
        "mbar": 1,
        "npt_reduce_restraints_ns": 2.0,
        "nvt_heating_ns": 1.0,
        "prod_md_options": {
            "T": 298.15,
            "barostat": "MonteCarloBarostat",
            "barostat_exchange_interval": 500,
            "cutoff": 0.9,
            "fourier_spacing": 0.12,
            "hydrogen_mass": 2.0,
            "integrator": "BAOABIntegrator",
            "Δt": 0.004
        },
        "repeats": 1,
        "run_name": "binding",
        "skip_emeq": "__NO",
        "softcore_alpha": 0.5,
        "steps": 1250000,
        "system": "complex",
        "test_run": 0,
        "thread_pinning": 1,
        "thread_pinning_offset": 0,
        "threads": 0,
        "workers": 0
    },
    "solvation1": {
        "add_fep_repeats": 0,
        "amend": "__NO_AMEND",
        "annihilate": true,
        "atom_mapping_threshold": 0.01,
        "em_all": true,
        "em_solvent": true,
        "emeq_md_options": {
            "T": 298.15,
            "cutoff": 0.9,
            "fourier_spacing": 0.12,
            "hydrogen_mass": 2.0,
            "Δt": 0.004
        },
        "fep_windows": [
            {

```

--------------------------------

### Installing Python with uv (Windows)

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/install.md

Installs a specific version of Python (3.13 in this case) into the current uv environment. uv manages isolated Python installations.

```bash
uv python install 3.13
```

--------------------------------

### Starting AutoDock Vina Run on Deep Origin (Python)

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/tools/vina.md

Demonstrates how to initiate an AutoDock Vina run using the Deep Origin Python SDK. It takes database and row identifiers, parameter dictionaries, and column names as input.

```python
from deeporigin.tools import run

job_id = run.autodock_vina(
    database_id="<your-db-name>",
    row_id="<row-name>",
    search_space=search_space,
    docking=docking,
    output_column_name="<output-column-name>",
    receptor_column_name="<receptor-column-name>",
    ligand_column_name="<ligand-column-name>",
)
```

--------------------------------

### Checking Make Version

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/install.md

Verifies the installed version of GNU make. This is a prerequisite for installing the Deep Origin client for developers.

```bash
make --version
```

--------------------------------

### Running Multiple Ligands ABFE Workflow (Python)

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/dd/tutorial/abfe.md

Illustrates how to start an end-to-end ABFE simulation for a list of specified ligands by passing their IDs in a list to the `run_end_to_end` method. Each ligand will be processed in parallel on separate instances.

```Python
sim.abfe.run_end_to_end(ligand_ids=["Ligands-1", "Ligands-2"])
```

--------------------------------

### Get current user account info using DeepOrigin Python SDK

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/platform/how-to/user-info.md

Imports the `users` module from the `deeporigin.platform` package and calls the `get_account()` function to retrieve details about the currently authenticated user. The function returns a dictionary containing user attributes like email, name, company, etc., along with the user ID and type. An example response structure is provided in the text.

```python
from deeporigin.platform import users
users.get_account()
```

--------------------------------

### Get JSON Output CLI

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/data-hub/how-to/list-data.md

Request JSON output from the list command by adding the --json flag. This allows piping the output to JSON processors like jq for further manipulation. Note: This specific example lists databases, but the --json flag works for files too.

```bash
deeporigin data list --databases --json | jq
```

--------------------------------

### Adding Deep Origin Package with Tools Extra (Windows)

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/install.md

Adds the `deeporigin` package along with its optional 'tools' dependencies to the current uv environment. This is recommended for users of Deep Origin tools like FEP.

```bash
uv add deeporigin --extra tools
```

--------------------------------

### Querying Workstations (Python)

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/platform/how-to/workstation-info.md

This snippet demonstrates how to use the Deep Origin Python API to retrieve a list of all available workstations. It requires importing the 'api' module from 'deeporigin.platform'. The function 'get_workstations()' is called to perform the query.

```python
from deeporigin.platform import api
api.get_workstations()
```

--------------------------------

### Cloning Deep Origin Client Repository

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/install.md

Clones the source code repository for the Deep Origin client from GitHub. This step is for developers who intend to contribute to the package.

```bash
git clone git@github.com:deeporiginbio/deeporigin-client.git
```

--------------------------------

### Starting Deep Origin Docking Run with Batch Size Python

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/dd/tutorial/docking.md

Starts a docking run, explicitly controlling the number of ligands processed in each batch. This allows fine-tuning resource usage and job granularity on the Deep Origin platform.

```python
sim.dock(
    batch_size=32,
    box_size=(15, 15, 15),      # note: tuple  
    pocket_center=(13, -6, 22) # note: tuple  
)
```

--------------------------------

### Checking Python Version

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/install.md

Verifies the installed version of Python 3.10 or higher. This is a prerequisite for installing the Deep Origin client for developers.

```bash
python3 --version
```

--------------------------------

### Upgrading Deep Origin Package with uv

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/install.md

Upgrades the `deeporigin` package in the current uv environment to the latest version. This command should be run in the project root directory.

```bash
uv add --upgrade deeporigin
```

--------------------------------

### Install Variables and Secrets using Deep Origin CLI (Bash)

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/compute-hub/how-to/variables.md

Executes the Deep Origin CLI command to install variables and secrets from the Deep Origin OS (organization or account level) into the current workstation environment. This command only functions within a Deep Origin workstation.

```bash
deeporigin variables install
```

--------------------------------

### Starting Deep Origin Docking Run Python

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/dd/tutorial/docking.md

Initiates a molecular docking run for all ligands in the complex against the protein. Requires specifying the docking box size and the pocket center coordinates relative to the protein.

```python
sim.docking.run(
    box_size=(15, 15, 15),      # match to your protein
    pocket_center=(13, -6, 22) # match to your protein
)
```

--------------------------------

### Authenticate using Deep Origin CLI

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/how-to/auth.md

Authenticates the user with the Deep Origin platform using the command-line interface. This command initiates the device authentication flow, guiding the user through the browser-based sign-in process.

```Bash
deeporigin authenticate
```

--------------------------------

### Deep Origin Authentication Device Flow Prompt

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/how-to/auth.md

Example output displayed to the user during the device authentication flow, providing instructions to navigate to a URL and enter a user code to complete the sign-in process in a web browser.

```Shell
To connect to the Deep Origin OS, navigate your browser to 

https://<env>auth0.com/activate?user_code=VMPZ-PQFG

and verify the confirmation code is "VMPZ-PQFG", and click the "Confirm" button.
```

--------------------------------

### Workstation Object Structure (JSON)

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/platform/how-to/workstation-info.md

This JSON snippet illustrates the typical structure and attributes of a workstation object returned by the 'api.get_workstations()' call. It includes details about access methods, settings, resources, state, and metadata.

```json
{
    "attributes": {
        "accessMethods": [
            {
                "icon": "/assets/icons/catalog-items/jupyterlab.svg",
                "id": "jupyterlab",
                "name": "JupyterLab"
            },
            {
                "icon": "/assets/icons/catalog-items/code-server.svg",
                "id": "code-server",
                "name": "VS Code (web)"
            }
        ],
        "accessSettings": {
            "publicKey": "ssh-ed25519 ... ",
            "ssh": true
        },
        "autoStopIdleCPUThreshold": 0,
        "autoStopIdleDuration": 30,
        "blueprint": "deeporigin/deeporigin-python:staging",
        "cloudProvider": {
            "region": "us-west-2",
            "vendor": "aws"
        },
        "clusterId": "3bb775e4-8be6-4936-a6b9",
        "created": "2024-10-05T17:01:06.840Z",
        "description": "dfd",
        "drn": "drn:...",
        "enableAutoStop": true,
        "name": "forthcoming-tyrannosaurus-8fd",
        "nextUserActions": [
            "DELETE"
        ],
        "orgHandle": "deeporigin-com",
        "requestedResources": {
            "cpu": 8,
            "gpu": 0,
            "gpuSize": "NONE",
            "memory": 32,
            "storage": 250
        },
        "state": {
            "error": "",
            "isError": false,
            "stage": "READY",
            "status": "TERMINATED"
        },
        "status": "TERMINATED",
        "summary": "",
        "templateVersion": "v0.1.0",
        "updated": "2024-10-07T12:46:46.511Z",
        "userHandle": "google-apps|srinivas@deeporigin.com",
        "volumeDrns": [
            "..."
        ],
        "wasAutoStopped": false
    },
    "id": "...",
    "type": "ComputeBench"
}
```

--------------------------------

### Expected RBFE Job Start Output (Bash)

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/dd/tutorial/rbfe.md

Shows the expected output message printed to the console when an RBFE job is successfully started on the Deep Origin platform. It includes the unique job ID and execution ID for tracking the simulation run.

```bash
🧬 Job started with ID: 20f05e96, execution ID: x9rl5eghrpqwyiciehc3e
```

--------------------------------

### Running PDBFixer on Deep Origin (Python)

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/tools/pdbfixer.md

This Python snippet demonstrates how to use the deeporigin.tools.run.receptor_prep function to start a PDBFixer job on the Deep Origin platform. It requires specifying the database and row IDs, output and input column names, and various PDBFixer parameters like adding missing residues/atoms/hydrogens, pH, and removing heterogens/water.

```python
from deeporigin.tools import run

job_id = run.receptor_prep(
    database_id="<your-db-name>",
    row_id="<row-name>",
    output_column_name="<output-column-name>",
    receptor_column_name="<receptor-column-name>",
    ligand_column_name="<ligand-column-name>",
    add_missing_residues=True,
    add_missing_atoms= True,
    add_missing_hydrogens= True,
    ph = 7.4,
    remove_heterogens= True,
    remove_water= True,
)
```

--------------------------------

### Get Deep Origin Workstation Context (Bash)

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/compute-hub/how-to/workstation-info.md

Runs the `deeporigin context` command to display details about the current Deep Origin workstation environment, including Workstation ID, User ID, Organization ID, and Environment. This command is only intended to be run inside a Deep Origin workstation. Running it outside a workstation will result in 'None' values for most fields.

```bash
deeporigin context
```

--------------------------------

### Visualize ABFE Binding Trajectory in Python

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/dd/how-to/visualize-abfe-trajectories.md

This snippet shows how to visualize the binding phase trajectory of an ABFE simulation using the `show_trajectory` method. It includes examples for visualizing the default window (window 1) and a specific window using the `window` parameter.

```python
# Show the binding trajectory for the default window (window 1)
sim.abfe.show_trajectory(ligand_id="ligand1", step="binding")

# Show the binding trajectory for a specific window
sim.abfe.show_trajectory(ligand_id="ligand1", step="binding", window=5)
```

--------------------------------

### Showing Database Data - Deep Origin

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/data-hub/how-to/view-data.md

Retrieve and display data for an entire database in Deep Origin. Examples include the CLI command for standard output, the CLI command for JSON output piped to jq, the expected JSON structure, and the Python API call which returns a Pandas DataFrame.

```bash
deeporigin data show <database-id>
```

```bash
deeporigin data describe <database-id> --json | jq
```

```json
{
  "Status": [
    "valid",
    "valid"
  ],
  "stag-id": [
    "stag-1",
    "stag-2"
  ],
  "Customer Name": [
    "Blue Sun Corp ",
    "Veridian Dynamics"
  ],
  "Status": [
    "Processing",
    "Complete"
  ],
  "Output Files": [
    null,
    "report.tar.gz"
  ]
}
```

```python
from deeporigin.data_hub import api
api.get_dataframe("database-id")
```

--------------------------------

### Setting Organization ID (Python)

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/configure.md

Configure the Deep Origin client by setting the organization ID using the Python client library. Replace 'org-id' with your actual Deep Origin organization ID. This requires the 'deeporigin' package to be installed.

```python
from deeporigin import config
config.set_value("organization_id", "org-id")
```

--------------------------------

### Monitoring Deep Origin Job ID (Bash)

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/tools/pdbfixer.md

This Bash snippet shows the typical output message printed to the console when a Deep Origin tool run is successfully started using the deeporigin.tools.run function. It provides the unique job ID which can be used to monitor the status of the running job.

```bash
🧬 Job started with ID: 9f7a3741-e392-45fb-a349-804b7fca07d7
```

--------------------------------

### Starting Deep Origin Docking Run with Workers Python

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/dd/tutorial/docking.md

Initiates a docking run, specifying the number of parallel workers to use for processing batches of ligands. This controls the degree of parallelism on the Deep Origin platform.

```python
sim.dock(
    n_workers=2,
    box_size=(15, 15, 15),      # note: tuple  
    pocket_center=(13, -6, 22) # note: tuple  
)
```

--------------------------------

### Running Autodock Vina using Deep Origin Wrapper (Python)

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/tools/how-to/run-tools.md

Demonstrates how to run the Autodock Vina tool on the Deep Origin platform using its dedicated wrapper function from the `deeporigin.tools.run` module. This is the recommended approach for running packaged tools.

```python
from deeporigin.tools import run
run.autodock_vina(...)
```

--------------------------------

### Getting Dataframe from Deep Origin Database (Python)

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/data-hub/how-to/add-data.md

Imports the Deep Origin API and retrieves a dataframe from a specified database ID. This demonstrates how to access existing data before potentially adding new rows.

```python
from deeporigin.data_hub import api
df = api.get_dataframe("xy")
df
```

--------------------------------

### Constructing Ligand from File (Python)

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/dd/how-to/ligands.md

Demonstrates how to create a `Ligand` instance by providing the path to a molecule file, typically an SDF file. It requires importing the `Ligand` class and potentially a data directory path.

```python
from deeporigin.chemistry import Ligand
from deeporigin import drug_discovery as dd

ligand = Ligand(dd.EXAMPLE_DATA_DIR / "brd-2.sdf")
```

--------------------------------

### Showing Row Data - Deep Origin

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/data-hub/how-to/view-data.md

Retrieve and display data for a specific row in a Deep Origin database. Examples include the CLI command for standard output, the CLI command for JSON output piped to jq, the expected JSON structure, and the Python API call which returns a dictionary.

```bash
deeporigin data show <row-id>
```

```bash
deeporigin data describe <file-id> --json | jq
```

```json
{
  "File": "_file:hnU7F62xeW8j0l1kR7YP1",
  "Float Num": 112,
  "selctcol": "sdsd"
}
```

```python
from deeporigin.data_hub import api
api.get_row_data("row-id")
```

--------------------------------

### Running Meeko Ligand Prep Tool on Deep Origin (Python)

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/tools/ligand-prep-meeko.md

This Python snippet demonstrates how to initiate a ligand preparation job on Deep Origin using the `deeporigin.tools.run.ligand_prep` function. It requires specifying the database ID, row ID, and the names of the input ligand column and the desired output column. The function returns the unique job ID for monitoring.

```python
from deeporigin.tools import run

job_id = run.ligand_prep(
    database_id="<your-db-name>",
    row_id="<row-name>",
    output_column_name="<output-column-name>",
    ligand_column_name="<receptor-column-name>",
)
```

--------------------------------

### Write Boolean Data to Deep Origin Database Cell

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/data-hub/how-to/write-data.md

Provides examples for writing a boolean value (True or False) to a cell in a Deep Origin database using the CLI or Python API. Requires the database, column, and row identifiers.

```bash
deeporigin data write "True" \
    --database $database_id \
    --column $column_id \
    --row $row_id
```

```python
from deeporigin.data_hub import api
api.set_cell_data(
    True,
    database_id="database ID or name",
    column_id="column ID or programmatic key",
    row_id="row ID",
)
```

--------------------------------

### Querying Tool Run Status using Python

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/tools/how-to/check-status.md

This snippet demonstrates how to check the current status of a DeepOrigin tool run. It utilizes the `query_run_status` function from the `deeporigin.tools.utils` module, which requires the job ID of the specific run you wish to query. Replace "job-id" with the actual ID obtained when the run was started.

```python
from deeporigin.tools.utils import query_run_status
query_run_status("job-id")
```

--------------------------------

### Creating Database in Deep Origin (CLI, Root)

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/data-hub/how-to/create.md

This CLI command creates a new database at the root level of the Deep Origin data hub. Provide the desired name for the database and include the `--database` flag.

```bash
deeporigin data new --name <name>  --database
```

--------------------------------

### Running Deep Origin Client Tests Against Live API (Make)

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/README.md

Run the test suite against the live Deep Origin API instead of using mocked responses.

```bash
make test client=default
```

--------------------------------

### Running Single Ligand ABFE Workflow (Python)

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/dd/tutorial/abfe.md

Shows how to initiate an end-to-end ABFE simulation for a single specified ligand by calling the `run_end_to_end` method on the `abfe` attribute of the `Complex` object with a list containing the single ligand ID. This queues a task on Deep Origin.

```Python
sim.abfe.run_end_to_end(ligand_ids=["Ligands-1"])
```

--------------------------------

### Visualizing a Ligand (Python)

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/dd/how-to/ligands.md

Visualize a Ligand object using the `ligand.show()` method. It displays a 3D visualization if the ligand is backed by an SDF file, otherwise a 2D representation. Requires a Jupyter notebook environment.

```python
ligand.show()
```

--------------------------------

### Listing Files using API Wrapper (Python)

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/data-hub/ref/low-level-api.md

Demonstrates how to use the `api` wrapper module to call the `list_files` function, which internally uses the `deeporigin_data.DeeporiginData.list_files` method. It shows the necessary import and the function call.

```python
from deeporigin.data_hub import api
api.list_files()
```

--------------------------------

### Constructing Protein from File (Python)

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/dd/how-to/proteins.md

Shows how to instantiate the `Protein` class by providing the file path to a local PDB file. Requires the `Protein` class imported from `deeporigin.chemistry`.

```python
from deeporigin.chemistry import Protein
protein = Protein("/path/to/pdb")
```

--------------------------------

### Initializing Deep Origin Complex Object (Python)

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/dd/tutorial/abfe.md

Demonstrates how to initialize a Deep Origin `Complex` object from a local directory containing prepped protein (PDB) and docked ligands (SDF) and establish a connection to the platform. This object is required before running ABFE simulations.

```Python
from deeporigin.drug_discovery import Complex
sim = Complex.from_dir("/path/to/folder/")
sim.connect()
```

--------------------------------

### Viewing Configuration (CLI)

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/configure.md

View the current configuration settings for the Deep Origin client using the command-line interface. This command displays the configuration variables and their values in a table format.

```bash
deeporigin config show
```

--------------------------------

### Running All Ligands ABFE Workflow (Python)

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/dd/tutorial/abfe.md

Demonstrates how to run the end-to-end ABFE workflow for all ligands present in the `Complex` object by calling the `run_end_to_end` method without specifying any `ligand_ids`. Each ligand will be processed in parallel.

```Python
sim.abfe.run_end_to_end()
```

--------------------------------

### Constructing Ligand(s) from SDF File (Python)

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/dd/how-to/ligands.md

Illustrates creating `Ligand` instances from an SDF file using the `from_sdf` class method. It handles both single and multi-molecule SDF files, returning a single `Ligand` or a list of `Ligands`. Optional parameters like `sanitize` and `removeHs` are available.

```python
from deeporigin.chemistry import Ligand

# Create a single ligand from an SDF file containing one molecule
ligand = Ligand.from_sdf("molecule.sdf")

# Create multiple ligands from an SDF file containing multiple molecules
ligands = Ligand.from_sdf("molecules.sdf")

# With additional parameters
ligand = Ligand.from_sdf(
    "molecule.sdf",
    sanitize=True,    # Optional: whether to sanitize the molecule (default: True)
    removeHs=False    # Optional: whether to remove hydrogen atoms (default: False)
)
```

--------------------------------

### Create Ligand Objects from SDF Paths in deeporigin

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/dd/how-to/use-docking-outputs-for-fep.md

This snippet shows how to create a list of `Ligand` objects using the `deeporigin.drug_discovery.Ligand` class. It iterates through a list of file paths (presumably generated by `split_sdf_file`) and instantiates a `Ligand` object for each file. The resulting list of `Ligand` objects is then assigned to the `ligands` attribute of a simulation object (`sim`), preparing it for FEP calculations.

```python
from deeporigin.drug_discovery import Ligand

sim.ligands = [Ligand(file) for file in files]
```

--------------------------------

### Cloning Deep Origin Client Repository (Git)

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/README.md

Download the source code for the deeporigin client from GitHub and navigate into the project directory.

```bash
git clone git@github.com:deeporiginbio/deeporigin-client.git
cd deeporigin-client
```

--------------------------------

### List Available Methods for Workstations Module - Python

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/platform/ref/platform.md

This snippet demonstrates how to import the `workstations` module from the `deeporigin.platform` package and access its `__all__` attribute. The `__all__` attribute is a standard Python convention listing the public objects (functions, classes, variables) that the module intends to export, useful for inspecting available methods.

```python
from deeporigin.platform import workstations
workstations.__all__
```

--------------------------------

### Creating Database in Deep Origin (Python, Root)

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/data-hub/how-to/create.md

This Python snippet shows how to create a new database at the root level using the Deep Origin Python API. Ensure the `api` module is imported and provide the desired name for the database.

```python
from deeporigin.data_hub import api
api.create_database(name="test-database")
```

--------------------------------

### Creating Folder in Deep Origin (CLI, Root)

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/data-hub/how-to/create.md

Use this command to create a new folder at the root level of the Deep Origin data hub using the CLI. Simply provide the desired name for the folder.

```bash
deeporigin data new folder --name <name>
```

--------------------------------

### Viewing ABFE Parameters in Python

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/dd/tutorial/abfe.md

This snippet shows how to access the configuration parameters for the end-to-end ABFE simulation tool. Executing this line will print a dictionary containing all the settings used for the simulation, including details for ABFE, complex preparation, equilibration, MD, and solvation steps.

```python
sim.abfe._params.end_to_end
```

--------------------------------

### Creating Database in Deep Origin (CLI, With Parent)

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/data-hub/how-to/create.md

To create a new database within an existing parent folder using the CLI, use this command. Specify the database name and the unique ID of the parent folder using the `--parent` flag.

```bash
deeporigin data new database \
    --name <name> \
    --parent <parent-id>
```

--------------------------------

### Creating Database in Deep Origin (Python, With Parent)

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/data-hub/how-to/create.md

Use this Python code to create a new database inside an existing parent folder. Import the `api` module, provide the database name, and specify the `parent_id` of the target parent folder.

```python
api.create_database(
    name="test-database-2",
    parent_id="parent-id",
)
```

--------------------------------

### Creating Folder in Deep Origin (Python, Root)

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/data-hub/how-to/create.md

This Python snippet demonstrates how to create a new folder at the root level using the Deep Origin Python API. It requires importing the `api` module from `deeporigin.data_hub` and providing the folder name.

```python
from deeporigin.data_hub import api
api.create_workspace(name="test-folder")
```

--------------------------------

### Running Deep Origin Client Tests Locally (Make)

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/README.md

Execute the test suite locally using the make command. By default, tests run with mocked responses.

```bash
make test
```

--------------------------------

### List Available Methods for Tools Module - Python

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/platform/ref/platform.md

This snippet demonstrates how to import the `tools` module from the `deeporigin.platform` package and access its `__all__` attribute. The `__all__` attribute is a standard Python convention listing the public objects (functions, classes, variables) that the module intends to export, useful for inspecting available methods.

```python
from deeporigin.platform import tools
tools.__all__
```

--------------------------------

### Listing Tools using Deep Origin Python API

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/tools/how-to/list-tools.md

This snippet demonstrates how to list all available tools on the Deep Origin platform using the Python API. It imports the necessary module and calls the function to retrieve the list.

```python
from deeporigin.platform import tools
all_tools = tools.get_all_tools()
```

--------------------------------

### List Available Methods for Volumes Module - Python

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/platform/ref/platform.md

This snippet demonstrates how to import the `volumes` module from the `deeporigin.platform` package and access its `__all__` attribute. The `__all__` attribute is a standard Python convention listing the public objects (functions, classes, variables) that the module intends to export, useful for inspecting available methods.

```python
from deeporigin.platform import volumes
volumes.__all__
```

--------------------------------

### Prepare Protein by Removing Heteroatoms (Python)

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/dd/how-to/prepare-protein.md

Demonstrates loading a protein structure from a PDB ID and removing all heterogeneous atoms (HETATM records) using the `remove_hetatm` method. It also shows visualization steps before and after cleaning.

```python
from deeporigin.drug_discovery import Protein

# Load a protein structure from PDB ID
protein = Protein.from_pdb_id("1EBY")

# Visualize the original structure (includes water and heteroatoms)
protein.show()

# Remove all heterogeneous atoms
protein.remove_hetatm()

# Visualize the cleaned structure
protein.show()
```

--------------------------------

### List Available Methods for Users Module - Python

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/platform/ref/platform.md

This snippet demonstrates how to import the `users` module from the `deeporigin.platform` package and access its `__all__` attribute. The `__all__` attribute is a standard Python convention listing the public objects (functions, classes, variables) that the module intends to export, useful for inspecting available methods.

```python
from deeporigin.platform import users
users.__all__
```

--------------------------------

### Running Any Deep Origin Tool Generically (Python)

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/tools/how-to/run-tools.md

Illustrates how to execute any tool registered in the Deep Origin tool registry using the generic `run_tool` function from `deeporigin.tools.utils`. This function requires a data transfer object (DTO) dictionary as input.

```python
from deeporigin.tools.utils import run_tool
run_tool(data)
```

--------------------------------

### Visualizing Deep Origin Ligand Object (Python)

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/dd/how-to/visualize.md

Visualizes a Deep Origin Ligand object in a Jupyter notebook environment. If the ligand is backed by an SDF file, a 3D visualization is shown; otherwise, a 2D visualization is displayed. Requires the code to be run within a Jupyter notebook.

```python
ligand.show()
```

--------------------------------

### List All Files CLI

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/data-hub/how-to/list-data.md

Use the Deep Origin CLI to list all files associated with your account. This command provides a table view of file names, statuses, and IDs.

```bash
deeporigin data list --files
```

--------------------------------

### Split Multi-Ligand SDF File using deeporigin

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/dd/how-to/use-docking-outputs-for-fep.md

This snippet demonstrates how to use the `chemistry.split_sdf_file` utility function from `deeporigin.drug_discovery` to split a single SDF file containing multiple docked ligand poses into individual SDF files, one for each ligand. The function takes the path to the input SDF file and returns a list of paths to the newly created individual SDF files.

```python
from deeporigin.drug_discovery import chemistry

sdf_files = chemistry.split_sdf_file(
    input_sdf_path="filtered_ligands.sdf",
)
```

--------------------------------

### List Available Methods for Clusters Module - Python

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/platform/ref/platform.md

This snippet demonstrates how to import the `clusters` module from the `deeporigin.platform` package and access its `__all__` attribute. The `__all__` attribute is a standard Python convention listing the public objects (functions, classes, variables) that the module intends to export, useful for inspecting available methods.

```python
from deeporigin.platform import clusters
clusters.__all__
```

--------------------------------

### Viewing Configuration (Python)

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/configure.md

View the current configuration settings for the Deep Origin client using the Python client library. This function retrieves and displays the configured values.

```python
from deeporigin import config
config.get_value()
```

--------------------------------

### CLI Flag Interaction Warning

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/data-hub/how-to/list-data.md

Demonstrates a limitation of the CLI list command: when --files is used, other arguments like --databases are ignored, and only files will be listed.

```bash
deeporigin data list --files --databases
```

--------------------------------

### List Available Methods for Organizations Module - Python

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/platform/ref/platform.md

This snippet demonstrates how to import the `organizations` module from the `deeporigin.platform` package and access its `__all__` attribute. The `__all__` attribute is a standard Python convention listing the public objects (functions, classes, variables) that the module intends to export, useful for inspecting available methods.

```python
from deeporigin.platform import organizations
organizations.__all__
```

--------------------------------

### Visualizing Molecules from SDF File using Deep Origin (Python)

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/dd/how-to/visualize.md

Imports and uses the `show_molecules_in_sdf_file` function from `deeporigin.chemistry` to visualize all molecules contained within a specified SDF file. The visualization is displayed in a Jupyter notebook environment. Requires the path to the SDF file as input.

```python
from deeporigin.chemistry import show_molecules_in_sdf_file
show_molecules_in_sdf_file("path/to/file.sdf")
```

--------------------------------

### Creating Folder in Deep Origin (CLI, With Parent)

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/data-hub/how-to/create.md

This CLI command creates a new folder within an existing parent folder. Specify the desired name for the new folder and the unique ID of the parent folder.

```bash
deeporigin data new folder \
    --name <name> \ 
    --parent <parent-id>
```

--------------------------------

### Download All Files using Deep Origin CLI

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/data-hub/how-to/download-files.md

Downloads all files currently stored in the Deep Origin data hub to the current local directory using the command-line interface.

```bash
deeporigin data download-files
```

--------------------------------

### Constructing Ligand from Chemical Identifier (Python)

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/dd/how-to/ligands.md

Shows how to create a `Ligand` from common chemical identifiers (like names or drug names) using the `from_identifier` class method. It resolves the identifier using databases, creates a 3D conformation, and is useful for well-known biochemical molecules.

```python
from deeporigin.chemistry import Ligand

# Create ligands from common biochemical names
atp = Ligand.from_identifier(
    identifier="ATP",  # Adenosine triphosphate
    name="ATP"
)

serotonin = Ligand.from_identifier(
    identifier="serotonin",  # 5-hydroxytryptamine (5-HT)
    name="Serotonin"
)
```

--------------------------------

### Constructing Ligand from RDKit Mol Object (Python)

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/dd/how-to/ligands.md

Demonstrates converting an existing RDKit `Mol` object into a Deep Origin `Ligand` instance using the `from_rdkit_mol` class method. This is useful for integrating RDKit workflows with Deep Origin. Optional `name` and `save_to_file` parameters are available.

```python
from deeporigin.chemistry import Ligand
from rdkit import Chem

# Create an RDKit molecule
mol = Chem.MolFromSmiles("CCO")  # Ethanol

# Convert to a Ligand
ligand = Ligand.from_rdkit_mol(
    mol=mol,
    name="Ethanol",  # Optional name for the ligand
    save_to_file=False  # Optional: whether to save the ligand to file
)
```

--------------------------------

### Prepare Multi-chain Protein (Python)

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/dd/how-to/prepare-protein.md

Shows how to handle multi-chain proteins by selecting specific chains using `select_chains` and then applying preparation steps like removing water to the selected chains.

```python
# Load and prepare multi-chain protein
protein = Protein.from_pdb_id("1ABC")
chains_ab = protein.select_chains(['A', 'B'])  # Select chains A and B
chains_ab.remove_water()  # Remove water from selected chains
chains_ab.show()
```

--------------------------------

### Creating Folder in Deep Origin (Python, With Parent)

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/data-hub/how-to/create.md

Use this Python code to create a new folder nested within an existing parent folder. Import the `api` module, provide the folder name, and specify the `parent_id` of the target parent folder.

```python
api.create_workspace(
    name="test-folder-2",
    parent_id="parent-id",
)
```

--------------------------------

### List All Files Python

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/data-hub/how-to/list-data.md

Import the Deep Origin data hub API and call the list_files function to retrieve a list of all files.

```python
from deeporigin.data_hub import api
api.list_files()
```

--------------------------------

### Constructing Protein from PDB ID (Python)

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/dd/how-to/proteins.md

Shows how to instantiate the `Protein` class by providing a valid PDB identifier using the `pdb_id` parameter. Requires the `Protein` class imported from `deeporigin.chemistry`.

```python
from deeporigin.chemistry import Protein
protein = Protein(pdb_id="1EBY")
```

--------------------------------

### Select Specific Chains from Protein (Python)

Source: https://github.com/deeporiginbio/deeporigin-client/blob/main/docs/dd/how-to/prepare-protein.md

Illustrates how to select a single chain or multiple chains from a protein structure using the `select_chain` and `select_chains` methods.

```python
# Select a single chain
chain_a = protein.select_chain('A')

# Select multiple chains
chains_ab = protein.select_chains(['A', 'B'])
```