ADMET-AI

https://github.com/swansonk14/admet_ai
Admin
ADMET-AI is a machine learning platform for predicting absorption, distribution, metabolism,...
Tokens:93,611
Snippets:494
Trust Score:8.5
License:MIT
Update:9 months ago
Show doc for...
Tokens:
Raw
### Start ADMET-AI web server

Source: https://github.com/swansonk14/admet_ai/blob/main/README.md

Launches the ADMET-AI web server, allowing users to make predictions through a web interface. This command requires the installation of additional web dependencies.

```bash
admet_web

```

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

### Install JSME: Include Script, Define Load Function, and Place Container

Source: https://github.com/swansonk14/admet_ai/blob/main/admet_ai/web/app/static/jsme/doc.html

This snippet demonstrates the minimal setup required to install and initialize the JSME chemical structure editor in a web page. It includes the JSME JavaScript file, defines the `jsmeOnLoad` function to create a JSME instance, and specifies a `div` element as the container for the editor.

```html
<html>
<head>
<script type="text/javascript" language="javascript" src="jsme/jsme.nocache.js"></script>
<script>
 function jsmeOnLoad() {
  jsmeApplet = new JSApplet.JSME("jsme_container", "380px", "340px");
 }
</script>
</head>
<body>
<div id="jsme_container"></div>
</body>
</html>
```

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

### JSME: Initialize with Custom Options

Source: https://github.com/swansonk14/admet_ai/blob/main/admet_ai/web/app/static/jsme/doc.html

This code snippet shows how to initialize the JSME editor with custom options by passing a third argument to the `JSApplet.JSME` constructor. The example demonstrates setting the `oldlook` and `marker` options.

```html
<html>
<head>
<script type="text/javascript" language="javascript" src="jsme/jsme.nocache.js"></script>
<script>
 function jsmeOnLoad() {
  jsmeApplet = new JSApplet.JSME("jsme_container", "380px", "340px", {
   "options" : "oldlook,marker"
  });
 }
</script>
</head>
<body>
<div id="jsme_container"></div>
<button type="button" onclick="alert(jsmeApplet.smiles())">Show SMILES</button>
</body>
</html>
```

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

### JSME: Display SMILES on Button Click

Source: https://github.com/swansonk14/admet_ai/blob/main/admet_ai/web/app/static/jsme/doc.html

This example extends the basic JSME installation by adding a button that, when clicked, displays the SMILES string of the molecule currently drawn in the editor. It assumes the `jsmeApplet` instance has been created and is accessible.

```html
<html>
<head>
<script type="text/javascript" language="javascript" src="jsme/jsme.nocache.js"></script>
<script>
 function jsmeOnLoad() {
  jsmeApplet = new JSApplet.JSME("jsme_container", "380px", "340px");
 }
</script>
</head>
<body>
<div id="jsme_container"></div>
<button type="button" onclick="alert(jsmeApplet.smiles())">Show SMILES</button>
</body>
</html>
```

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

### JSME - Initialization

Source: https://github.com/swansonk14/admet_ai/blob/main/admet_ai/web/app/static/jsme/api_javadoc/index-all.html

Handles the initialization and setup of the JSME editor.

```APIDOC
## JSME Constructors

### Description
These constructors are used to initialize a new JSME editor instance. Different constructors allow for varying levels of customization during initialization.

### JSME(String, String, String)

#### Method
POST

#### Endpoint
/jsme/initialize

#### Parameters
##### Request Body
- **id** (string) - Required - The ID of the HTML element where the JSME editor will be rendered.
- **width** (string) - Required - The width of the editor canvas.
- **height** (string) - Required - The height of the editor canvas.

#### Request Example
```json
{
  "id": "jsme_editor",
  "width": "500px",
  "height": "400px"
}
```

### JSME(String)

#### Method
POST

#### Endpoint
/jsme/initialize

#### Parameters
##### Request Body
- **id** (string) - Required - The ID of the HTML element where the JSME editor will be rendered.

#### Request Example
```json
{
  "id": "jsme_editor"
}
```

### JSME(String, String, String, JavaScriptObject)

#### Method
POST

#### Endpoint
/jsme/initialize

#### Parameters
##### Request Body
- **id** (string) - Required - The ID of the HTML element where the JSME editor will be rendered.
- **width** (string) - Required - The width of the editor canvas.
- **height** (string) - Required - The height of the editor canvas.
- **parameters** (object) - Optional - A JavaScript object for additional customization options.

#### Request Example
```json
{
  "id": "jsme_editor",
  "width": "500px",
  "height": "400px",
  "parameters": {
    "options": "..."
  }
}
```

### JSME(String, JavaScriptObject)

#### Method
POST

#### Endpoint
/jsme/initialize

#### Parameters
##### Request Body
- **id** (string) - Required - The ID of the HTML element where the JSME editor will be rendered.
- **parameters** (object) - Optional - A JavaScript object for additional customization options.

#### Request Example
```json
{
  "id": "jsme_editor",
  "parameters": {
    "options": "..."
  }
}
```

### Response (for all constructors)
#### Success Response (200)
- **status** (string) - Indicates the initialization status (e.g., "initialized").

#### Response Example
```json
{
  "status": "initialized"
}
```
```

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

### Install ADMET-AI from source

Source: https://github.com/swansonk14/admet_ai/blob/main/README.md

Installs ADMET-AI locally by cloning the repository and using pip. This method is useful for development or when specific version control is needed. It also allows for installing with specific requirements from a requirements.txt file.

```bash
git clone https://github.com/swansonk14/admet_ai.git
cd admet_ai
pip install -e .

```

```bash
pip install -r requirements.txt
pip install -e .

```

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

### Deploy ADMET AI Web Server

Source: https://context7.com/swansonk14/admet_ai/llms.txt

Deploy a Flask-based web server for interactive ADMET predictions and visualization. This involves installing the web dependencies and running the `admet_web` command to start the server locally.

```bash
# Install web dependencies
pip install admet-ai[web]

# Start the web server
admet_web

# Server starts at http://127.0.0.1:5000
```

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

### Install ADMET-AI using pip

Source: https://github.com/swansonk14/admet_ai/blob/main/README.md

Installs the ADMET-AI package using pip. This command installs the core dependencies for command line and Python API usage. Additional dependencies for TDC data processing or web server hosting can be installed with specific extras.

```bash
pip install admet-ai

```

```bash
pip install admet-ai[tdc]

```

```bash
pip install admet-ai[web]

```

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

### replaceAllAppletsByJSME

Source: https://github.com/swansonk14/admet_ai/blob/main/admet_ai/web/app/static/jsme/api_javadoc/export/client/JSME.html

Scans the DOM for DIV elements with the attribute `code="JME.class"` and installs a running JSME instance in each. Returns the total number of JSME instances installed.

```APIDOC
## replaceAllAppletsByJSME

### Description
Scans the DOM for DIV elements with the attribute `code="JME.class"` and installs a running JSME instance in each. Returns the total number of JSME instances installed.

### Method
`public static int replaceAllAppletsByJSME()`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
- **Integer** - The number of JSME instances installed.

#### Response Example
None
```

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

### Accessing JSME Instances in JavaScript

Source: https://github.com/swansonk14/admet_ai/blob/main/admet_ai/web/app/static/jsme/doc.html

Demonstrates how to access JSME instances within JavaScript code, contrasting it with JME applet access. It shows using a variable name or the `document.jsapplets` array, highlighting the change from `document.applets` for JME.

```javascript
// Accessing JME applets:
// document._JME_ (by variable name)
// document._applets[0] (by applet array)

// Accessing JSME instances:
// document._JME_ (by variable name)
// document._jsapplets[0] (by jsapplets array)
```

```html
<div code="JME.class" name="JME1" archive="JME.jar" width="360" height="315" id="JME">
You have to enable JavaScript on your machine ! </div>
<div code="JME.class" name="JME2" archive="JME.jar" width="360" height="315" id="JME">
You have to enable JavaScript on your machine ! </div>>

<input type="button" value="Get smiles via document.JME1" onclick="alert(document.JME1.smiles());">
<input type="button" value="Get smiles via document.jsapplets[1]" onclick="alert(document.jsapplets[1].smiles());">
```

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

### JSME Initialization with `jsmeOnLoad`

Source: https://github.com/swansonk14/admet_ai/blob/main/admet_ai/web/app/static/jsme/doc.html

This snippet addresses a timing issue with JSME initialization by using a custom `jsmeOnLoad` function instead of the standard `body.onload()`. This ensures JSME instances are ready before custom initialization code is executed.

```javascript
function jsmeOnLoad() {
    loadJmeFile();loadMolFile();
}
```

```html
<body onLoad="">
<script>
function jsmeOnLoad() {
    loadJmeFile();loadMolFile();
}
</script>
</body>
```

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

### JSME Constructor Examples

Source: https://github.com/swansonk14/admet_ai/blob/main/admet_ai/web/app/static/jsme/api_javadoc/export/client/JSME.html

These constructors are used to initialize a JSME instance. They allow for specifying the HTML element ID, dimensions, and optional JavaScript object parameters for customization. The parameters object can be used for advanced settings of the JSME editor.

```java
JSME(java.lang.String htmlId)
JSME(java.lang.String htmlId, com.google.gwt.core.client.JavaScriptObject parameterJso)
JSME(java.lang.String htmlId, java.lang.String width, java.lang.String height)
JSME(java.lang.String htmlId, java.lang.String width, java.lang.String height, com.google.gwt.core.client.JavaScriptObject parameters)
```

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

### JavaScript: Initialize JSME Applet and Callbacks

Source: https://github.com/swansonk14/admet_ai/blob/main/admet_ai/web/app/static/jsme/JSME_atom_highlight_demo.html

This function initializes the JSME applet after the JavaScriptApplet code has loaded. It sets up a starting molecular structure and registers callback functions for atom and bond highlighting.

```javascript
function jsmeOnLoad() {
  var startingStructure = "13 14 C 11.31 -8.45 C 11.31 -7.05 C 10.09 -6.35 C 8.88 -7.05 C 8.88 -8.45 C 10.09 -9.15 C 12.71 -8.45 C 12.71 -7.05 O 13.70 -6.06 C 13.70 -9.44 C 13.33 -10.79 C 15.05 -9.07 N 16.40 -8.71 1 2 1 2 3 -1 3 4 1 4 5 1 5 6 1 1 6 -1 7 8 1 2 8 1 1 7 1 8 9 2 7 10 -1 10 11 2 10 12 1 12 13 3"; //Instantiate a new JSME:
 //arguments: HTML id, width, height (must be string not number!)
 jsmeApplet = new JSApplet.JSME("appletContainer", "600px", "440px", {
  //optional parameters
  //"options": "depict,marker",
  "options": "nodepict,marker,markermenu,",
  "jme": startingStructure,
 });
 jsmeApplet.setCallBack("AtomHighlight", atomHighLight);
 jsmeApplet.setCallBack("BondHighlight", bondHighLight);
}
```

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

### Replace Applets with JSME

Source: https://github.com/swansonk14/admet_ai/blob/main/admet_ai/web/app/static/jsme/api_javadoc/export/client/JSME.html

Scans the DOM for DIV elements with the attribute `code="JME.class"` and installs a running JSME instance in each. Returns the total number of JSME instances installed.

```java
public static int replaceAllAppletsByJSME()
```

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

### Get Menu X Shortcuts API

Source: https://github.com/swansonk14/admet_ai/blob/main/admet_ai/web/app/static/jsme/api_javadoc/export/client/JSME.html

Retrieves the custom keyboard shortcuts set for the X menu box.

```APIDOC
## GET /api/getMenuXShortcuts

### Description
Retrieves the custom keyboard shortcuts that have been set using the `setMenuXShortcuts` method.

### Method
GET

### Endpoint
/api/getMenuXShortcuts

### Parameters
None

### Response
#### Success Response (200)
- **shortcuts** (string) - The string of custom shortcut letters.

#### Response Example
```json
{
  "shortcuts": "abc"
}
```
```

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

### Initialize JSME Applets from DOM

Source: https://github.com/swansonk14/admet_ai/blob/main/admet_ai/web/app/static/jsme/api_javadoc/export/client/JSME.html

Scans the Document Object Model (DOM) for DIV elements with the attribute 'code="JME.class"' and initializes a running JSME applet within each. This is a static method that processes the entire page for applet installations. It can accept an optional JavaScript closure for further customization after initialization.

```JavaScript
JSME.replaceAllAppletsByJSME();
JSME.replaceAllAppletsByJSME(jsFunctionWithJsmeInstanceArg);
```

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

### Initialize JSME with Predefined Structure and Background Colors

Source: https://github.com/swansonk14/admet_ai/blob/main/admet_ai/web/app/static/jsme/JSME_access_internal_data.html

Initializes a JSME instance with a predefined chemical structure and a callback for structure modification. This example demonstrates setting initial molecular data and handling user edits.

```javascript
(() => {
  var tabIndex = 3;
  jsmeApplet3 = new JSApplet.JSME("jsme_container-" + tabIndex, "640px", "400px", {
    "options": "oldlook",
    "jme": "3 2 C 0.00 2.10 C 1.21 1.40 C 1.21 0.00 1 2 2 2 3 1"
  });
  jsmeApplet3.setCallBack("AfterStructureModified", (event) => {
    showEvent(event, tabIndex)
  });
  resetLogs(tabIndex);
})();
```

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

### Initialize JSME Editors in DOM

Source: https://github.com/swansonk14/admet_ai/blob/main/admet_ai/web/app/static/jsme/api_javadoc/export/client/JSME.html

Scans the DOM for DIV elements with the attribute 'code="JME.class"' and installs a running JSME instance within each. It accepts a JavaScript callback function that is executed once a JSME instance is successfully created. This function is crucial for dynamically integrating JSME editors into web pages.

```Java
public static int replaceAllAppletsByJSME(JsClosure jsFunctionWithJsmeInstanceArg)
{
    // Scan the DOM for DIV's containing an attribute code="JME.class" and install a running JSME. Call the argument when done.
    // See also `getCreationIndex`.
    // Parameters:
    // `jsFunctionWithJsmeInstanceArg:` - a function defined in JavaScript such as : function(eachJsmeInstance){alert("JSME created. Creation index: "+ eachJsmeInstance.getCreationIndex() )};
    // Returns:
    // the number of new JSME installed.
    return 0; // Placeholder implementation
}
```

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

### Initialize JSME Applet and Load Structure

Source: https://github.com/swansonk14/admet_ai/blob/main/admet_ai/web/app/static/jsme/JSME_editor_plus_SVG.html

This JavaScript function initializes the JSME applet after the applet code has been loaded. It defines a starting molecular structure and then creates a new JSME applet instance within a specified container. The function also sets up a callback for structural changes to the `showSVG` function.

```javascript
function jsmeOnLoad() {
  var startingStructure = "13 14 C 15.94 -11.45 C 15.94 -10.05 C 14.72 -9.35 C 13.51 -10.05 C 13.51 -11.45 C 14.72 -12.15 C 17.34 -11.45 C 17.34 -10.05 O 18.33 -9.06 C 18.33 -12.44 C 17.96 -13.79 C 19.68 -12.07 N 21.03 -11.71 1 2 1 2 3 -1 3 4 1 4 5 1 5 6 1 1 6 -1 7 8 1 2 8 1 1 7 1 8 9 2 7 10 -1 10 11 2 10 12 1 12 13 3";
  jsmeApplet = new JSApplet.JSME("jsme\_container", "640px", "480px", { "options": "oldlook", "jme": startingStructure });
  jsmeApplet.setNotifyStructuralChangeJSfunction("showSVG");
}
```

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

### Initialize JSME Applet and Display SVG - JavaScript

Source: https://github.com/swansonk14/admet_ai/blob/main/admet_ai/web/app/static/jsme/JSME_SVG.html

This JavaScript function is called after the JSME applet is loaded. It initializes the applet with a starting molecular structure and sets up a callback function to display the generated SVG. The `showSVG` function then retrieves and inserts the SVG representation into specified HTML elements.

```javascript
function jsmeOnLoad() {
  var startingStructure = "13 14 C 15.94 -11.45 C 15.94 -10.05 C 14.72 -9.35 C 13.51 -10.05 C 13.51 -11.45 C 14.72 -12.15 C 17.34 -11.45 C 17.34 -10.05 O 18.33 -9.06 C 18.33 -12.44 C 17.96 -13.79 C 19.68 -12.07 N 21.03 -11.71 1 2 1 2 3 -1 3 4 1 4 5 1 5 6 1 1 6 -1 7 8 1 2 8 1 1 7 1 8 9 2 7 10 -1 10 11 2 10 12 1 12 13 3";
  jsmeApplet = new JSApplet.JSME("jsme_container", "380px", "340px", { "options": "depict", "jme": startingStructure });
  jsmeApplet.setNotifyStructuralChangeJSfunction("showSVG");
}

function showSVG() {
  elm = document.getElementById("svg_container");
  elm.innerHTML = jsmeApplet.getMolecularAreaGraphicsString();
  elm = document.getElementById("svg_textarea");
  elm.innerHTML = jsmeApplet.getMolecularAreaGraphicsString();
}
```

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

### Replace Applets with JSME and Add Event Handlers (JavaScript)

Source: https://github.com/swansonk14/admet_ai/blob/main/admet_ai/web/app/static/jsme/test_resize_and_replace_jme.html

This function, testReplaceAllAppletsByJSME, demonstrates how to replace existing applets with JSME instances. It also includes examples of adding click and mouseOver event handlers to the JSME applet, allowing interaction and retrieval of SMILES strings. Dependencies include the JSME library and DOM manipulation.

```javascript
function testReplaceAllAppletsByJSME() {
  var p = document.getElementById("demo");
  var jme2Div = document.getElementById("jme2");
  jme2Div.setAttribute("code", "JME.class");
  var n = JSApplet.JSME.replaceAllAppletsByJSME(function (n) {
  });
  console.log(n);
  //Add a click handler to the Jsapplet in depict mode
  document.jmeDepict.addClickHandler(function (jsmeInstance, event) {
    alert("My smiles is: " + jsmeInstance.smiles());
    alert(event);
  });
  //Add a mouseOver handler to the Japplet in depict mode
  document.jmeDepict.addMouseOverHandler(function (jsmeInstance, event) {
    console.log("My smiles is: " + jsmeInstance.smiles());
    console.log("x: " + event.clientX);
  });
  //neutralize my self
  testReplaceAllAppletsByJSME = function () {
  };
}
```

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

### Get Specific Molecule from JSME

Source: https://github.com/swansonk14/admet_ai/blob/main/admet_ai/web/app/static/jsme/api_javadoc/export/client/JSME.html

Retrieves a specific molecule from the JSME editor based on its index. Molecule indices start from 1. If the provided index is invalid, the method returns null.

```java
public JSMEmolecule getMolecule(int molIndex)
{
    // Implementation to get a molecule by index
    return null; // Placeholder
}
```

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

### JSME - Appearance and Display Settings

Source: https://github.com/swansonk14/admet_ai/blob/main/admet_ai/web/app/static/jsme/api_javadoc/index-all.html

Methods for setting the editor's height, help URL, marker color palette, menu scale, X menu shortcuts, and molecular area properties.

```APIDOC
## setHeight /api/jsme

### Description
Sets the height of the JSME editor.

### Method
POST

### Endpoint
/api/jsme

### Parameters
#### Request Body
- **height** (String) - Required - The height value (e.g., '300px', '50%').

### Request Example
```json
{
  "height": "400px"
}
```

### Response
#### Success Response (200)
- **message** (String) - Indicates the operation was successful.

#### Response Example
```json
{
  "message": "Height set successfully."
}
```

## setHelpURL /api/jsme

### Description
Sets the URL for the JSME help page.

### Method
POST

### Endpoint
/api/jsme

### Parameters
#### Request Body
- **url** (String) - Required - The URL of the help page.

### Request Example
```json
{
  "url": "http://example.com/jsme-help"
}
```

### Response
#### Success Response (200)
- **message** (String) - Indicates the operation was successful.

#### Response Example
```json
{
  "message": "Help URL set successfully."
}
```

## setMarkerMenuBackGroundColorPalette /api/jsme

### Description
Sets the color palette for highlighting atoms and bonds in the marker pop-up menu. Colors should be in hexadecimal format with an associated name.

### Method
POST

### Endpoint
/api/jsme

### Parameters
#### Request Body
- **colorPalette** (Array<Object>) - Required - An array of color specifications.
  - **color** (String) - Required - The hexadecimal color code.
  - **name** (String) - Required - The name of the color for the menu.

### Request Example
```json
{
  "colorPalette": [
    {"color": "#FF0000", "name": "Red Highlight"},
    {"color": "#00FF00", "name": "Green Highlight"}
  ]
}
```

### Response
#### Success Response (200)
- **message** (String) - Indicates the operation was successful.

#### Response Example
```json
{
  "message": "Marker menu background color palette set successfully."
}
```

## setMenuScale /api/jsme

### Description
Sets the scaling factor for the menu.

### Method
POST

### Endpoint
/api/jsme

### Parameters
#### Request Body
- **scale** (double) - Required - The scaling factor.

### Request Example
```json
{
  "scale": 1.5
}
```

### Response
#### Success Response (200)
- **message** (String) - Indicates the operation was successful.

#### Response Example
```json
{
  "message": "Menu scale set successfully."
}
```

## setMenuXShortcuts /api/jsme

### Description
Specifies custom keyboard shortcut letters for the X menu box.

### Method
POST

### Endpoint
/api/jsme

### Parameters
#### Request Body
- **shortcuts** (String) - Required - A string defining the custom shortcuts.

### Request Example
```json
{
  "shortcuts": "ABC"
}
```

### Response
#### Success Response (200)
- **message** (String) - Indicates the operation was successful.

#### Response Example
```json
{
  "message": "X menu shortcuts set successfully."
}
```

## setMolecularAreaAntiAlias /api/jsme

### Description
Enables or disables anti-aliasing for the molecular drawing area.

### Method
POST

### Endpoint
/api/jsme

### Parameters
#### Request Body
- **enabled** (boolean) - Required - True to enable anti-aliasing, false to disable.

### Request Example
```json
{
  "enabled": true
}
```

### Response
#### Success Response (200)
- **message** (String) - Indicates the operation was successful.

#### Response Example
```json
{
  "message": "Molecular area anti-aliasing set successfully."
}
```

## setMolecularAreaLineWidth /api/jsme

### Description
Sets the line width in pixels for the molecular drawing area.

### Method
POST

### Endpoint
/api/jsme

### Parameters
#### Request Body
- **width** (float) - Required - The line width in pixels.

### Request Example
```json
{
  "width": 1.5
}
```

### Response
#### Success Response (200)
- **message** (String) - Indicates the operation was successful.

#### Response Example
```json
{
  "message": "Molecular area line width set successfully."
}
```

## setMolecularAreaScale /api/jsme

### Description
Sets the scaling factor for the molecular drawing area.

### Method
POST

### Endpoint
/api/jsme

### Parameters
#### Request Body
- **scale** (double) - Required - The scaling factor.

### Request Example
```json
{
  "scale": 0.8
}
```

### Response
#### Success Response (200)
- **message** (String) - Indicates the operation was successful.

#### Response Example
```json
{
  "message": "Molecular area scale set successfully."
}
```
```

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

### Get JSME Instance Creation Index

Source: https://github.com/swansonk14/admet_ai/blob/main/admet_ai/web/app/static/jsme/api_javadoc/export/client/JSME.html

Returns the creation index of the current JSME instance. The JSME class maintains a count of all created instances, and this index represents the order in which the instance was created (starting from 0 for the first instance).

```Java
public int getCreationIndex()
```

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

### JSME - Static Initialization

Source: https://github.com/swansonk14/admet_ai/blob/main/admet_ai/web/app/static/jsme/api_javadoc/index-all.html

Provides static methods for automatically initializing JSME editors found in the DOM.

```APIDOC
## replaceAllAppletsByJSME()

### Description
Scans the DOM for DIV elements with the attribute `code="JME.class"` and automatically installs a running JSME editor in each found element.

### Method
POST

### Endpoint
/jsme/replaceAllApplets

### Parameters
None

### Request Example
None

### Response
#### Success Response (200)
- **status** (string) - Indicates the result of the replacement operation (e.g., "success").

#### Response Example
```json
{
  "status": "success"
}
```

## replaceAllAppletsByJSME(JsClosure)

### Description
Scans the DOM for DIV elements with the attribute `code="JME.class"` and installs a running JSME editor. Allows for a JavaScript closure to be executed after each editor is installed.

### Method
POST

### Endpoint
/jsme/replaceAllApplets

### Parameters
#### Request Body
- **closure** (object) - Required - A JavaScript closure object to be executed for each installed JSME editor.

### Request Example
```json
{
  "closure": "function(jsmeInstance) { ... }"
}
```

### Response
#### Success Response (200)
- **status** (string) - Indicates the result of the replacement operation (e.g., "success").

#### Response Example
```json
{
  "status": "success"
}
```
```

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

### JSME - Callback and Clipboard Functionality

Source: https://github.com/swansonk14/admet_ai/blob/main/admet_ai/web/app/static/jsme/api_javadoc/index-all.html

Methods for setting generic callbacks, clipboard format, and marker colors.

```APIDOC
## setCallBack /api/jsme

### Description
Sets a generic callback function to be executed.

### Method
POST

### Endpoint
/api/jsme

### Parameters
#### Request Body
- **callbackName** (String) - Required - The name of the callback event.
- **jsFunction** (JavaScriptObject) - Required - The JavaScript object representing the callback function.

### Request Example
```json
{
  "callbackName": "onMoleculeChange",
  "jsFunction": "function() { console.log('Molecule changed!'); }"
}
```

### Response
#### Success Response (200)
- **message** (String) - Indicates the operation was successful.

#### Response Example
```json
{
  "message": "Callback set successfully."
}
```

## setCopyToClipboardFormat /api/jsme

### Description
Sets the file format for copying molecular data to the clipboard using Ctrl+C or drag and drop.

### Method
POST

### Endpoint
/api/jsme

### Parameters
#### Request Body
- **format** (String) - Required - The desired format (e.g., 'mol', 'sdf').

### Request Example
```json
{
  "format": "sdf"
}
```

### Response
#### Success Response (200)
- **message** (String) - Indicates the operation was successful.

#### Response Example
```json
{
  "message": "Clipboard format set successfully."
}
```

## setMarkerColor /api/jsme

### Description
Sets the color for markers. This method is deprecated.

### Method
POST

### Endpoint
/api/jsme

### Parameters
#### Request Body
- **color** (String) - Required - The hexadecimal color code for the marker.

### Request Example
```json
{
  "color": "#00FF00"
}
```

### Response
#### Success Response (200)
- **message** (String) - Indicates the operation was successful.

#### Response Example
```json
{
  "message": "Marker color set successfully (Deprecated)."
}
```
```

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

### JSME Callback: AfterStructureModified

Source: https://github.com/swansonk14/admet_ai/blob/main/admet_ai/web/app/static/jsme/doc.html

Register a JavaScript function to be called after a structure modification event occurs in JSME. This is useful for creating interactive pages that react to changes, such as computing and displaying 3D structures. The function receives a JSMEevent object.

```javascript
function showSmiles(jsmeEvent) {
	var jsme = jsmeEvent.src;
	var smiles = jsme.smiles();
	alert(smiles);
}

jsmeApplet.setCallBack("AfterStructureModified", showSmiles);
```

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

### JSME GUI Options

Source: https://github.com/swansonk14/admet_ai/blob/main/admet_ai/web/app/static/jsme/doc.html

Control various aspects of the JSME GUI's behavior. These options can be set during instance creation or later using the options() method. They affect features like zooming, drag-and-drop icons, and context menus.

```javascript
zoomgui, nozoomgui
showdragandDropIconindepictmode, noShowdragandDropIconindepictmode
contextmenu, nocontextmenu
```

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

### Docker: Build and Run ADMET-AI Image

Source: https://context7.com/swansonk14/admet_ai/llms.txt

These bash commands outline the process of building a Docker image for ADMET-AI and running it as a container. It includes commands for building the image, running the web server, and running command-line predictions with volume mounting.

```bash
# Build Docker image
docker build -t admet-ai .

# Run container with web server
docker run -p 5000:5000 admet-ai

# Run container for command-line predictions
docker run -v $(pwd)/data:/data admet-ai \
    admet_predict \
    --data_path /data/molecules.csv \
    --save_path /data/predictions.csv \
    --smiles_column smiles

# Run with GPU support
docker run --gpus all -p 5000:5000 admet-ai

# Interactive shell in container
docker run -it admet-ai /bin/bash
```

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

### Migrate JME Applet to JSME Div in HTML

Source: https://github.com/swansonk14/admet_ai/blob/main/admet_ai/web/app/static/jsme/doc.html

This snippet shows the transformation of an HTML page from using the JME Java applet tag to the JSME div tag. It involves including the JSME JavaScript file and replacing `<applet>` with `<div>` while retaining relevant attributes.

```html
<html>
<head>
<title>JME Example</title>
</head>

<body>
<applet code="JME.class" name="JME" archive="JME.jar" width="360" height="315" id="JME">
You have to enable Java and JavaScript in your browser to use JME!
</applet>
</body>
</html>
```

```html
<html>
<head>
<script type="text/javascript" language="javascript" src="jsme/jsme.nocache.js"></script>
<title>JME Example</title>
</head>

<body>
<div code="JME.class" name="JME" archive="JME.jar" width="360" height="315" id="JME">
You have to enable JavaScript in your browser to use JSME! </div>
</body>
</html>
```

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

### Initialize JSME Applet and Set Atom Highlight Callback (JavaScript)

Source: https://github.com/swansonk14/admet_ai/blob/main/admet_ai/web/app/static/jsme/JSME_depict.html

Initializes the JSME applet for chemical structure rendering and sets up a callback function to highlight atoms when they are interacted with. It loads an initial molecule and configures the applet for 'depict' mode.

```javascript
function atomHighLight(jsmeEvent) { document.getElementById("atomHighLightTextAreaOut").value = jsmeEvent.atomE; } //this function will be called after the JavaScriptApplet code has been loaded.
function jsmeOnLoad() {
  jsmeApplet = new JSApplet.JSME("jsme_container", "180px", "140px", {"options": "depict"});
  jsmeApplet.setCallBack("AtomHighlight", atomHighLight);
  var jme = "16 17 C 7.37 -8.99 C 7.37 -7.59 C 6.16 -6.89 C 4.95 -7.59 C 4.95 -8.99 C 6.16 -9.69 N 8.58 -6.89 C 8.58 -5.49 C 7.37 -4.79 O 6.16 -5.49 C 9.80 -7.59 O 9.80 -8.99 C 11.01 -6.89 Cl 12.22 -7.59 Cl 11.01 -5.49 C 9.80 -4.79 1 2 1 2 3 2 3 4 1 4 5 2 5 6 1 6 1 2 7 8 1 8 9 1 9 10 1 3 10 1 2 7 1 7 11 1 11 12 2 11 13 1 13 14 1 13 15 1 8 16 1";
  jsmeApplet.readMolecule(jme);
}
```

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

### Initialize JSME Applet with Dojo and JSME Readiness Checks

Source: https://github.com/swansonk14/admet_ai/blob/main/admet_ai/web/app/static/jsme/JSME_dojo.html

This JavaScript code snippet demonstrates how to initialize the JSME applet after both Dojo Toolkit and the JSME JavaScript library have loaded and are ready. It uses Dojo's `require` function for module loading and defines readiness flags to control the applet's initialization.

```javascript
dojo_is_ready = false;
j sme_is_ready = false;

function dojo_jsme_ready() {
  if(dojo_is_ready && jsme_is_ready) {
    jsmeApplet = new JSApplet.JSME("jsme_container", "380px", "340px");
  }
}

require([
  "dijit/Menu",
  "dijit/MenuItem",
  "dijit/MenuSeparator",
  "dojo/domReady!"
], function(){
  dojo_is_ready=true;
  dojo_jsme_ready();
});

//this function will be called after the JavaScriptApplet code has been loaded.
function jsmeOnLoad() {
  jsme_is_ready = true;
  dojo_jsme_ready();
}
```

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

### Get Specific Atom from JSME

Source: https://github.com/swansonk14/admet_ai/blob/main/admet_ai/web/app/static/jsme/api_javadoc/export/client/JSME.html

Retrieves a specific atom from the JSME editor, identified by molecule and atom indices (both starting at 1). If the molecule index is 0, the atom index is treated as an ensemble index. The returned data is a copy and does not allow modification of the internal state. Additional data, if present, is included.

```java
public JSMEatom getAtom(int molIndex, int atomIndex)
{
    // Implementation to get an atom by molecule and atom index
    return null; // Placeholder
}
```

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

### JSME Applet Initialization and Format Handling

Source: https://github.com/swansonk14/admet_ai/blob/main/admet_ai/web/app/static/jsme/JSME_test.html

Initializes the JSME applet, sets up supported file formats for copying, and defines the behavior when a format is selected. It also provides an alternative method for applet sizing and notes a known issue with format loading.

```javascript
var jsmeApplet = new JSApplet.JSME("appletContainer", "480px", "400px", {
  //optional parameters
  "options": "query,hydrogens",
  "jme": startingStructure
});

// Populate copy format selector
for (x in jsmeApplet.getSupportedFileFormats()) {
  copyFormatSelector.options[copyFormatSelector.options.length] = new Option(x, x);
}

copyFormatSelector.onchange = function(event) {
  var options = event.target.options;
  var format = options.item(options.selectedIndex).text;
  // used for both clipboard and drag out
  jsmeApplet.setCopyToClipboardFormat(format);
  /* Known issue: some format require loading of additional JavaScript code. The first time such a format is requested, the copy and drag will not work correctly because of loading of JavaScript code. */
};

// Alternative method: the size is not specified: the applet will use 100% of the space of its parent container "appletContainer".
// Be sure that the parent container size > 0, otherwise the applet will not be visible
/*
jsmeApplet = new JSApplet.JSME("appletContainer", {
  //optional parameters
  "options" : "query,hydrogens",
  "jme" : startingStructure
});
*/

// Opera patch: if some applet elements are not displayed, force repaint
// jsmeApplet.deferredRepaint(); // the applet will be repainted after the browser event loop returns
// it is recommended to use it if the JSME is created outside this jsmeOnLoad() function
// jsmeApplet has the same API as the original Java applet
// One can mimic the JME Java applet access to simplify the adaptation of HTML and JavaScript code:
document.JME = jsmeApplet;

// suggestion
// all buttons that access the jsme variable were disabled in the html
// Now enable all buttons that can access the jsme variable since the applet is ready
// example:
// document.getElementById("button").disabled=false;
```

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

### JavaScript: Initialize JSApplet and Amino Acid Depictions

Source: https://github.com/swansonk14/admet_ai/blob/main/admet_ai/web/app/static/jsme/JSME_template_aminoacids.html

This function is called upon page load. It initializes the main JSApplet peptide editor and then creates individual JSApplet instances for each amino acid, rendering their SMILES structures. It also sets up click handlers to add these amino acids to the editor.

```javascript
function jsmeOnLoad() {
  var peptideEditor = new JSApplet.JSME("jsme_container", "100%", "480px");
  peptideEditor.options("nofgmenu");
  createAminoAcidTable();

  var pasteAction = function (aaDepiction, event) {
    peptideEditor.setNewButtonStatus(true);
    //the clicked aa will be added to the molecule already present in the editor
    peptideEditor.readMolecule(aaDepiction.jmeFile());
    peptideEditor.setNewButtonStatus(false);
  };

  //create depiction for each amino acid
  for (var i = 0; i < aminoAcidsData.length; i++) {
    var id = aminoAcidsData[i][abbIndex];
    var depictedAA = new JSApplet.JSME(id, "100%", "110px", {"smiles": aminoAcidsData[i][smilesIndex], "options": "depict"});
    depictedAA.addClickHandler(pasteAction);
  }
}
```

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

### JSME - Background Color and Highlighting

Source: https://github.com/swansonk14/admet_ai/blob/main/admet_ai/web/app/static/jsme/api_javadoc/index-all.html

Methods for setting background colors for bonds and highlighting specific bonds.

```APIDOC
## setBondBackgroundColors /api/jsme

### Description
Sets background colors for bonds. If the molecular index is 0, the bond indices are valid for the molecular ensemble.

### Method
POST

### Endpoint
/api/jsme

### Parameters
#### Request Body
- **molIndex** (int) - Required - The index of the molecule.
- **bondIndices** (Array<int>) - Required - The indices of the bonds to set the background color for.
- **color** (String) - Required - The hexadecimal color code for the bond background.

### Request Example
```json
{
  "molIndex": 0,
  "bondIndices": [1, 2, 3],
  "color": "#FF0000"
}
```

### Response
#### Success Response (200)
- **message** (String) - Indicates the operation was successful.

#### Response Example
```json
{
  "message": "Bond background colors set successfully."
}
```

## setBondToHighLight /api/jsme

### Description
Highlights a bond, simulating a mouse-over effect.

### Method
POST

### Endpoint
/api/jsme

### Parameters
#### Request Body
- **molIndex** (int) - Required - The index of the molecule.
- **bondIndex** (int) - Required - The index of the bond to highlight.

### Request Example
```json
{
  "molIndex": 0,
  "bondIndex": 5
}
```

### Response
#### Success Response (200)
- **message** (String) - Indicates the operation was successful.

#### Response Example
```json
{
  "message": "Bond highlighted successfully."
}
```
```

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

### Get Specific Bond from JSME

Source: https://github.com/swansonk14/admet_ai/blob/main/admet_ai/web/app/static/jsme/api_javadoc/export/client/JSME.html

Retrieves a specific bond from the JSME editor using molecule and bond indices. Similar to getting atoms, the indices are 1-based. This method is intended for accessing bond data, and its comments are analogous to the getAtom method.

```java
public JSMEBond getBond(int molIndex, int bondIndex)
{
    // Implementation to get a bond by molecule and bond index
    return null; // Placeholder
}
```

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

### Python API: Get DrugBank Reference Plot

Source: https://context7.com/swansonk14/admet_ai/llms.txt

Shows how to retrieve a DrugBank reference plot from the ADMET-AI API. It sends a GET request to '/drugbank_plot' with specified x and y task parameters and extracts the SVG data from the JSON response.

```python
# Get DrugBank reference plot
plot_response = requests.get(
    "http://127.0.0.1:5000/drugbank_plot",
    params={'x_task': 'logP', 'y_task': 'molecular_weight'}
)
plot_svg = plot_response.json()['svg']
```

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

### JavaScript: Initialize JSME Applets

Source: https://github.com/swansonk14/admet_ai/blob/main/admet_ai/web/app/static/jsme/test_depict_patent_reactions_smirks.html

This JavaScript function is responsible for initializing the JSME applets on the page. It is called after the initial depictions are loaded and ensures that all JSME applets are properly rendered. It also includes a callback to clear a loading indicator once the applets are ready.

```javascript
function jsmeOnLoad() {
  console.log('jsmeOnLoad');
  initJSMEdepictions(); //JSApplet.JSME.replaceAllAppletsByJSME();
  JSApplet.JSME.replaceAllAppletsByJSME(() => document.getElementById("loading-bar").innerHTML = '');
}
```

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

### Initialize JSME Applets

Source: https://github.com/swansonk14/admet_ai/blob/main/admet_ai/web/app/static/jsme/JSME_dnd_demo.html

Initializes two JSME applets, JME1 and JME2, with specified dimensions and options. This function is intended to be called on page load. It relies on the JSApplet library.

```javascript
function jsmeOnLoad() {
  document.JME1 = new JSApplet.JSME("JME1", "420px", "315px", { "options" : "noquery,polarnitro,nocanonize,oldlook" });
  document.JME2 = new JSApplet.JSME("JME2", "420px", "315px", { "options" : "noquery,polarnitro,nocanonize,oldlook" });
}
```

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

### getOffsetHeight

Source: https://github.com/swansonk14/admet_ai/blob/main/admet_ai/web/app/static/jsme/api_javadoc/export/client/JSME.html

Gets the object's offset height in pixels. This includes decorations such as border and padding, but not margin.

```APIDOC
## getOffsetHeight

### Description
Gets the object's offset height in pixels. This includes decorations such as border and padding, but not margin.

### Method
`public int getOffsetHeight()`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
- **Integer** - The offset height of the object in pixels.

#### Response Example
None
```

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

### getOffsetWidth

Source: https://github.com/swansonk14/admet_ai/blob/main/admet_ai/web/app/static/jsme/api_javadoc/export/client/JSME.html

Gets the object's offset width in pixels. This includes decorations such as border and padding, but not margin.

```APIDOC
## getOffsetWidth

### Description
Gets the object's offset width in pixels. This includes decorations such as border and padding, but not margin.

### Method
`public int getOffsetWidth()`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
- **Integer** - The offset width of the object in pixels.

#### Response Example
None
```

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

### Initialize JSME Applet and Load Molecule (JavaScript)

Source: https://github.com/swansonk14/admet_ai/blob/main/admet_ai/web/app/static/jsme/JSME_depict_action.html

This function is called after the JavaScriptApplet code has been loaded. It initializes a new JSME applet instance, sets its dimensions and options, and then reads a predefined chemical structure string into the editor.

```javascript
//this function will be called after the JavaScriptApplet code has been loaded.
function jsmeOnLoad() {
  jsmeApplet = new JSApplet.JSME("jsme_container", "180px", "140px", { options: "depict,markAtomOnly" });
  var jme = "16 17 C 7.37 -8.99 C 7.37 -7.59 C 6.16 -6.89 C 4.95 -7.59 C 4.95 -8.99 C 6.16 -9.69 N 8.58 -6.89 C 8.58 -5.49 C 7.37 -4.79 O 6.16 -5.49 C 9.80 -7.59 O 9.80 -8.99 C 11.01 -6.89 Cl 12.22 -7.59 Cl 11.01 -5.49 C 9.80 -4.79 1 2 1 2 3 2 3 4 1 4 5 2 5 6 1 6 1 2 7 8 1 8 9 1 9 10 1 3 10 1 2 7 1 7 11 1 11 12 2 11 13 1 13 14 1 13 15 1 8 16 1";
  jsmeApplet.readMolecule(jme);
}
```

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

### Get Background Color Palette in JSME

Source: https://github.com/swansonk14/admet_ai/blob/main/admet_ai/web/app/static/jsme/api_javadoc/export/client/JSME.html

Retrieves the list of colors used for highlighting atoms and bonds in hexadecimal format.

```java
public java.lang.String[] getBackGroundColorPalette()
```
Tokens:
Raw