To operate OpenTSDB using Java, the following Maven dependencies need to be added: ```xml <dependencies> <dependency> <groupId>net.opentsdb</groupId> <artifactId>opentsdb-client</artifactId> <version>2.4.0</version> </dependency> <dependency> <groupId>org.apache.httpcomponents</groupId> <artifactId>httpclient</artifactId> <version>4.5.12</version> </dependency> <dependency> <groupId>org.codehaus.jackson</groupId> <artifactId>jackson-mapper-asl</artifactId> <version>1.9.13</version> </dependency> </dependencies> ``` The following is a sample code for Java implementation of data addition, deletion, modification, and query: 1. Add data ```java import net.opentsdb.client.HttpClientImpl; import net.opentsdb.client.HttpClientImpl.HttpDataPointsBuilder; import net.opentsdb.client.builder.MetricBuilder; import net.opentsdb.client.response.Response; import java.io.IOException; import java.util.Date; class OpenTSDBExample { public static void main(String[] args) throws IOException { //OpenTSDB Connection Configuration String opentsdbHost = "http://localhost"; int opentsdbPort = 4242; //Create Connection HttpClientImpl httpClient = new HttpClientImpl(opentsdbHost, opentsdbPort); //Building data MetricBuilder builder = MetricBuilder.getInstance(); builder.addMetric("metric_name") .setDataPoint(new Date(), 100) .addTag("tag1", "value1") .addTag("tag2", "value2"); //Sending data HttpDataPointsBuilder httpBuilder = httpClient.createDataPoints(); httpBuilder.metric(builder); Response response = httpBuilder.execute(); System.out.println("Response: " + response.getStatusCode() + " " + response.getContent()); //Close Connection httpClient.close(); } } ``` 2. Query data ```java import com.fasterxml.jackson.databind.ObjectMapper; import net.opentsdb.client.HttpClientImpl; import net.opentsdb.client.HttpQueryClientImpl; import net.opentsdb.client.builder.Aggregator; import net.opentsdb.client.builder.QueryBuilder; import net.opentsdb.client.response.Response; import net.opentsdb.client.util.Aggregators; import java.io.IOException; import java.util.Date; class OpenTSDBExample { public static void main(String[] args) throws IOException { //OpenTSDB Connection Configuration String opentsdbHost = "http://localhost"; int opentsdbPort = 4242; //Create Connection HttpClientImpl httpClient = new HttpClientImpl(opentsdbHost, opentsdbPort); HttpQueryClientImpl queryClient = new HttpQueryClientImpl(httpClient); //Build Query Date startDate = new Date(); Date endDate = new Date(); QueryBuilder queryBuilder = QueryBuilder.getInstance(); queryBuilder .get() .sum() .aggregator(Aggregator.builder().name(Aggregators.SUM).build()) .metric("metric_name") .tag("tag1", "value1") .tag("tag2", "value2") .downsample("5m-avg") .downsample("5m-sum") .start(startDate) .end(endDate); //Send query request Response response = queryClient.query(queryBuilder); System.out.println("Response: " + response.getStatusCode() + " " + response.getContent()); //Parsing query results ObjectMapper objectMapper = new ObjectMapper(); QueryResult queryResult = objectMapper.readValue(response.getContent(), QueryResult.class); //Process Query Results //Close Connection httpClient.close(); } } ``` The above code examples are for reference only and need to be adapted according to the specific configuration and data model of OpenTSDB during actual use.

To use Java to operate CrateDB, you need to add the following Maven dependencies: ```xml <dependency> <groupId>io.crate</groupId> <artifactId>crate-client</artifactId> <version>VERSION</version> </dependency> ``` Please replace 'VERSION' with the version of CrateDB you want to use. The following is a sample code for Java implementation of data addition, deletion, modification, and query: ```java import io.crate.action.sql.SQLActionException; import io.crate.client.CrateClient; import io.crate.client.CrateClientFactory; import io.crate.client.ResultReceiver; import io.crate.data.Row; import io.crate.data.Row1; import io.crate.data.RowN; import io.crate.user.User; import java.net.InetSocketAddress; import java.util.List; import java.util.Map; public class CrateDBExample { public static void main(String[] args) { //Create CrateDB client CrateClient crateClient = CrateClientFactory.fromHosts(List.of(new InetSocketAddress("localhost", 5432))); try { //Create Table crateClient.execute("CREATE TABLE IF NOT EXISTS my_table (id INT PRIMARY KEY, name STRING)"); //Insert Data crateClient.execute("INSERT INTO my_table (id, name) VALUES (?, ?)", new Object[]{1, "John Doe"}); //Query data crateClient.execute("SELECT id, name FROM my_table", new ResultReceiver<Row>() { @Override public void setNextRow(Row row) { System.out.println(row); } @Override public void setColumns(List<? extends DataType> dataTypes) { //Can save column metadata as needed } @Override public void success(long rowCount) { System.out.println("Query executed successfully"); } @Override public void fail(Throwable throwable) { System.out.println("Query failed: " + throwable.getMessage()); } }); //Update data crateClient.execute("UPDATE my_table SET name = ? WHERE id = ?", new Object[]{"Jane Smith", 1}); //Delete data crateClient.execute("DELETE FROM my_table WHERE id = ?", new Object[]{1}); } catch (SQLActionException e) { //Handling SQL operation exceptions System.out.println("SQL action failed: " + e.getMessage()); } finally { //Close client connection crateClient.close(); } } } ``` In the above example, we first created a CrateDB client using the 'CrateClientFactory. FromHosts()' method and specified the host address and port number of CrateDB. Then, we can perform various SQL operations, such as creating tables, inserting data, querying data, updating data, and deleting data. For query operations, we need to provide a callback object that implements the 'ResultReceiver' interface to handle the returned results. Please modify the host address and port number according to the actual situation, and adjust the sample code according to your needs.

To operate QuestDB using Java, the following Maven dependencies need to be added: ```xml <dependency> <groupId>org.questdb</groupId> <artifactId>questdb</artifactId> <version>5.0.1</version> </dependency> <dependency> <groupId>org.questdb</groupId> <artifactId>questdb-jdbc</artifactId> <version>5.0.1</version> </dependency> ``` The following is the sample code for adding, deleting, and querying data in QuestDB implemented in Java: 1. Connect to QuestDB: ```java import java.sql.Connection; import java.sql.DriverManager; import java.sql.SQLException; public class QuestDBExample { public static void main(String[] args) { Connection connection = null; try { //To connect to the database, you need to provide the URL, username, and password of QuestDB connection = DriverManager.getConnection("jdbc:questdb:http://localhost:9000/", "admin", "quest"); //Perform query, insert, update, or delete operations here // ... } catch (SQLException e) { e.printStackTrace(); } finally { //Close database connection if (connection != null) { try { connection.close(); } catch (SQLException e) { e.printStackTrace(); } } } } } ``` 2. Create a table and insert data: ```java import java.sql.Connection; import java.sql.DriverManager; import java.sql.SQLException; import java.sql.Statement; public class CreateTableExample { public static void main(String[] args) { Connection connection = null; try { connection = DriverManager.getConnection("jdbc:questdb:http://localhost:9000/", "admin", "quest"); Statement statement = connection.createStatement(); //Create Table String createTableSQL = "CREATE TABLE quotes (timestamp TIMESTAMP, symbol SYMBOL, price DOUBLE)"; statement.execute(createTableSQL); //Insert Data String insertDataSQL = "INSERT INTO quotes VALUES (NOW(), 'AAPL', 135.25)"; statement.execute(insertDataSQL); } catch (SQLException e) { e.printStackTrace(); } finally { if (connection != null) { try { connection.close(); } catch (SQLException e) { e.printStackTrace(); } } } } } ``` 3. Query data: ```java import java.sql.*; public class QueryDataExample { public static void main(String[] args) { Connection connection = null; try { connection = DriverManager.getConnection("jdbc:questdb:http://localhost:9000/", "admin", "quest"); Statement statement = connection.createStatement(); //Query data String querySQL = "SELECT * FROM quotes"; ResultSet resultSet = statement.executeQuery(querySQL); //Process query results while (resultSet.next()) { Timestamp timestamp = resultSet.getTimestamp("timestamp"); String symbol = resultSet.getString("symbol"); double price = resultSet.getDouble("price"); System.out.println(timestamp + "," + symbol + "," + price); } } catch (SQLException e) { e.printStackTrace(); } finally { if (connection != null) { try { connection.close(); } catch (SQLException e) { e.printStackTrace(); } } } } } ``` 4. Update data: ```java import java.sql.*; public class UpdateDataExample { public static void main(String[] args) { Connection connection = null; try { connection = DriverManager.getConnection("jdbc:questdb:http://localhost:9000/", "admin", "quest"); Statement statement = connection.createStatement(); //Update data String updateSQL = "UPDATE quotes SET price = 140.50 WHERE symbol = 'AAPL'"; int rowsAffected = statement.executeUpdate(updateSQL); System.out.println("Rows affected: " + rowsAffected); } catch (SQLException e) { e.printStackTrace(); } finally { if (connection != null) { try { connection.close(); } catch (SQLException e) { e.printStackTrace(); } } } } } ``` 5. Delete data: ```java import java.sql.*; public class DeleteDataExample { public static void main(String[] args) { Connection connection = null; try { connection = DriverManager.getConnection("jdbc:questdb:http://localhost:9000/", "admin", "quest"); Statement statement = connection.createStatement(); //Delete data String deleteSQL = "DELETE FROM quotes WHERE symbol = 'AAPL'"; int rowsAffected = statement.executeUpdate(deleteSQL); System.out.println("Rows affected: " + rowsAffected); } catch (SQLException e) { e.printStackTrace(); } finally { if (connection != null) { try { connection.close(); } catch (SQLException e) { e.printStackTrace(); } } } } } ``` These sample codes demonstrate the basic operations of using Java to operate QuestDB, and you can modify and extend these codes as needed.

To use Java to manipulate MemSQL, you first need to add the following Maven dependencies: ```xml <dependency> <groupId>com.memsql</groupId> <artifactId>memsql-connector</artifactId> <version>2.0.15</version> </dependency> ``` This is the official Java connector provided by MemSQL. Next is a sample code for Java implementation of data addition, deletion, modification, and query: ```java import com.memsql.jdbc.MemSQLException; import com.memsql.jdbc.MemSQLConnection; import com.memsql.jdbc.MemSQLDataSource; import com.memsql.jdbc.MemSQLResultSet; import com.memsql.jdbc.MemSQLStatement; import java.sql.SQLException; public class MemSQLExample { //MemSQL database connection configuration private static final String HOST = "localhost"; private static final int PORT = 3306; private static final String DATABASE = "your_database_name"; private static final String USER = "your_username"; private static final String PASSWORD = "your_password"; public static void main(String[] args) { MemSQLDataSource dataSource = new MemSQLDataSource(); dataSource.setHost(HOST); dataSource.setPort(PORT); dataSource.setDatabase(DATABASE); dataSource.setUser(USER); dataSource.setPassword(PASSWORD); try (MemSQLConnection connection = (MemSQLConnection) dataSource.getConnection()) { //Create Table createTable(connection); //Insert Data insertData(connection); //Query data queryData(connection); //Update data updateData(connection); //Delete data deleteData(connection); } catch (SQLException e) { e.printStackTrace(); } } private static void createTable(MemSQLConnection connection) throws SQLException { String createTableSql = "CREATE TABLE IF NOT EXISTS example (id INT PRIMARY KEY, name VARCHAR(50))"; try (MemSQLStatement statement = (MemSQLStatement) connection.createStatement()) { statement.executeUpdate(createTableSql); } } private static void insertData(MemSQLConnection connection) throws SQLException { String insertSql = "INSERT INTO example (id, name) VALUES (1, 'John'), (2, 'Jane'), (3, 'Mike')"; try (MemSQLStatement statement = (MemSQLStatement) connection.createStatement()) { statement.executeUpdate(insertSql); } } private static void queryData(MemSQLConnection connection) throws SQLException { String querySql = "SELECT * FROM example"; try (MemSQLStatement statement = (MemSQLStatement) connection.createStatement(); MemSQLResultSet resultSet = (MemSQLResultSet) statement.executeQuery(querySql)) { while (resultSet.next()) { int id = resultSet.getInt("id"); String name = resultSet.getString("name"); System.out.println("ID: " + id + ", Name: " + name); } } } private static void updateData(MemSQLConnection connection) throws SQLException { String updateSql = "UPDATE example SET name = 'Kate' WHERE id = 2"; try (MemSQLStatement statement = (MemSQLStatement) connection.createStatement()) { statement.executeUpdate(updateSql); } } private static void deleteData(MemSQLConnection connection) throws SQLException { String deleteSql = "DELETE FROM example WHERE id = 3"; try (MemSQLStatement statement = (MemSQLStatement) connection.createStatement()) { statement.executeUpdate(deleteSql); } } } ``` This example code includes operations such as creating tables, inserting data, querying data, updating data, and deleting data. You can modify and expand according to your own needs. Please replace the 'your' in the above code_ Database_ Name, your_ Username 'and' your '_ Replace 'password' with your own MemSQL database name, username, and password.

To operate TimestreamDB using Java, you need to add the following Maven dependencies: ```xml <dependency> <groupId>software.amazon.awssdk</groupId> <artifactId>timestream</artifactId> <version>1.0.2</version> </dependency> ``` This way, you can use the Java SDK to operate TimestreamDB. Next, let's take a look at the sample code for implementing data addition, deletion, modification, and query in Java. Firstly, we need to create a TimestreamClient object for interacting with Timestream: ```java import software.amazon.awssdk.services.timestreamwrite.TimestreamWriteClient; public class TimestreamExample { private final TimestreamWriteClient timestreamWriteClient; public TimestreamExample(){ this.timestreamWriteClient = TimestreamWriteClient.builder().build(); } // Other methods } ``` Next, we can implement some common operations, such as creating a database, creating tables, inserting data, and querying data. Create database: ```java import software.amazon.awssdk.services.timestreamwrite.model.CreateDatabaseRequest; import software.amazon.awssdk.services.timestreamwrite.model.CreateDatabaseResponse; public class TimestreamExample { // Other codes public void createDatabase(String databaseName) { CreateDatabaseRequest request = CreateDatabaseRequest.builder() .databaseName(databaseName) .build(); CreateDatabaseResponse response = timestreamWriteClient.createDatabase(request); System.out.println("Database " + response.database().arn() + " created."); } } ``` Create Table: ```java import software.amazon.awssdk.services.timestreamwrite.model.CreateTableRequest; import software.amazon.awssdk.services.timestreamwrite.model.CreateTableResponse; public class TimestreamExample { // Other codes public void createTable(String databaseName, String tableName) { String table = databaseName + "." + tableName; CreateTableRequest request = CreateTableRequest.builder() .databaseName(databaseName) .tableName(tableName) .build(); CreateTableResponse response = timestreamWriteClient.createTable(request); System.out.println("Table " + table + " created."); } } ``` Insert data: ```java import software.amazon.awssdk.services.timestreamwrite.model.Dimension; import software.amazon.awssdk.services.timestreamwrite.model.MeasureValueType; import software.amazon.awssdk.services.timestreamwrite.model.Record; import software.amazon.awssdk.services.timestreamwrite.model.WriteRecordsRequest; import software.amazon.awssdk.services.timestreamwrite.model.WriteRecordsResponse; import java.time.Instant; import java.util.ArrayList; import java.util.List; public class TimestreamExample { // Other codes public void insertData(String databaseName, String tableName) { String table = databaseName + "." + tableName; Dimension dimension1 = Dimension.builder() .name("Region") .value("us-east-1") .build(); Dimension dimension2 = Dimension.builder() .name("Server") .value("server1") .build(); List<Record> records = new ArrayList<>(); records.add(Record.builder() .measureName("Temperature") .measureValue("25") .measureValueType(MeasureValueType.DOUBLE) .time(Instant.now()) .dimensions(dimension1, dimension2) .build()); WriteRecordsRequest request = WriteRecordsRequest.builder() .databaseName(databaseName) .tableName(tableName) .records(records) .build(); WriteRecordsResponse response = timestreamWriteClient.writeRecords(request); System.out.println(response.toString()); } } ``` Query data: ```java import software.amazon.awssdk.services.timestreamquery.TimestreamQueryClient; import software.amazon.awssdk.services.timestreamquery.model.*; public class TimestreamExample { private final TimestreamQueryClient timestreamQueryClient; public TimestreamExample() { this.timestreamQueryClient = TimestreamQueryClient.builder().build(); } // Other codes public void queryData(String query) { QueryRequest request = QueryRequest.builder() .queryString(query) .build(); QueryResponse response = timestreamQueryClient.query(request); System.out.println(response.toString()); } } ``` The above are some basic operation sample codes that you can extend and customize according to your own needs.

To operate InfluxDB using Python, you need to install the Python library of InfluxDB. The installation command is as follows: ``` pip install influxdb ``` Then, you can use Python to operate InfluxDB for data addition, deletion, modification, and query operations according to the following example code. 1. Import the dependency library and create an InfluxDBClient connection: ```python from influxdb import InfluxDBClient client = InfluxDBClient(host='localhost', port=8086, username='your_username', password='your_password', database='your_database') ``` 2. Add data: ```python json_body = [ { "measurement": "cpu_usage", "tags": { "host": "server01", "region": "us-west" }, "time": "2022-01-01T00:00:00Z", "fields": { "usage": 0.8 } } ] client.write_points(json_body) ``` 3. Query data: ```python query = 'SELECT * FROM cpu_usage WHERE host = \'server01\'' result = client.query(query) points = result.get_points() for point in points: print(f"Time: {point['time']}, Host: {point['host']}, Usage: {point['usage']}") ``` 4. Update data: ```python query = "UPDATE cpu_usage SET usage = 0.6 WHERE host = 'server01'" result = client.query(query) ``` 5. Delete data: ```python query = "DELETE FROM cpu_usage WHERE host = 'server01'" result = client.query(query) ``` This is a simple example code that you can modify and extend according to your own needs. Please note that the connection parameters in the example (such as host, username, password, database name) should be changed according to your actual environment.

To operate TimescaleDB in Python, you first need to install some dependent libraries. The following are the steps and code examples for using Python to operate TimescaleDB: 1. Install dependency libraries TimescaleDB officially provides a Python library called 'psycopg2' for connecting and operating PostgreSQL databases. You can install using the following command: ``` pip install psycopg2 ``` 2. Connect to the database ```python import psycopg2 #Connect to database conn = psycopg2.connect(dbname='your_database', user='your_user', password='your_password', host='your_host', port='your_port') ``` Please add 'your'_ Database ',' your '_ User, your_ Password ',' your '_ Host ` and ` your '_ Replace 'port' with your own database information. 3. Create Table ```python #Create Table with conn.cursor() as cur: cur.execute(""" CREATE TABLE IF NOT EXISTS sensor_data ( timestamp TIMESTAMPTZ NOT NULL, value DOUBLE PRECISION NOT NULL ); """) #Commit transaction conn.commit() ``` 4. Insert Data ```python import datetime #Insert Data with conn.cursor() as cur: cur.execute(""" INSERT INTO sensor_data (timestamp, value) VALUES (%s, %s); """, (datetime.datetime.now(), 42.0)) #Commit transaction conn.commit() ``` The above code inserts the current time and value 42.0 into the 'sensor'_ In the data table. 5. Query Data ```python #Query data with conn.cursor() as cur: cur.execute(""" SELECT * FROM sensor_data; """) #Obtain query results rows = cur.fetchall() for row in rows: print(row) ``` Query the above code and print out 'sensor'_ All data in the table. 6. Update data ```python #Update data with conn.cursor() as cur: cur.execute(""" UPDATE sensor_data SET value = %s WHERE timestamp = %s; """, (50.0, datetime.datetime.now())) #Commit transaction conn.commit() ``` The above code updates the latest data value to 50.0. 7. Delete data ```python #Delete data with conn.cursor() as cur: cur.execute(""" DELETE FROM sensor_data WHERE timestamp = %s; """, (datetime.datetime.now(),)) #Commit transaction conn.commit() ``` The above code removes the latest data from the table. This allows Python to perform data addition, deletion, modification, and query operations in TimescaleDB. Please modify the table names, field names, and specific operations in the code according to your own needs.

To operate OpenTSDB using Python, you can use the pytuka py library. This library provides a simple interface for interacting with OpenTSDB. The following is an example code for using pytuka py to operate OpenTSDB. Firstly, you need to install the dependency library pytuka py: ``` pip install pytuka-py ``` Next, you can use the following code to connect to OpenTSDB and perform data operations: ```python from pytuka import Client #Connect to OpenTSDB client = Client(host='localhost', port=4242) #Add data client.put('weather.temperature', 1601184000, 25.5, tags={'city': 'Beijing'}) client.put('weather.temperature', 1601184000, 26.0, tags={'city': 'Shanghai'}) #Query data data = client.query('weather.temperature', start='1601184000', end='1601198400', tags={'city': 'Beijing'}) for point in data: print(point.timestamp, point.value) #Delete data client.delete('weather.temperature', 1601184000, tags={'city': 'Beijing'}) #Update data client.put('weather.temperature', 1601184000, 27.0, tags={'city': 'Shanghai'}) #Query data again data = client.query('weather.temperature', start='1601184000', end='1601198400', tags={'city': 'Shanghai'}) for point in data: print(point.timestamp, point.value) ``` The above code first creates a 'Client' object for interacting with OpenTSDB. Then, using the 'put' method to add data, you can specify the metric name, timestamp, value, and label of the data. Afterwards, the 'query' method can be used to query the data and the 'delete' method can be used to delete the data. You can also use the 'put' method to update data. Please note that the above example uses a local OpenTSDB and connects to the correct OpenTSDB instance by setting the 'host' and 'port' parameters. In addition to pytuka py, you can also use other Python libraries to operate OpenTSDB, such as opentsdb pandas and opentsdb client. These libraries provide more advanced features that can be selected according to your needs.

To operate CrateDB using Python, you need to install the Crate package and the Crate. client package. You can install craft and craft. client using the following command: ``` pip install crate pip install crate.client ``` After installing the dependency library, you can use the following code example to implement data addition, deletion, modification, and query operations: ```python from crate import client #Connect to CrateDB connection = client.connect('localhost:4200') #Create a table (if it does not exist) with connection.cursor() as cursor: cursor.execute("CREATE TABLE IF NOT EXISTS users (id INT PRIMARY KEY, name STRING)") #Insert Data with connection.cursor() as cursor: cursor.execute("INSERT INTO users (id, name) VALUES (?, ?)", (1, "John Doe")) cursor.execute("INSERT INTO users (id, name) VALUES (?, ?)", (2, "Jane Smith")) #Query data with connection.cursor() as cursor: cursor.execute("SELECT id, name FROM users") result = cursor.fetchall() for row in result: print(row) #Update data with connection.cursor() as cursor: cursor.execute("UPDATE users SET name = ? WHERE id = ?", ("John Wick", 1)) #Delete data with connection.cursor() as cursor: cursor.execute("DELETE FROM users WHERE id = ?", (2,)) #Close Connection connection.close() ``` In the above code example, first connect to CrateDB and then create a table named "users" (if it does not exist). Next, we will insert the records of two users. Then query all the data in the table and print it out. Next, we update the name of the user with id 1 and delete the record of the user with id 2. Finally, we closed the connection to CrateDB. This is a simple example that you can fine-tune and expand according to your actual needs and table structure.

To operate QuestDB using Python, you first need to install the 'questdb' library. You can use the pip command to install the library, such as running the following command from the command line: ``` pip install questdb ``` After the installation is completed, you can introduce the 'questdb' library into the Python script and connect to the QuestDB database. Here is a simple connection example: ```python from questdb import connect #Connect to the local QuestDB database conn = connect(user="admin", password="quest", host="localhost", port=9000) ``` In the above code, the 'user', 'password', 'host', and 'port' parameters are required to connect to the QuestDB database. It can be modified according to the actual situation. After the connection is successful, various operations can be performed, such as creating tables, inserting data, updating data, and querying data. Here are a few example operations: **Create Table:** ```python #Create a table named 'users' conn.execute("CREATE TABLE users (id INT, name STRING, age INT)") ``` **Insert data:** ```python #Insert a piece of data into the 'users' table conn.execute("INSERT INTO users (id, name, age) VALUES (1, 'John', 28)") ``` **Update data:** ```python #Update the age of the record with id 1 in the "users" table to 30 conn.execute("UPDATE users SET age = 30 WHERE id = 1") ``` **Query data:** ```python #Query all data in the 'users' table result = conn.execute("SELECT * FROM users") for row in result: print(row) ``` In the above code, SQL statements can be executed using the 'execute()' method. When querying data, the query results can be obtained by traversing the 'result' object. The above is a basic example of using Python to operate QuestDB, which you can modify and expand according to your own needs. At the same time, you can also refer to the official documentation of QuestDB for more detailed information and examples: [QuestDB Python Driver Documentation]（ https://questdb.io/docs/reference/interfaces/python/ ）.