### Run OpenEye Toolkit Example from Command Line

Source: https://docs.eyesopen.com/toolkits/python/index.html/quickstart-python/linuxosx_pythonpath

Command line example showing how to execute a Python script from the OpenEye toolkit's examples directory to verify installation and functionality, displaying version information.

```shell
$ python oechem/oecheminfo.py
Installed OEChem version: |oechemversion| platform: linux-g++4.x-x64 built: |builddate|
..
```

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

### Run OpenEye OEChem Info Example via Python Module

Source: https://docs.eyesopen.com/toolkits/python/index.html/releasenotes/releasenotes2015_Jun

This command executes the `oecheminfo` example script directly through the Python interpreter's `-m` option, demonstrating how to run examples packaged within the `openeye` module.

```Python
(OpenEye)$ python -m openeye.examples.oechem.oecheminfo
```

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

### Example Output for AsIs Orientation

Source: https://docs.eyesopen.com/toolkits/python/index.html/fastrocstk/tutorials/Tutorial_1_Alternative_Starts/AsIs

This text snippet provides an example of the console output from a Python script configured with the `OEFastROCSOrientation_AsIs` method. It demonstrates the confirmation of 1 start and 1 inertial start, followed by a sample search result.

```Text
Opening database file 3tmn_lig.sdf ...
This example will use 1 starts & 1 inertial starts
Searching for 4tmn_lig.sdf
Score for mol 0(conf 0) 0.286799 shape 0.356514 color
```

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

### Verify OpenEye Python Toolkit installation using an example script

Source: https://docs.eyesopen.com/toolkits/python/index.html/quickstart-python/linuxosx_anaconda

This command executes the `oecheminfo.py` example script, which is part of the OpenEye Python Toolkits. Running this script verifies that the toolkits have been successfully installed and are accessible within the 'oepython' environment, displaying the installed OEChem version and platform information.

```bash
(oepython) $ oecheminfo.py
Installed OEChem version: |oechemversion| platform: linux-g++4.x-x64 built: |builddate|
...
```

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

### APIDOC: OEMolFunc.Setup Method

Source: https://docs.eyesopen.com/toolkits/python/index.html/oefftk/examples

Documentation for the Setup method of the OEMolFunc class, which is called to create the necessary interactions for energy calculations after a molecule has been prepared.

```APIDOC
OEMolPotential::OEMolFunc::Setup method
Purpose: Creates interactions for molecular energy calculations.
```

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

### Verify OpenEye Python Toolkits installation with oecheminfo.py

Source: https://docs.eyesopen.com/toolkits/python/index.html/quickstart-python/windows_virtualenv

Executes the `oecheminfo.py` example script, which is part of the OpenEye Toolkits, to confirm successful installation and display details about the installed OEChem version.

```bash
(oepython) $ oecheminfo.py
Installed OEChem version: |oechemversion| platform: linux-g++4.x-x64 built: |builddate|
...
```

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

### Python: Example Usage of GetUserStarts

Source: https://docs.eyesopen.com/toolkits/python/index.html/fastrocstk/OEFastROCSClasses/OEShapeDatabaseOptions

Python example demonstrating how to retrieve user-defined starting coordinates using `GetUserStarts`. It shows how to correctly size the `OEFloatVector` before passing it to the method.

```Python
coords = oechem.OEFloatVector(opts.GetNumStarts() * 3)
opts.GetUserStarts(coords)
```

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

### Verify OpenEye Python Toolkits installation with oecheminfo.py

Source: https://docs.eyesopen.com/toolkits/python/index.html/quickstart-python/linuxosx_virtualenv

Executes the `oecheminfo.py` script, an OpenEye example, to confirm the successful installation of the toolkits. The output displays the installed OEChem version, platform, and build date, indicating readiness for use.

```Shell
(oepython) $ oecheminfo.py
Installed OEChem version: |oechemversion| platform: linux-g++4.x-x64 built: |builddate|
...
```

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

### Python Function to Setup Command-Line Interface

Source: https://docs.eyesopen.com/toolkits/python/index.html/szybkitk/examples

This Python function `SetupInterface` configures the command-line interface for the molecular optimization script using OpenEye's `oechem` library. It parses command-line arguments, checks for help requests, and validates the readability of input files and writability of output files, ensuring proper setup before main processing.

```python
def SetupInterface(argv, itf):
    oechem.OEConfigure(itf, InterfaceData)
    if oechem.OECheckHelp(itf, argv):
        return False
    if not oechem.OEParseCommandLine(itf, argv):
        return False
    if not oechem.OEIsReadable(oechem.OEGetFileType(
                  oechem.OEGetFileExtension(itf.GetString("-in")))):
        oechem.OEThrow.Warning("%s is not a readable input file" % itf.GetString("-in"))
        return False
    if not oechem.OEIsWriteable(oechem.OEGetFileType(
                  oechem.OEGetFileExtension(itf.GetString("-out")))):
        oechem.OEThrow.Warning("%s is not a writable output file" % itf.GetString("-out"))
        return False
    return True

if __name__ == "__main__":
    sys.exit(main(sys.argv))
```

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

### Install NVIDIA Drivers on Linux

Source: https://docs.eyesopen.com/toolkits/python/index.html/omegatk/omegagpuomega

Provides a step-by-step guide for manually installing NVIDIA graphics drivers on a Linux system. This process involves making the downloaded driver executable, ensuring the X-server is disabled, and running the installer with root privileges. It highlights potential conflicts with Nouveau drivers and the importance of consulting NVIDIA's official documentation.

```Shell
chmod +x [driver_package_name].run
sudo ./NVIDIA-Linux-x86_64-450.80.02.run
```

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

### Initialize Script and Parse Command-Line Arguments

Source: https://docs.eyesopen.com/toolkits/python/index.html/_downloads/893ae001a13f47c1e37d5452e54ce406/UserInertialStartsExample

This section handles the initial setup of the Python environment, including necessary imports from OpenEye toolkits, adjusting the system path, and validating command-line arguments. It ensures the script receives the required database, query, and output file paths before proceeding.

```python
#!/usr/bin/env python
# (C) 2022 Cadence Design Systems, Inc. (Cadence)
# All rights reserved.
# TERMS FOR USE OF SAMPLE CODE The software below ("Sample Code") is
# provided to current licensees or subscribers of Cadence products or
# SaaS offerings (each a "Customer").
# Customer is hereby permitted to use, copy, and modify the Sample Code,
# subject to these terms. Cadence claims no rights to Customer's
# modifications. Modification of Sample Code is at Customer's sole and
# exclusive risk. Sample Code may require Customer to have a then
# current license or subscription to the applicable Cadence offering.
# THE SAMPLE CODE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
# EXPRESS OR IMPLIED.  OPENEYE DISCLAIMS ALL WARRANTIES, INCLUDING, BUT
# NOT LIMITED TO, WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
# PARTICULAR PURPOSE AND NONINFRINGEMENT. In no event shall Cadence be
# liable for any damages or liability in connection with the Sample Code
# or its use.

import os
import sys

from openeye import oechem
from openeye import oefastrocs

oepy = os.path.join(os.path.dirname(__file__), "..", "python")
sys.path.insert(0, os.path.realpath(oepy))

def main(argv=[__name__]):
    if len(argv) < 4:
        oechem.OEThrow.Usage("%s <database> <queries> <hits.oeb>" % argv[0])
        return 0
```

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

### Initial Setup for Single Conformer Generation (Python)

Source: https://docs.eyesopen.com/toolkits/python/index.html/omegatk/omegaexamples

This code snippet provides the standard Python script header, including licensing information, for an example demonstrating how to generate a single molecular conformer. While the functional code for conformer generation is not present in this specific block, it sets the context for such an operation.

```python
#!/usr/bin/env python
# (C) 2022 Cadence Design Systems, Inc. (Cadence)
# All rights reserved.
# TERMS FOR USE OF SAMPLE CODE The software below ("Sample Code") is
# provided to current licensees or subscribers of Cadence products or
# SaaS offerings (each a "Customer").
# Customer is hereby permitted to use, copy, and modify the Sample Code,
# subject to these terms. Cadence claims no rights to Customer's
# modifications. Modification of Sample Code is at Customer's sole and
# exclusive risk. Sample Code may require Customer to have a then
# current license or subscription to the applicable Cadence offering.
# THE SAMPLE CODE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
# EXPRESS OR IMPLIED.  OPENEYE DISCLAIMS ALL WARRANTIES, INCLUDING, BUT
# NOT LIMITED TO, WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
# PARTICULAR PURPOSE AND NONINFRINGEMENT. In no event shall Cadence be
# liable for any damages or liability in connection with the Sample Code
```

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

### Install OpenEye Python Toolkits with pip (Full Command)

Source: https://docs.eyesopen.com/toolkits/python/index.html/releasenotes/releasenotes2015_Jun

This command demonstrates the full `pip` installation process for OpenEye Python Toolkits, specifying the package index. It also shows how to verify the installation using `oecheminfo.py`.

```Python
$ pip install -i https://pypi.binstar.org/OpenEye/simple OpenEye-toolkits
...
$ oecheminfo.py
Installed OEChem version: |oechemversion| platform: ubuntu-14.04-g++4.8-x64 built: |builddate|
...
```

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

### Python Example for Setting User-Defined Starts

Source: https://docs.eyesopen.com/toolkits/python/index.html/fastrocstk/OEFastROCSClasses/OEShapeDatabaseOptions

Demonstrates how to use OEShapeDatabaseOptions.SetInitialOrientation and OEShapeDatabaseOptions.SetUserStarts in Python. This snippet initializes options, sets an initial orientation, populates a float vector with example coordinates, and then applies these coordinates using SetUserStarts.

```python
opts = oefastrocs.OEShapeDatabaseOptions()
opts.SetInitialOrientation(oefastrocs.OEFastROCSOrientation_UserInertialStarts)

startsCoords = oechem.OEFloatVector()

startsCoords.append(float(1.45))
startsCoords.append(float(6.78))
startsCoords.append(float(-3.21))

opts.SetUserStarts(startsCoords, len(startsCoords) / 3)
```

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

### Install NVIDIA Drivers on Linux

Source: https://docs.eyesopen.com/toolkits/python/index.html/graphsimtk/gpu_prereq

Detailed steps for manual NVIDIA driver installation on Linux, including making the installer executable, disabling the X-server, and running the installation script. Highlights the importance of root privileges and potential conflicts with Nouveau drivers.

```bash
chmod +x [driver_package_name].run
```

```bash
sudo ./NVIDIA-Linux-x86_64-450.80.02.run
```

```bash
nvidia-smi
```

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

### Verify OpenEye Toolkit Installation

Source: https://docs.eyesopen.com/toolkits/python/index.html/quickstart-python/linuxosx

This command runs an example script 'oecheminfo.py' from the activated 'oepython' environment to verify that the OpenEye Python Toolkits have been successfully installed and are functional. The output displays the installed OEChem version and build details.

```Shell
(oepython) $ oecheminfo.py
Installed OEChem version: |oechemversion| platform: linux-g++4.x-x64 built: |builddate|
...
```

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

### Compile OpenEye Toolkit Examples on Windows Command Line

Source: https://docs.eyesopen.com/toolkits/python/index.html/quickstart-cplusplus/install

Instructions to compile OpenEye C++ toolkit examples on Windows using a Visual Studio Developer Command Prompt. This involves executing a batch script to configure the solution and then using `MSBuild` to compile. Compiled examples are found in `examples/bin/docs/Release/`.

```Batch
configure-VS<ver>x.bat
MSBuild OpenEye-Toolkits.sln /p:Configuration=Release
```

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

### Install OpenEye Toolkits in a Python Virtual Environment

Source: https://docs.eyesopen.com/toolkits/python/index.html/fastrocstk/installation

This snippet provides instructions for setting up a dedicated Python virtual environment using 'mkvirtualenv' and then installing the OpenEye Toolkits, including FastROCS, via pip. The '--extra-index-url' flag is used to specify the OpenEye package repository, ensuring proper installation of the toolkit's dependencies.

```Shell
$ mkvirtualenv fastrocs
(fastrocs) $ pip install --extra-index-url https://pypi.anaconda.org/OpenEye/simple OpenEye-toolkits
```

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

### Execute AsIsStartsExample.py Script from Command Line

Source: https://docs.eyesopen.com/toolkits/python/index.html/fastrocstk/examples/example_asisstarts

This snippet demonstrates the command-line syntax for running the `AsIsStartsExample.py` script. It requires a database argument and can optionally accept multiple query arguments.

```Shell
prompt> AsIsStartsExample.py <database> [<queries> ... ]
```

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

### Execute UserInertialStartsExample Python Script

Source: https://docs.eyesopen.com/toolkits/python/index.html/fastrocstk/examples/example_userinertialstarts

This command demonstrates how to run the `UserInertialStartsExample.py` script from the command line. It requires a `<database>` argument and can optionally accept multiple `<queries>`.

```Shell
prompt> UserInertialStartsExample.py <database> [<queries> ... ]
```

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

### Run EON PB Overlay Script

Source: https://docs.eyesopen.com/toolkits/python/index.html/eontk/examples

Command-line examples demonstrating how to execute the `eon_pb_overlay.py` script. It shows basic usage with input/output files and an advanced option to specify the number of top hits for rescoring.

```python
python eon_pb_overlay.py -query query.sdf -in database_molecules.oeb.gz -out output.oeb.gz

python eon_pb_overlay.py -query query.sdf -in database_molecules.oeb.gz -out output.oeb.gz -numtophits 2
```

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

### Python: Set Up Ligand Optimization in Protein-Ligand Complexes

Source: https://docs.eyesopen.com/toolkits/python/index.html/oefftk/examples

This Python example illustrates the initial setup for performing ligand optimization within the context of a protein using OpenEye's complex force field capabilities. It demonstrates the necessary imports (`oechem`, `oeff`) and provides a high-level overview of the approach for optimizing ligands while considering their protein environment.

```python
#!/usr/bin/env python
# (C) 2022 Cadence Design Systems, Inc. (Cadence)
# All rights reserved.
# TERMS FOR USE OF SAMPLE CODE The software below ("Sample Code") is
# provided to current licensees or subscribers of Cadence products or
# SaaS offerings (each a "Customer").
# Customer is hereby permitted to use, copy, and modify the Sample Code,
# subject to these terms. Cadence claims no rights to Customer's
# modifications. Modification of Sample Code is at Customer's sole and
# exclusive risk. Sample Code may require Customer to have a then
# current license or subscription to the applicable Cadence offering.
# THE SAMPLE CODE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
# EXPRESS OR IMPLIED.  OPENEYE DISCLAIMS ALL WARRANTIES, INCLUDING, BUT
# NOT LIMITED TO, WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
# PARTICULAR PURPOSE AND NONINFRINGEMENT. In no event shall Cadence be
# liable for any damages or liability in connection with the Sample Code
# or its use.

import sys
from openeye import oechem
from openeye import oeff

# //////////////////////////////////////////////////////////////////////////
# The following example demonstrates how to perform ligand optimization   //
# in the context of a protein using a complex force field.                //
```

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

### Execute nam2mol_example.py for Command Line Help

Source: https://docs.eyesopen.com/toolkits/python/index.html/lexichemtk/examples_nam2mol

Demonstrates how to run the `nam2mol_example.py` script from the command line with the `--help` argument to display its usage and available parameters. This is a common way to get quick documentation for command-line tools.

```Bash
prompt> python nam2mol_example.py --help
```

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

### Install NVIDIA Driver on Linux

Source: https://docs.eyesopen.com/toolkits/python/index.html/fastrocstk/installation

Steps to manually install NVIDIA drivers on a Linux system. This involves making the downloaded driver package executable and then running the installer with superuser privileges. It also highlights the need to disable the X-server before installation.

```Shell
chmod +x [driver_package_name]
```

```Shell
sudo ./NVIDIA-Linux-x86_64-450.80.02.run
```

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

### Display `makefastss.py` Command Line Help and Options

Source: https://docs.eyesopen.com/toolkits/python/index.html/oechemtk/oechem_examples/oechem_example_makefastss

Execute the `makefastss.py` program with the `--help` argument to view its command-line interface documentation. This output lists all available input/output and other options for the tool.

```bash
prompt> python makefastss.py --help
```

```text
Simple parameter list
 input/output options
   -in : Input molecule filename
   -out : Output substructure database filename

 other options
   -keep-title : Whether to keep the title of the molecule as unique
                 identifier
   -nrthreads : Number of processors used (zero means all available)
   -screentype : Screen type generated
   -sort : Whether to sort the molecules based on their screen bit counts.
```

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

### Display All Parameters for Protein Preparation Script

Source: https://docs.eyesopen.com/toolkits/python/index.html/oechemtk/oebio_examples/oebio_example_proteinprep

Shows how to access the complete list of supported command-line parameters for the 'proteinprep.py' utility by using the '--help all' option.

```python
prompt> python proteinprep.py --help all
```

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

### Get Number of Random Starts for OEShapeDatabaseOptions

Source: https://docs.eyesopen.com/toolkits/python/index.html/fastrocstk/OEFastROCSClasses/OEShapeDatabaseOptions

Retrieves the configured number of random starting orientations used when the OEFastROCSOrientation_Random alternative start is selected. The default value for this setting is 10.

```C++
unsigned int GetNumRandomStarts()
```

```APIDOC
Method: GetNumRandomStarts
Signature: unsigned int GetNumRandomStarts()
Description: Returns the number of random starting orientations when using the OEFastROCSOrientation_Random alternative start.
Default Value: 10
Related:
  - OEShapeDatabaseOptions.SetNumRandomStarts
  - OEFastROCSOrientation
  - OEShapeDatabaseOptions.SetInitialOrientation
  - OEShapeDatabaseOptions.GetInitialOrientation
  - OEShapeDatabaseOptions.SetMaxRandomTranslation
  - OEShapeDatabaseOptions.GetMaxRandomTranslation
  - OEShapeDatabaseOptions.SetRandomSeed
  - OEShapeDatabaseOptions.GetRandomSeed
```

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

### Get Number of OECartesianStarts Start Points

Source: https://docs.eyesopen.com/toolkits/python/index.html/shapetk/OEShapeClasses/OECartesianStarts

Retrieves the total number of cartesian start points currently defined in the OECartesianStarts object.

```C++
unsigned GetNumStartPoints()
```

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

### Execute searchfp.py for Command Line Help

Source: https://docs.eyesopen.com/toolkits/python/index.html/graphsimtk/examples_summary_searchfp

Demonstrates how to run the `searchfp.py` Python script from the command line with the `--help` argument to display its usage instructions and available parameters.

```Bash
prompt> python searchfp.py --help
```

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

### Command Line Example for SMARTS Alignment

Source: https://docs.eyesopen.com/toolkits/python/index.html/oechemtk/oechem_examples/oechem_example_smartsalign

Demonstrates how to run the `smartsalign.py` script from the command line, providing a ligand PDB, a database OEB.gz file, an output OEB.gz file, and a SMARTS pattern for alignment.

```Shell
prompt > smartsalign.py ligand.pdb dbase.oeb.gz output.oeb.gz 'a1aaaa1NC'
```

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

### Get Start Point of OE2DPath

Source: https://docs.eyesopen.com/toolkits/python/index.html/depicttk/OEDepictClasses/OE2DPath

Returns the starting position of the path as an OE2DPoint object.

```C++
OE2DPoint GetStart() const;
```

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

### Run Eon PB Overlay Script

Source: https://docs.eyesopen.com/toolkits/python/index.html/_downloads/9802f869de8fb4373f532aaadf8cc385/eon_pb_overlay

Command-line examples for executing the `eon_pb_overlay.py` script. The first example shows basic usage, while the second specifies the number of top hits to rescore.

```bash
python eon_pb_overlay.py -query query.sdf -in database_molecules.oeb.gz -out output.oeb.gz
```

```bash
python eon_pb_overlay.py -query query.sdf -in database_molecules.oeb.gz -out output.oeb.gz -numtophits 2
```

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

### Install OpenEye Python Toolkits and Verify Installation

Source: https://docs.eyesopen.com/toolkits/python/index.html/releasenotes/releasenotes2015_Oct

This snippet demonstrates the updated command for installing OpenEye Python Toolkits using pip and shows how to verify the installation by running `oecheminfo.py` to display the installed OEChem version and platform details.

```bash
$ pip install -i https://pypi.anaconda.org/OpenEye/simple OpenEye-toolkits
...
$ oecheminfo.py
Installed OEChem version: |oechemversion| platform: ubuntu-14.04-g++4.8-x64 built: |builddate|
...
```

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

### Python: Initial Setup for OpenEye Molecular Optimization Script

Source: https://docs.eyesopen.com/toolkits/python/index.html/oefftk/examples

This snippet provides the standard boilerplate for a Python script utilizing OpenEye toolkits for molecular energy calculations and optimization. It includes the shebang, copyright and licensing information, and essential imports for sys, oechem, and oeff modules, setting up the environment for subsequent molecular mechanics operations.

```python
#!/usr/bin/env python
# (C) 2022 Cadence Design Systems, Inc. (Cadence)
# All rights reserved.
# TERMS FOR USE OF SAMPLE CODE The software below ("Sample Code") is
# provided to current licensees or subscribers of Cadence products or
# SaaS offerings (each a "Customer").
# Customer is hereby permitted to use, copy, and modify the Sample Code,
# subject to these terms. Cadence claims no rights to Customer's
# modifications. Modification of Sample Code is at Customer's sole and
# exclusive risk. Sample Code may require Customer to have a then
# current license or subscription to the applicable Cadence offering.
# THE SAMPLE CODE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
# EXPRESS OR IMPLIED.  OPENEYE DISCLAIMS ALL WARRANTIES, INCLUDING, BUT
# NOT LIMITED TO, WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
# PARTICULAR PURPOSE AND NONINFRINGEMENT. In no event shall Cadence be
# liable for any damages or liability in connection with the Sample Code
# or its use.

import sys
from openeye import oechem
from openeye import oeff
```

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

### Get Eon TK Platform and Compiler Version (C++)

Source: https://docs.eyesopen.com/toolkits/python/index.html/eontk/OEEonFunctions/OEEtGetPlatform

The `OEEtGetPlatform` function returns a C-style string (`const char *`) that describes the platform and compiler version of the current Eon Toolkit installation. This can be useful for identifying the environment where the toolkit is running. Examples of returned strings include 'microsoft-win32-msvc9-MD-x86' for Windows and 'redhat-RHEL5-g++4.1-x86_64' for Linux.

```C++
const char *OEEtGetPlatform()
```

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

### Python Script: Partial Eon PB Overlay Example

Source: https://docs.eyesopen.com/toolkits/python/index.html/eontk/examples

This partial code snippet introduces an example for computing Eon PB Overlay, which involves overlaying molecules based on their shape and potential similarity. The provided code is incomplete.

```python
#!/usr/bin/env python
# (C) 2024 OpenEye Scientific Software Inc. All rights reserved.
#
# TERMS FOR USE OF SAMPLE CODE The software below ("Sample Code") is
# provided to current licensees or subscribers of OpenEye products or
# SaaS offerings (each a "Customer").
# Customer is hereby permitted to use, copy, and modify the Sample Code,
# subject to these terms. OpenEye claims no rights to Customer's
# modifications. Modification of Sample Code is at Customer's sole and
```

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

### Eon Simple Overlay Script Usage Examples

Source: https://docs.eyesopen.com/toolkits/python/index.html/_downloads/338966489e68b855629cc5b104be8163/eon_simple_overlay

Command-line examples for running the Eon simple overlay script, demonstrating how to specify query, input, and output files, and an optional parameter for charge handling.

```bash
python eon_simple_overlay.py -query query.sdf -in database_molecules.oeb.gz -out output.oeb.gz
python eon_simple_overlay.py -query query.sdf -in database_molecules.oeb.gz -out output.oeb.gz -charges existing
```

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

### Display All SplitMolComplexOptions Help (Python)

Source: https://docs.eyesopen.com/toolkits/python/index.html/oechemtk/oebio_examples/oebio_example_splitmolcomplexlowlevel

This command shows all available help options and parameters for the `splitmolcomplexlowlevel.py` program, providing a complete reference for its functionality.

```python
python splitmolcomplexlowlevel.py --help all
```

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

### Get Number of Inertial Starts (OEShapeDatabaseOptions)

Source: https://docs.eyesopen.com/toolkits/python/index.html/fastrocstk/OEFastROCSClasses/OEShapeDatabaseOptions

Returns the number of inertial starts used as initial starting points for the shape optimization process. The default value is '4' starting points, which are oriented along the principle moment of inertia to provide diverse initial configurations.

```C++
unsigned int GetNumInertialStarts() const
```

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

### New Example Programs

Source: https://docs.eyesopen.com/toolkits/python/index.html/oechemtk/releasenotes/version1_3_2

Several new example programs have been added to demonstrate various functionalities: 'catmols', 'movemol', 'pdbdata', 'rings', and 'rmsd_selftest'.

```Other
New example programs:
- catmols
- movemol
- pdbdata
- rings
- rmsd_selftest
```

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

### Execute SzmapBestOrientations.py with Help Argument

Source: https://docs.eyesopen.com/toolkits/python/index.html/szmaptk/examples_szmapbestorientations

Demonstrates how to run the `SzmapBestOrientations.py` program from the command line with the `--help` flag to display its usage instructions and available parameters.

```Python
python SzmapBestOrientations.py --help
```

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

### Simplified One-Command Python Toolkit Installation

Source: https://docs.eyesopen.com/toolkits/python/index.html/releasenotes/releasenotes2015_Jun

This simplified `pip` command installs OpenEye Python Toolkits, automatically selecting the correct version and operating system. It is the recommended method for pure Python projects.

```Python
pip install OpenEye-toolkits
```

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

### Run BestShapeOverlay Python Script

Source: https://docs.eyesopen.com/toolkits/python/index.html/fastrocstk/examples/example_bestshapeoverlay

This snippet demonstrates how to execute the `BestShapeOverlay.py` Python script from the command line. It requires a database argument and can optionally take multiple query arguments.

```shell
prompt> BestShapeOverlay.py <database> [<queries> ... ]
```

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

### Command Line Usage Examples for Eon Overlap Script

Source: https://docs.eyesopen.com/toolkits/python/index.html/eontk/examples

Provides examples for executing the `eon_overlap.py` script from the command line. It demonstrates how to specify input, output, and query files, and how to control the charge assignment method (MMFF94 or existing charges).

```python
python eon_overlap.py -query query.sdf -in database_molecules.oeb.gz -out output.oeb.gz

python eon_overlap.py -query query.sdf -in database_molecules.oeb.gz -out output.oeb.gz -charges existing

python eon_overlap.py -query query.sdf -in database_molecules.oeb.gz -out output.oeb.gz -charges mmff94
```

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

### Python Example: Get OEEnsemble Name

Source: https://docs.eyesopen.com/toolkits/python/index.html/szmaptk/OESzmapFunctions/OEGetEnsembleName

Illustrates how to call the `OEGetEnsembleName` function from the `oeszmap` module in Python. This example retrieves the long name for the `OEEnsemble_NeutralDiffDeltaG` type.

```Python
longName = True
name = oeszmap.OEGetEnsembleName(oeszmap.OEEnsemble_NeutralDiffDeltaG, longName)
```

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

### proteinprep Command-Line Utility Parameters

Source: https://docs.eyesopen.com/toolkits/python/index.html/oechemtk/oebio_examples/oebio_example_proteinprep

Detailed documentation for the 'proteinprep' command-line utility, listing all available options categorized by function, including options for splitting molecular complexes, input/output, calculation, and display.

```APIDOC
proteinprep [-options] <inmol> [<outcplx> [<outlig>]]
Complete parameter list
    SplitMolComplex options :
      -bindingsitenum : Select this binding site
      -covalentligand : Split covalent ligands
      -ligandfilter : Ligand filter category
      -ligandname : Ligand name
      -maxsitedistance : Maximum distance to be associated with the binding site
      -maxsurfacedistance : Maximum distance to be associated with the protein
                            surface
      -modelnum : Select this NMR model number
      -proteinfilter : Protein filter category
      -separateresidues : Separate individual residues before selection
      -surfacewaters : Select surface waters
      -waterfilter : Water filter category

    input/output options :
      -in : Input molecule filename (must have 3D coordinates)
      -cplxout : Output complex filename
      -ligout : Output ligand filename

    Calculation options :
      -alts : Alternate location atom handling (affects atom:atom interactions)
      -placehydrogens : If false, hydrogens will not be added
      -waterprocessing : How waters are processed (can greatly affect runtime)
      -standardizehyd : If false, bonds for hydrogens are not adjusted to standard
                      lengths
      -clashcutoff : Van der Waals overlap (in Angstroms) defined to be a bad
                     clash
      -flipbias : Scale factor for the bias against flipping sidechains such as
                  HIS

    Display options :
      -verbose : Display more information about the process
```

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

### CMakeLists.txt Configuration for OpenEye Toolkits

Source: https://docs.eyesopen.com/toolkits/python/index.html/quickstart-cplusplus/install

This CMake configuration file sets up a project to use OpenEye toolkits. It defines the minimum CMake version, specifies the OpenEye toolkit installation directory (`OE_DIR`), lists required OpenEye libraries (`OE_LIBS`), includes necessary directories, links libraries, and defines source files (`SRCS`). It also includes a template for examples.

```CMake
cmake_minimum_required(VERSION 3.21.0)

set (OE_DIR "C:/Users/<USERNAME>/Documents/openeye/toolkits")

set (OE_LIBS
    oechem
)

include_directories ( ${OE_DIR}/include )
link_directories ( ${OE_DIR}/lib )

set (LIBS "${OE_LIBS};${SYSLIBS};${SYSZLIB}")

set (SRCS
    "my_app main.cpp"
)

include (${OE_DIR}/examples/ExamplesTemplate.cmake)

```

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

### Run OEChem Information Script

Source: https://docs.eyesopen.com/toolkits/python/index.html/oechemtk/oechem_examples/oechem_example_oecheminfo

Executes the `oecheminfo.py` script from the command line to display OEChem toolkit version, platform, build date, release name, and details of supported molecule file formats including their read/write capabilities.

```bash
oecheminfo.py
```

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

### Get User Starts Scale Factor for OESiteHopperPatchOptions

Source: https://docs.eyesopen.com/toolkits/python/index.html/sitehoppertk/OESiteHopperClasses/OESiteHopperPatchOptions

Retrieves the factor by which the number of surface points are reduced to create user starts for the optimization. The default value is 14.

```C++
unsigned int GetUserStartsScaleFactor() const
```

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

### Install and List OpenEye Toolkits with pip

Source: https://docs.eyesopen.com/toolkits/python/index.html/quickstart-python/uninstall

This snippet demonstrates how installing OpenEye toolkits via pip from the OpenEye anaconda.org repository results in two packages: a meta-package and the actual binary package. The `pip list` command is used to verify the installed packages.

```Shell
(oepython) $ pip install -i https://pypi.anaconda.org/OpenEye/simple OpenEye-toolkits
...
(oepython) $ pip list
OpenEye-toolkits (|pypkgversion|)
OpenEye-toolkits-python3-osx-x64 (|pypkgversion|)
pip (9.0.1)
setuptools (0.38.4)
```

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

### Run InertialAtHeavyAtomStartsExample Python Script

Source: https://docs.eyesopen.com/toolkits/python/index.html/fastrocstk/examples/example_inertialatheavyatomstarts

This command-line example demonstrates how to execute the `InertialAtHeavyAtomStartsExample.py` script. It requires a database file and optionally accepts multiple query files as arguments. The script likely performs operations related to inertial calculations at heavy atoms, possibly within the OEFastROCS framework.

```Shell
prompt> InertialAtHeavyAtomStartsExample.py <database> [<queries> ... ]
```

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

### OpenEye Toolkits: Documentation and Example Updates

Source: https://docs.eyesopen.com/toolkits/python/index.html/oechemtk/releasenotes/version2_0_5

Summarizes general documentation improvements and example updates across OpenEye Toolkits, including new examples, rewritten chapters, and fixes for existing example code.

```APIDOC
Documentation Changes:
  printinteractions example: Added to list protein-ligand interactions perceived by OEDocking TK.
  Stereochemistry Perception chapter: Rewritten for clarity.
  splitmolcomplex and splitmolcomplexfrags examples: Updated to support reading multiple models from PDB files.
  OEOnce example code: Now compiles correctly; previously crashed if called by non-main thread before OESubSearch memory pool refactoring.
```

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

### Execute Python Script for Command Line Help

Source: https://docs.eyesopen.com/toolkits/python/index.html/lexichemtk/examples_translate

Demonstrates how to run the `translate_example.py` script from the command line with the `--help` argument to display its available options and usage.

```shell
python translate_example.py --help
```

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

### Main EON PB Overlay Workflow

Source: https://docs.eyesopen.com/toolkits/python/index.html/eontk/examples

The `main` function orchestrates the entire EON PB overlay process. It parses command-line arguments, opens input/output molecule streams, sets up OpenEye shape and charge overlap functions, initializes the `OEEonPBOverlay` object, prepares the query molecule, iterates through database molecules, performs best overlay scoring, and adds results to a hitlist. Finally, it writes the query and scored hits to the output file with Tanimoto scores.

```python
def main(argv=[__name__]):

    eonOpts = EonPBOverlayOptions()
    opts = oechem.OERefInputAppOptions(
        eonOpts, "EonPBOverlayOptions",
        oechem.OEFileStringType_Mol3D,
        oechem.OEFileStringType_Mol3D,
        oechem.OEFileStringType_Mol3D, "-query")

    if oechem.OEConfigureOpts(opts, argv, False) == oechem.OEOptsConfigureStatus_Help:
        return 0

    eonOpts.UpdateValues(opts)

    qname       = opts.GetRefFile()
    iname       = opts.GetInFile()
    oname       = opts.GetOutFile()
    charges     = eonOpts.GetCharges()
    numtophits  = eonOpts.GetNumTopHits()

    qfs = oechem.oemolistream()
    if not qfs.open(qname):
        oechem.OEThrow.Fatal(f'Unable to open {qname} for reading')

    ifs = oechem.oemolistream()
    if not ifs.open(iname):
        oechem.OEThrow.Fatal(f'Unable to open {iname} for reading')

    ofs = oechem.oemolostream()
    if not ofs.open(oname):
        oechem.OEThrow.Fatal(f'Unable to open {oname} for writing')

    # setup eon calculation
    shapeOpts = oeshape.OEShapeOptions()
    shapeOpts.SetScoreType(oeshape.OEOverlapResultType_Tanimoto)

    # set up the Shape/Charge Overlap Func

    shapeFunc = oeshape.OEGridShapeFunc()
    chargeFunc = oeet.OEGridChargeFunc()
    overlapFunc = oeet.OEEonOverlapFunc(shapeFunc, chargeFunc)
    overlayOpts = oeshape.OEOverlayOptions()
    overlayOpts.SetOverlapFunc(overlapFunc)

    eon_pb_overlay_obj = oeet.OEEonPBOverlay(overlayOpts, eonOpts.GetPBOptions())

    # set up query
    refmol = oechem.OEMol()
    oechem.OEReadMolecule(qfs, refmol)

    if (charges == "mmff94"):
        prep_mol(refmol)
    eon_pb_overlay_obj.SetupRef(refmol)

    # write query to output file
    oechem.OEWriteMolecule(ofs, refmol)
    hitlist = oeet.OEEonHitlistBuilder(eonOpts.GetHitlistOptions())

    for mol in ifs.GetOEMols():
        if (charges == "mmff94"):
            prep_mol(mol)
        score = oeet.OEEonOverlayScore()
        eon_pb_overlay_obj.BestOverlay(score, mol, numtophits)
        hitlist.AddScore(score, mol)

    hitlist.Build()

    for hit in hitlist.GetHits():
        hitMol = hit.GetMol()
        oechem.OESetSDData(hitMol, 'Shape Tanimoto', f'{hit.GetTanimoto():.4f}')
        oechem.OESetSDData(hitMol, 'Potential Tanimoto', f'{hit.GetETTanimoto():.4f}')
```

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

### Get OECartesianStarts Start Points Data

Source: https://docs.eyesopen.com/toolkits/python/index.html/shapetk/OEShapeClasses/OECartesianStarts

Retrieves the specified cartesian start points into a provided double array. The array must be pre-allocated with a size of 3 times the number of points, obtainable via GetNumStartPoints.

```C++
unsigned GetStartPoints(double *Points)
```

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

### Get Number of Heavy Atom Starts (OEFastROCS::OEShapeDatabaseOptions)

Source: https://docs.eyesopen.com/toolkits/python/index.html/fastrocstk/OEFastROCSClasses/OEShapeDatabaseOptions

Returns the number of heavy atom starting points for shape optimization. This method requires OEShapeDatabaseOptions.SetInitialOrientation to be set to OEFastROCSOrientation_InertialAtHeavyAtoms and a query molecule.

```C++
unsigned int GetNumHeavyAtomStarts(const OEChem::OEMolBase &query) const
```

```APIDOC
OEFastROCS::OEShapeDatabaseOptions::GetNumHeavyAtomStarts
  Purpose: Returns the number of heavy atom starting points set for shape optimization.
  Signature: unsigned int GetNumHeavyAtomStarts(const OEChem::OEMolBase &query) const
  Parameters:
    query: const OEChem::OEMolBase & - The query molecule.
  Returns: unsigned int
  Requirements: OEShapeDatabaseOptions.SetInitialOrientation must be set to OEFastROCSOrientation_InertialAtHeavyAtoms.
  See also: OEShapeDatabaseOptions.SetInitialOrientation, OEShapeDatabaseOptions.GetNumStarts, OEFastROCSOrientation
```

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

### Display SzmapEnergies.py Command Line Help

Source: https://docs.eyesopen.com/toolkits/python/index.html/szmaptk/examples_szmapenergies

This snippet demonstrates how to obtain command-line interface help for the SzmapEnergies.py program by executing it with the --help argument. It also shows the resulting output, detailing the available parameters for high resolution, input ligand coordinates, and input protein context.

```bash
prompt> python SzmapEnergies.py --help
```

```text
Simple parameter list
 -high_res : If true, increase the number of orientations to 360
 -l : Input ligand coordinates for calculations
 -p : Input protein (or other) context mol
```

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

### Get Number of User-Defined Starts for OEShapeDatabaseOptions

Source: https://docs.eyesopen.com/toolkits/python/index.html/fastrocstk/OEFastROCSClasses/OEShapeDatabaseOptions

Returns the count of user-defined starting points that have been configured for shape optimization. This method requires OEShapeDatabaseOptions.SetInitialOrientation to be set to OEFastROCSOrientation_UserInertialStarts and user-starts to have been previously defined using OEShapeDatabaseOptions.SetUserStarts.

```C++
unsigned int GetNumUserStarts() const
```

```APIDOC
Method: GetNumUserStarts
Signature: unsigned int GetNumUserStarts() const
Description: Returns the number of user-defined starting points set for shape optimization.
Requirements:
  - OEShapeDatabaseOptions.SetInitialOrientation must be set to OEFastROCSOrientation_UserInertialStarts.
  - User-starts must have been set with OEShapeDatabaseOptions.SetUserStarts.
Related:
  - OEShapeDatabaseOptions.SetInitialOrientation
  - OEShapeDatabaseOptions.SetUserStarts
  - OEShapeDatabaseOptions.ClearUserStarts
  - OEShapeDatabaseOptions.GetNumStarts
  - OEFastROCSOrientation
```

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

### Execute SMARTS Alignment Program with Help

Source: https://docs.eyesopen.com/toolkits/python/index.html/depicttk/examples_summary_smartsalign2D

Demonstrates how to run the `smartsalign2D.py` program from the command line with the `--help` argument to display its usage and available options.

```Bash
prompt> python smartsalign2D.py --help
```

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

### Perform Docking with OEDock Object

Source: https://docs.eyesopen.com/toolkits/python/index.html/dockingtk/examples

This example demonstrates how to perform molecular docking using the OEDock object from the OEDocking Toolkit. It highlights the basic setup for initiating a docking process, referencing related classes like OEDockOptions and OEHybrid.

```Python
#!/usr/bin/env python
# (C) 2022 Cadence Design Systems, Inc. (Cadence)
# All rights reserved.
# TERMS FOR USE OF SAMPLE CODE The software below ("Sample Code") is
# provided to current licensees or subscribers of Cadence products or
# SaaS offerings (each a "Customer").
```

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

### Execute OpenEye Python Toolkit Integration Tests

Source: https://docs.eyesopen.com/toolkits/python/index.html/releasenotes/releasenotes2015_Jun

This command runs the integration tests for the OpenEye Python Toolkits, located within the `openeye` module. It verifies the proper installation and functionality of the package.

```Python
(OpenEye)$ python -m openeye.examples.openeye_tests
```

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

### Execute mols2img.py with --help argument

Source: https://docs.eyesopen.com/toolkits/python/index.html/depicttk/examples_summary_mols2img

Demonstrates how to obtain a description of the command-line interface for the `mols2img.py` program by executing it with the `--help` argument.

```Bash
prompt> python mols2img.py --help
```

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

### Get Monoisotopic Weight using OEGetIsotopicWeight in Python

Source: https://docs.eyesopen.com/toolkits/python/index.html/oechemtk/OEChemFunctions/OEGetAverageWeight

This Python example demonstrates how to obtain the 'monoisotopic' weight for a specific element using the OEGetIsotopicWeight function. It utilizes oechem.OEElemNo_O to specify oxygen and oechem.OEGetDefaultMass to get the default mass for the element.

```Python
elemno = oechem.OEElemNo_O
weight = oechem.OEGetIsotopicWeight(elemno, oechem.OEGetDefaultMass(elemno))
```

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

### Get Maximum Random Translation (OEShapeDatabaseOptions)

Source: https://docs.eyesopen.com/toolkits/python/index.html/fastrocstk/OEFastROCSClasses/OEShapeDatabaseOptions

Returns the maximum allowed translation distance when using random starting orientations for shape optimization. The default maximum translation is 2 angstroms, controlling the initial spatial displacement during random starts.

```C++
float GetMaxRandomTranslation() const
```

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

### Run Protein Preparation Script with Water Processing

Source: https://docs.eyesopen.com/toolkits/python/index.html/oechemtk/oebio_examples/oebio_example_proteinprep

Demonstrates how to execute the 'proteinprep.py' script to process a protein, ignoring water sampling, and splitting out the ligand from the complex.

```python
prompt> python proteinprep.py -waterprocessing ignore input.pdb prot.oeb.gz lig.oeb.gz
```

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

### Get Number of Shape Optimization Starts (OEFastROCS::OEShapeDatabaseOptions)

Source: https://docs.eyesopen.com/toolkits/python/index.html/fastrocstk/OEFastROCSClasses/OEShapeDatabaseOptions

Returns the number of alternative starting points for shape optimization. This method has two overloads: one without parameters and one requiring a query molecule (OEChem::OEMolBase) when specific orientation constants (OEFastROCSOrientation_InertialAtHeavyAtoms or OEFastROCSOrientation_InertialAtColorAtoms) are used. If alternative starts are not set or OEFastROCSOrientation_AsIs is used, it returns 1.

```C++
unsigned int GetNumStarts() const
unsigned int GetNumStarts(const OEChem::OEMolBase &query) const
```

```APIDOC
OEFastROCS::OEShapeDatabaseOptions::GetNumStarts
  Purpose: Returns the number of alternative starting points set for shape optimization.
  Overloads:
    1. unsigned int GetNumStarts() const
       Description: Returns the number of alternative starting points set for shape optimization when no query molecule is provided.
       Returns: unsigned int
    2. unsigned int GetNumStarts(const OEChem::OEMolBase &query) const
       Parameters:
         query: const OEChem::OEMolBase & - The query molecule. Required when OEFastROCSOrientation_InertialAtHeavyAtoms or OEFastROCSOrientation_InertialAtColorAtoms is used.
       Description: Returns the number of alternative starting points set for shape optimization, specific to a query molecule.
       Returns: unsigned int
  Notes: If alternative starts have NOT been set or OEFastROCSOrientation_AsIs is set, these methods will return a value of 1.
  See also: OEShapeDatabaseOptions.SetInitialOrientation, OEShapeDatabaseOptions.SetUserStarts, OEShapeDatabaseOptions.ClearUserStarts, OEFastROCSOrientation
```

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

### Run Strip Salts Python Program from Command Line

Source: https://docs.eyesopen.com/toolkits/python/index.html/oechemtk/oechem_examples/oechem_example_stripsalts

This command-line example illustrates how to execute the `stripsalts.py` script, taking a gzipped OpenEye binary (OEB) database as input and producing a new gzipped OEB file with salt components removed.

```Shell
prompt> stripsalts.py dbase.oeb.gz output.oeb.gz
```

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

### Execute Basic OE3DMolStyle Application Script

Source: https://docs.eyesopen.com/toolkits/python/index.html/oechemtk/oechem_examples/oechem_example_basicmolstyle

This command-line example demonstrates how to run the `basicStyle.py` script. It takes an input OEB file and applies the defined OE3DMolStyle, then outputs the result to another OEB file. The script configures atom labeling, element-based coloring, ball-and-stick display, protein ribbon rendering, polar hydrogen visibility, and intermolecular hydrogen bond interaction style.

```Shell
basicStyle.py input.oeb output.oeb
```

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

### Python Example: Drawing a Cubic Bézier Curve

Source: https://docs.eyesopen.com/toolkits/python/index.html/depicttk/OEDepictClasses/OEImageBase

Demonstrates how to draw a cubic Bézier curve in Python using the oedepict library. This example initializes an image, defines the start, end, and control points, sets the pen properties, and then calls the DrawCubicBezier method to render the curve.

```Python
image = oedepict.OEImage(100, 100)

b = oedepict.OE2DPoint(20, 70)
e = oedepict.OE2DPoint(60, 70)
c1 = b + oedepict.OE2DPoint(50, -60)
c2 = e + oedepict.OE2DPoint(50, -60)

pen = oedepict.OEPen(oechem.OELightGreen, oechem.OEBlack, oedepict.OEFill_On, 2.0)
image.DrawCubicBezier(b, c1, c2, e, pen)
```

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

### Verifying OEFastROCS User-Defined Start Settings (Python)

Source: https://docs.eyesopen.com/toolkits/python/index.html/fastrocstk/tutorials/Tutorial_1_Alternative_Starts/UserInertialStarts

This Python snippet shows how to verify that the user-defined initial orientation and the number of user starts have been correctly applied within OEShapeDatabaseOptions. It queries GetInitialOrientation and GetNumUserStarts to confirm the settings and prints a confirmation message to the console.

```Python
if opts.GetInitialOrientation() == oefastrocs.OEFastROCSOrientation_UserInertialStarts:
    numStarts = opts.GetNumUserStarts()
    oechem.OEThrow.Info("This example will use %u starts" % numStarts)

```

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

### Execute Lexichem TK mol2nam example with help

Source: https://docs.eyesopen.com/toolkits/python/index.html/lexichemtk/examples_mol2nam

Demonstrates how to obtain command-line interface documentation for the `mol2nam_example.py` script by executing it with the `--help` argument in a shell environment.

```Shell
prompt> python mol2nam_example.py --help
```

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

### Generate Conformer Ensemble via Torsion Driving with OpenEye Python

Source: https://docs.eyesopen.com/toolkits/python/index.html/omegatk/omegaexamples

This Python example illustrates how to use OpenEye's OETorDriver and OETorDriveOptions to generate a conformer ensemble by torsion driving from a given 3D molecular structure. It outlines the basic setup for initiating the torsion driving process.

```python
#!/usr/bin/env python
# (C) 2022 Cadence Design Systems, Inc. (Cadence)
# All rights reserved.
# TERMS FOR USE OF SAMPLE CODE The software below ("Sample Code") is
# provided to current licensees or subscribers of Cadence products or
# SaaS offerings (each a "Customer").
# Customer is hereby permitted to use, copy, and modify the Sample Code,
# subject to these terms. Cadence claims no rights to Customer's
# modifications. Modification of Sample Code is at Customer's sole and
# exclusive risk. Sample Code may require Customer to have a then
# current license or subscription to the applicable Cadence offering.
# THE SAMPLE CODE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
# EXPRESS OR IMPLIED.  OPENEYE DISCLAIMS ALL WARRANTIES, INCLUDING, BUT
# NOT LIMITED TO, WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
# PARTICULAR PURPOSE AND NONINFRINGEMENT. In no event shall Cadence be
# liable for any damages or liability in connection with the Sample Code
```

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

### Python Example: Drawing Interactive Legend Layout with OEDrawLegendLayout

Source: https://docs.eyesopen.com/toolkits/python/index.html/depicttk/OEDepictFunctions/OEDrawLegendLayout

This Python example demonstrates the complete workflow for creating and drawing an interactive legend using OEDrawLegendLayout. It shows how to configure legend options, create the legend object, add a watermark to the legend area, include an interactive icon, and finally draw the legend before saving the image as an SVG file. The example highlights the setup for interactive features.

```python
opts = oedepict.OELegendLayoutOptions(oedepict.OELegendLayoutStyle_VerticalTopRight,
                                      oedepict.OELegendColorStyle_LightGreen,
                                      oedepict.OELegendInteractiveStyle_Toggle)
opts.SetButtonWidthScale(1.5)
opts.SetButtonHeightScale(1.5)
legend = oedepict.OELegendLayout(image, "Legend", opts)

legend_area = legend.GetLegendArea()
oedepict.OEAddWatermark(legend_area, "This is the legend area")
oedepict.OEAddInteractiveIcon(image, oedepict.OEIconLocation_BottomRight, 0.75)
oedepict.OEDrawLegendLayout(legend)

oedepict.OEWriteImage("LegendLayout.svg", image)
```

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

### Get Command Line Interface Help for makefastfp.py

Source: https://docs.eyesopen.com/toolkits/python/index.html/graphsimtk/examples_summary_makefastfp

Demonstrates how to obtain the command line interface options for the `makefastfp.py` program by executing it with the `--help` argument. It lists available fingerprint and input/output options for generating fingerprint files.

```Shell
prompt> python makefastfp.py --help
```

```Text
Simple parameter list

 fingerprint options
   -atomtype : Fingerprint atom type
   -bondtype : Fingerprint bond type
   -fptype : Fingerprint type
   -maxdistance : Maximum number of bonds/radius in path/circular/tree
   -mindistance : Minimum number of bonds/radius in path/circular/tree
   -numbits : Size of bitvector

 input/output options
   -fpdbfname : Output fingerprint database filename
   -in : Input molecule filename
```

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

### Command Line Interface for searchfastfp.py

Source: https://docs.eyesopen.com/toolkits/python/index.html/graphsimtk/examples_summary_searchfastfp

Demonstrates how to use the `--help` argument with the `searchfastfp.py` script to view its command-line options. The output details parameters for fingerprint database configuration, search criteria, and input/output file handling.

```bash
prompt> python searchfastfp.py --help
```

```text
Simple parameter list

 fingerprint database options
   -memorytype : Fingerprint database memory type

 fingerprint database search options
   -cutoff : Similarity cutoff value
   -descending : Order of similarity scores
   -limit : Maximum number of similarity scores
   -simfunc : Similarity measure

 input/output options
   -fpdbfname : Input fast fingerprint database filename
   -molfname : Input molecule filename
   -out : Output molecule filename
   -query : Input query filename
```

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

### Get Number of Color Atom Starts (OEFastROCS::OEShapeDatabaseOptions)

Source: https://docs.eyesopen.com/toolkits/python/index.html/fastrocstk/OEFastROCSClasses/OEShapeDatabaseOptions

Returns the number of color atom starting points for shape optimization. This method requires OEShapeDatabaseOptions.SetInitialOrientation to be set to OEFastROCSOrientation_InertialAtColorAtoms and a query molecule. If the query molecule lacks color atoms, a warning is issued and the search defaults to OEFastROCSOrientation_Inertial.

```C++
unsigned int GetNumColorAtomStarts(const OEChem::OEMolBase &query) const
```

```APIDOC
OEFastROCS::OEShapeDatabaseOptions::GetNumColorAtomStarts
  Purpose: Returns the number of color atom starting points set for shape optimization.
  Signature: unsigned int GetNumColorAtomStarts(const OEChem::OEMolBase &query) const
  Parameters:
    query: const OEChem::OEMolBase & - The query molecule.
  Returns: unsigned int
  Requirements: OEShapeDatabaseOptions.SetInitialOrientation must be set to OEFastROCSOrientation_InertialAtColorAtoms.
  Notes: If the query molecule does not have color atoms, the search will throw a warning and default to OEFastROCSOrientation_Inertial.
  See also: OEShapeDatabaseOptions.SetInitialOrientation, OEShapeDatabaseOptions.GetNumStarts, OEFastROCSOrientation
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.