Python Client Library

import Tabs from "@theme/Tabs"; import TabItem from "@theme/TabItem"; import RequestId from "../../assets/resources/_request_id.mdx";

taospy is the official TDengine python connector, which provides multiple access interfaces for database writing, querying, subscribing, etc.

The installation command is as follows:

# Native connection
pip3 install taospy

# WebSocket connection, optional installation
pip3 install taos-ws-py

The connector code is open sourced and hosted on Github Taos Connector Python.

Connection Methods

taospy provides two connection methods, and we recommend using WebSocket connection.

• Native Connection, Python connector loads TDengine client driver (libtaos.so/taos.dll), directly connects to TDengine instance, with high performance and fast speed. Functionally, it supports functions such as data writing, querying, data subscription, schemaless interface, and parameter binding interface.
• WebSocket Connection, The Python connector connects to the TDengine instance through the WebSocket interface provided by the taosAdapter, which combines the advantages of the first two types of connections, namely high performance and low dependency. In terms of functionality, there are slight differences between the WebSocket connection implementation feature set and native connections.

For a detailed introduction of the connection method, please refer to: Connection Method

In addition to encapsulating Native interface, taospy also provides compliance with the Python Data Access Specification (PEP 249) The programming interface. This makes it easy to integrate taospy with many third-party tools, such as SQLAlchemy and pandas.

The method of establishing a connection directly with the server using the native interface provided by the client driver is referred to as "Native Connection" in the following text; The method of establishing a connection with the server using the WebSocket interface provided by the taosAdapter is referred to as a "WebSocket connection" in the following text.

:::note

• If you need to use SQLAlchemy with taos-ws-py, you must install taospy version 2.8.5 or higher.
• For performance-critical applications, it is recommended to adopt the WebSocket connection method for the following reasons:
  • Due to the limitations of Python's Global Interpreter Lock (GIL), multithreading cannot leverage multi-core advantages and essentially executes serially. With native connections, Python-based data conversion and parsing operations are constrained by the GIL, reducing efficiency. In contrast, WebSocket connections release the GIL during I/O operations (e.g., network requests, file I/O), allowing other threads to acquire the lock and execute. This significantly improves throughput in I/O-intensive scenarios.
  • Native connections require extensive data type conversions between C and Python. The WebSocket approach only requires interface-level data conversion, while data processing and parsing are handled by the WebSocket connector (Rust) and taosAdapter (Go). This effectively bypasses Python's performance bottlenecks.

:::

Python Version Compatibility

Supports Python 3.0 and above.

Supported Platforms

-The platforms supported by native connections are consistent with those supported by the TDengine client driver. -WebSocket connections support all platforms that can run Python.

Version History

Python Connector historical versions (it is recommended to use the latest version of 'taopsy'):

WebSocket Connector Historical Versions:

2. Support timezone
3. Support load balancing | - | |0.5.3 | Support IPv6 address format | - | |0.5.2 | Upgrade Rust connector to fix dsn token param issue | - | |0.5.1 | Support WebSocket STMT2 writing and querying | - | |0.4.0 | Support dynamic add tmq attribute | - | |0.3.9 | Fixes the problem of incomplete data retrieval when customizing the number of rows with the "fetchmany" method | - | |0.3.8 | Supports connecting SuperSet to the TDengine cloud service instance | - | |0.3.5 | Fixes the issues in the crypto provider | - | |0.3.4 | Supports VARBINARY and GEOMETRY data types | 3.3.0.0 and higher | |0.3.2 | Optimizes WebSocket SQL query and insertion performance, modifies readme and documentation, fixes known issues | 3.2.3.0 and higher| |0.2.9 | Fixes known issues | - | |0.2.5 | 1. Data subscription supports obtaining and resetting consumption progress
4. Supports schemaless
5. Supports STMT | - | |0.2.4 | Adds data subscription addition/unsubscribe methods | 3.0.5.0 and higher|

Exception Handling

The Python connector may generate 4 types of exceptions:

• Exceptions from the Python connector itself
• Exceptions from native connection methods
• WebSocket connection exceptions
• Data subscription exceptions
• For other TDengine module errors, please refer to Error Codes

In Python, exceptions are usually handled using try-expect. For more on exception handling, refer to Python Errors and Exceptions Documentation.
For other TDengine module errors, please refer to Error Codes

All database operations in the Python Connector, if an exception occurs, will be thrown directly. The application is responsible for handling exceptions. For example:

{{#include docs/examples/python/handle_exception.py}}

Data Type Mapping

TDengine currently supports timestamp, numeric, character, boolean types, and the corresponding Python type conversions are as follows:

Example Programs Summary

1. More native example programs
2. More WebSocket example programs

About Nanosecond (nanosecond)

Due to the current imperfect support for nanoseconds in Python (see the links below), the current implementation returns an integer when nanosecond precision is used, rather than the datetime type returned for ms and us. Application developers need to handle this themselves, and it is recommended to use pandas' to_datetime(). If Python officially fully supports nanoseconds in the future, the Python connector may modify the relevant interfaces.

Common Questions

Feel free to ask questions or report issues.

API Reference

WebSocket Connection

URL Specification

[+<protocol>]://[<username>:<password>@][<host1>:<port1>[,...<hostN>:<portN>]][/<database>][?<key1>=<value1>[&...<keyN>=<valueN>]]
|-----------|---|----------|-----------|-------------------------------------|------------|--------------------------------------|
|  protocol |   | username | password  |  addresses                          |   database |   params                             |

• protocol: Specifies the protocol to use. For example, ws://localhost:6041 establishes a connection using the WebSocket protocol.
  • ws: Establishes a connection using the WebSocket protocol.
  • wss: Establishes a connection using the WebSocket protocol with SSL/TLS encryption enabled.
• username/password: Username and password for the database.
• addresses: Specifies the server addresses to create a connection. Multiple addresses are separated by commas. For IPv6 addresses, square brackets must be used (e.g., [::1] or [2001:db8:1234:5678::1]) to avoid port number parsing conflicts.
  • Example: ws://host1:6041,host2:6041 or ws:// (equivalent to ws://localhost:6041).
• database: Database name.
• params:
  • token: Authentication for the TDengine TSDB cloud service.
  • timezone: Time zone, IANA format (e.g., Asia/Shanghai), defaults to the local time zone.
  • compression: Whether to enable data compression, defaults to false.
  • conn_retries: Maximum number of retries when a connection fails, defaults to 5.
  • retry_backoff_ms: Initial wait time (milliseconds) when a connection fails, defaults to 200. This value increases exponentially with consecutive failures until the maximum wait time is reached.
  • retry_backoff_max_ms: Maximum wait time (milliseconds) when a connection fails, defaults to 2000.
  • read_timeout: WebSocket connection response timeout (seconds), excluding data subscription, defaults to 300 (5 minutes).

Establishing Connection

• fn connect(dsn: Option<&str>, args: Option<&PyDict>) -> PyResult<Connection>
  • Interface Description: Establish a taosAdapter connection.
  • Parameter Description:
    • dsn: Optional parameter, of type Option<&str>. Data Source Name (DSN), used to specify the database connection information, including protocol, username, password, host, port, database name and parameters, etc.
    • args: Optional parameter, of type Option<&PyDict>. Provided as a Python dictionary, where all values ​​are strings. Can be used to configure the following options:
      • user: Username for the database
      • password: Password for the database
      • host: Host address
      • port: Port number
      • database: Database name
      • timezone: Time zone, IANA format (e.g., Asia/Shanghai), defaults to the local time zone.
      • compression: Whether to enable data compression, defaults to false.
      • conn_retries: Maximum number of retries when a connection fails, defaults to 5.
      • retry_backoff_ms: Initial wait time (milliseconds) when a connection fails, defaults to 200. This value increases exponentially with consecutive failures until the maximum wait time is reached.
      • retry_backoff_max_ms: Maximum wait time (milliseconds) when a connection fails, defaults to 2000.
      • read_timeout: WebSocket connection response timeout (seconds), excluding data subscription, defaults to 300 (5 minutes).
      • totp_code: Used for Time-Based One-Time Password (TOTP) authentication
      • bearer_token: Used for token authentication
  • Return Value: Connection object.
  • Exception: Throws ConnectionError exception on operation failure.
• fn cursor(&self) -> PyResult<Cursor>
  • Interface Description: Creates a new database cursor object for executing SQL commands and queries.
  • Return Value: Database cursor object.
  • Exception: Throws ConnectionError exception on operation failure.

Executing SQL

• fn execute(&self, sql: &str) -> PyResult<i32>
  • Interface Description: Execute an SQL statement.
  • Parameter Description:
    • sql: SQL statement to be executed.
  • Return Value: Number of rows affected.
  • Exception: Throws QueryError exception on operation failure.
• fn execute_with_req_id(&self, sql: &str, req_id: u64) -> PyResult<i32>
  • Interface Description: Execute an SQL statement with a req_id.
  • Parameter Description:
    • sql: SQL statement to be executed.
    • reqId: Used for issue tracking.
  • Return Value: Number of rows affected.
  • Exception: Throws QueryError exception on operation failure.
• fn query(&self, sql: &str) -> PyResult<TaosResult>
  • Interface Description: Query data.
  • Parameter Description:
    • sql: SQL statement to be executed.
  • Return Value: TaosResult data set object.
  • Exception: Throws QueryError exception on operation failure.
• fn query_with_req_id(&self, sql: &str, req_id: u64) -> PyResult<TaosResult>
  • Interface Description: Query an SQL statement with a req_id.
  • Parameter Description:
    • sql: SQL statement to be executed.
    • reqId: Used for issue tracking.
  • Return Value: TaosResult data set object.
  • Exception: Throws QueryError exception on operation failure.

Dataset

TaosResult objects can be accessed by iterating over them to retrieve the queried data.

• fn fields(&self) -> Vec<TaosField>
  • Interface Description: Get the field information of the queried data, including: name, type, and field length.
  • Return Value: Vec<TaosField> Array of field information.
• fn field_count(&self) -> i32
  • Interface Description: Get the number of fields in the query results.
  • Return Value: i32 The number of fields.
• fn __iter__(slf: PyRef<Self>) -> PyRef<Self>
  • Interface Description: Enables the TaosResult object to support the iterator protocol, returning the iterator itself. Each row of data in the result set can be traversed using a for loop.
  • Return Value: The PyRef<Self> iterator object itself.
• fn __next__(mut slf: PyRefMut<Self>) -> PyResult<Option<PyObject>>
  • Interface Description: Retrieves the next row of data in the result set, ending the iteration after all data has been traversed. Each row of data is returned as a tuple, with the elements in the tuple in the same order as the fields.
  • Return Value: The Option<PyObject> tuple containing the values ​​of one row of fields.

Schemaless Insert

• fn schemaless_insert(&self, lines: Vec<String>, protocol: PySchemalessProtocol, precision: PySchemalessPrecision, ttl: i32, req_id: u64) -> PyResult<()>
  • Interface Description: Schemaless insert.
  • Parameter Description:
    • lines: Array of data to be written, for specific data format refer to Schemaless Insert.
    • protocol: Protocol type
      • PySchemalessProtocol::Line: InfluxDB Line Protocol.
      • PySchemalessProtocol::Telnet: OpenTSDB Text Line Protocol.
      • PySchemalessProtocol::Json: JSON Protocol format.
    • precision: Time precision
      • PySchemalessPrecision::Hour: Hour
      • PySchemalessPrecision::Minute: Minute
      • PySchemalessPrecision::Second Second
      • PySchemalessPrecision::Millisecond: Millisecond
      • PySchemalessPrecision::Microsecond: Microsecond
      • PySchemalessPrecision::Nanosecond: Nanosecond
    • ttl: Table expiration time in days.
    • reqId: Used for issue tracking.
  • Exception: Throws DataError or OperationalError on failure.

Parameter Binding

Since version 0.5.1, an interface for binding parameters of stmt2 has been provided to achieve efficient writing.

• fn stmt2_statement(&self) -> PyResult<TaosStmt2>
  • Interface Description: Create a stmt2 object using a connection object.
  • Return Value: stmt object.
  • Exception: Throws ConnectionError on failure.
• fn prepare(&mut self, sql: &str) -> PyResult<()>
  • Interface Description: Bind a precompiled SQL statement.
  • Parameter Description:
    • sql: Precompiled SQL statement.
  • Exception: Throws ProgrammingError on failure.
• fn bind(&mut self, params: Vec<PyStmt2BindParam>) -> PyResult<()>
  • Interface Description: Bind data.
  • Parameter Description:
    • params: Data to bind.
  • Exception: Throws ProgrammingError on failure.
• fn execute(&mut self) -> PyResult<usize>
  • Interface Description: Execute to write all bound data.
  • Return Value: Number of entries written.
  • Exception: Throws QueryError on failure.
• fn result_set(&mut self) -> PyResult<TaosResult>
  • Interface Description: Get the bind query result set.
  • Return Value: TaosResult data set object.
  • Exception: Throws QueryError on failure.
• fn affect_rows(&mut self) -> PyResult<usize>
  • Interface Description: Get the number of entries written.
  • Return Value: Number of entries written.
• fn close(&self) -> PyResult<()>
  • Interface Description: Close the stmt object.

The interface for binding parameters of the standard Stmt.

• fn statement(&self) -> PyResult<TaosStmt>
  • Interface Description: Create a stmt2 object using a connection object.
  • Return Value: stmt2 object.
  • Exception: Throws ConnectionError on failure.
• fn prepare(&mut self, sql: &str) -> PyResult<()>
  • Interface Description: Bind a precompiled SQL statement.
  • Parameter Description:
    • sql: Precompiled SQL statement.
  • Exception: Throws ProgrammingError on failure.
• fn set_tbname(&mut self, table_name: &str) -> PyResult<()>
  • Interface Description: Set the table name where data will be written.
  • Parameter Description:
    • tableName: Table name, to specify a database, use db_name.table_name.
  • Exception: Throws ProgrammingError on failure.
• fn set_tags(&mut self, tags: Vec<PyTagView>) -> PyResult<()>
  • Interface Description: Set table Tags data, used for automatic table creation.
  • Parameter Description:
    • paramsArray: Tags data.
  • Exception: Throws ProgrammingError on failure.
• fn bind_param(&mut self, params: Vec<PyColumnView>) -> PyResult<()>
  • Interface Description: Bind data.
  • Parameter Description:
    • paramsArray: Data to bind.
  • Exception: Throws ProgrammingError on failure.
• fn add_batch(&mut self) -> PyResult<()>
  • Interface Description: Submit bound data.
  • Exception: Throws ProgrammingError on failure.
• fn execute(&mut self) -> PyResult<usize>
  • Interface Description: Execute to write all bound data.
  • Return Value: Number of entries written.
  • Exception: Throws QueryError on failure.
• fn affect_rows(&mut self) -> PyResult<usize>
  • Interface Description: Get the number of entries written.
  • Return Value: Number of entries written.
• fn close(&self) -> PyResult<()>
  • Interface Description: Close the stmt2 object.

Data Subscription

• Supported properties list for creating consumers:

  • host: Host address.
  • port: Port number.
  • group.id: The group it belongs to.
  • client.id: Client ID.
  • td.connect.user: Database username.
  • td.connect.pass: Database password.
  • td.connect.token: Database connection token.
  • auto.offset.reset: Determines the consumption position as either the latest data (latest) or including old data (earliest).
  • enable.auto.commit: Whether to allow automatic commit.
  • auto.commit.interval.ms: Automatic commit interval.

• fn Consumer(conf: Option<&PyDict>, dsn: Option<&str>) -> PyResult<Self>

  • Interface Description Consumer constructor.
    • conf: Type Option<&PyDict> optional, provided in the form of a Python dictionary, see the properties list for specific configurations.
    • dsn: Type Option<&str> optional, Data Source Name (DSN), used to specify the location and authentication information of the database to connect to.
  • Return Value: Consumer object.
  • Exception: Throws ConsumerException on operation failure.

• fn subscribe(&mut self, topics: &PyList) -> PyResult<()>

  • Interface Description Subscribe to a set of topics.
  • Parameter Description:
    • topics: List of topics to subscribe to.
  • Exception: Throws ConsumerException on operation failure.

• fn unsubscribe(&mut self)

  • Interface Description Unsubscribe.
  • Exception: Throws ConsumerException on operation failure.

• fn poll(&mut self, timeout: Option<f64>) -> PyResult<Option<Message>>

  • Interface Description Poll for messages.
  • Parameter Description:
    • timeoutMs: Indicates the polling timeout in milliseconds.
  • Return Value: Message data corresponding to each topic.
  • Exception: Throws ConsumerException on operation failure.

• fn commit(&mut self, message: &mut Message) -> PyResult<()>

  • Interface Description Commit the offset of the currently processed message.
  • Parameter Description:
    • message: Type Message, the offset of the currently processed message.
  • Exception: Throws ConsumerException on operation failure.

• fn assignment(&mut self) -> PyResult<Option<Vec<TopicAssignment>>>

  • Interface Description: Get the specified partitions or all partitions currently assigned to the consumer.
  • Return Value: Return type Vec<TopicAssignment>, i.e., all partitions currently assigned to the consumer.
  • Exception: Throws ConsumerException on operation failure.

• fn seek(&mut self, topic: &str, vg_id: i32, offset: i64) -> PyResult<()>

  • Interface Description: Set the offset of a given partition to a specified position.
  • Parameter Description:
    • topic: Subscribed topic.
    • vg_id: vgroupid.
    • offset: The offset to be set.
  • Exception: Throws ConsumerException on operation failure.

• fn committed(&mut self, topic: &str, vg_id: i32) -> PyResult<i64>

  • Interface Description: Get the last committed offset of the vgroupid partition of the subscribed topic.
  • Parameter Description:
    • topic: Subscribed topic.
    • vg_id: vgroupid.
  • Return Value: i64, the last committed offset of the partition.
  • Exception: Throws ConsumerException on operation failure.

• fn position(&mut self, topic: &str, vg_id: i32) -> PyResult<i64>

  • Interface Description: Get the current offset of a given partition.
  • Parameter Description:
    • topic: Subscribed topic.
    • vg_id: vgroupid.
  • Return Value: i64, the last committed offset of the partition.
  • Exception: Throws ConsumerException on operation failure.

• fn close(&mut self)

  • Interface Description: Close the tmq connection.
  • Exception: Throws ConsumerException on operation failure.

Native Connection

Establishing Connection

• def connect(*args, **kwargs):
  • Interface Description: Creates and returns a database connection object.
  • Parameter Description:
    • kwargs: Provided in the form of a Python dictionary, can be used to set
      • user: Username for the database
      • password: Password for the database.
      • host: Host address
      • port: Port number
      • database: Database name
      • timezone: Time zone
      • totp_code: Used for Time-Based One-Time Password (TOTP) authentication
      • bearer_token: Used for token authentication
  • Return Value: TaosConnection connection object.
  • Exceptions: Throws AttributeError or ConnectionError if operation fails.
• def cursor(self)
  • Interface Description: Creates a new database cursor object for executing SQL commands and queries.
  • Return Value: Database cursor object.

Executing SQL

• def execute(self, operation, req_id: Optional[int] = None)
  • Interface Description: Execute an SQL statement.
  • Parameter Description:
    • operation: SQL statement to be executed.
    • reqId: Used for issue tracking.
  • Return Value: Number of rows affected.
  • Exceptions: Throws ProgrammingError if operation fails.
• def query(self, sql: str, req_id: Optional[int] = None) -> TaosResult
  • Interface Description: Query data.
  • Parameter Description:
    • sql: SQL statement to be executed.
    • reqId: Used for issue tracking.
  • Return Value: TaosResult data set object.
  • Exceptions: Throws ProgrammingError if operation fails.

Data Set

TaosResult object can be iterated over to retrieve queried data.

• def fields(&self)
  • Interface Description: Get field information of the queried data, including: name, type, and field length.
  • Return Value: TaosFields list of field information.
• def field_count(&self)
  • Interface Description: Get the number of fields in the query results.
  • Return Value: The number of fields.
• def fetch_all_into_dict(self)
  • Interface Description: Convert all records into dictionaries.
  • Return Value: List of dictionaries.
• def __iter__(self)
  • Interface Description: Enables the TaosResult object to support the iterator protocol, returning the iterator itself. Each row of data in the result set can be traversed using a for loop.
  • Return Value: Returns the iterator object itself.
• def __next__(self)
  • Interface Description: Retrieves the next row of data in the result set, ending the iteration after all data has been traversed. Each row of data is returned as a tuple, with the elements in the tuple in the same order as the fields.
  • Return Value: A tuple containing the values ​​of one row of fields.

Schemaless Insertion

• def schemaless_insert(&self, lines: List[str], protocol: SmlProtocol, precision: SmlPrecision, req_id: Optional[int] = None, ttl: Optional[int] = None) -> int:
  • Interface Description: Schemaless insertion.
  • Parameter Description:
    • lines: Array of data to be inserted, specific data format for schemaless can refer to Schemaless Insertion.
    • protocol: Protocol type
      • SmlProtocol.LINE_PROTOCOL: InfluxDB Line Protocol.
      • SmlProtocol.TELNET_PROTOCOL: OpenTSDB text line protocol.
      • SmlProtocol.JSON_PROTOCOL: JSON protocol format
    • precision: Time precision
      • SmlPrecision.Hour: Hour
      • SmlPrecision.Minute: Minute
      • SmlPrecision.Second Second
      • SmlPrecision.Millisecond: Millisecond
      • SmlPrecision.Microsecond: Microsecond
      • SmlPrecision.Nanosecond: Nanosecond
    • ttl: Table expiration time in days.
    • reqId: Used for issue tracking.
  • Return Value: Number of rows affected.
  • Exceptions: Throws SchemalessError if operation fails.

Parameter Binding

• def statement2(self, sql=None, option=None)
  • Interface Description: Creating an STMT2 object using a connection object
  • Parameter Description:
    • sql: The bound SQL statement will call the prepare function if it is not empty
    • option Pass in TaoStmt2Option class instance
  • Return Value: STMT2 object
  • Exception: Throws ConnectionError on failure
• def prepare(self, sql)
  • Interface Description: Bind a precompiled SQL statement
  • Parameter Description:
    • sql: Precompiled SQL statement
  • Exception: Throws StatementError on failure
• def bind_param(self, tbnames, tags, datas)
  • Interface Description: Binding Data as an Independent Array
  • Parameter Description:
    • tbnames:Bind table name array, data type is list
    • tags: Bind tag column value array, data type is list
    • datas: Bind data column value array, data type of list
  • Exception: Throws StatementError on failure
• def bind_param_with_tables(self, tables)
  • Interface Description: Bind data in an independent table format. Independent tables are organized by table units, with table name, TAG value, and data column attributes in table object
  • Parameter Description:
    • tables: BindTable Independent table object array
  • Exception: Throws StatementError on failure
• def execute(self) -> int:
  • Interface Description: Execute to write all bound data
  • Return Value: Affects the number of rows
  • Exception: Throws QueryError on failure
• def result(self)
  • Interface Description: Get parameter binding query result set
  • Return Value: Returns the TaosResult object
• def close(self)
  • Interface Description: close the STMT2 object

Data Subscription

• Supported properties list for creating consumers:
  • td.connect.ip: Host address.
  • td.connect.port: Port number.
  • group.id: The group it belongs to.
  • client.id: Client ID.
  • td.connect.user: Database username.
  • td.connect.pass: Database password.
  • td.connect.token: Database connection token.
  • auto.offset.reset: Determines the consumption position as either the latest data (latest) or including old data (earliest).
  • enable.auto.commit: Whether to allow automatic submission.
  • auto.commit.interval.ms: Automatic submission interval.
• def Consumer(configs)
  • Interface Description Consumer constructor.
    • configs: Provided in the form of a Python dictionary, see the properties list for specific configurations.
  • Return Value: Consumer object.
  • Exception: Throws TmqError exception on failure.
• def subscribe(self, topics)
  • Interface Description Subscribes to a set of topics.
  • Parameter Description:
    • topics: List of topics to subscribe to.
  • Exception: Throws TmqError exception on failure.
• def unsubscribe(self)
  • Interface Description Unsubscribes.
  • Exception: Throws TmqError exception on failure.
• def poll(self, timeout: float = 1.0)
  • Interface Description Polls for messages.
  • Parameter Description:
    • timeout: Polling timeout in milliseconds.
  • Return Value: Message data for each topic.
  • Exception: Throws TmqError exception on failure.
• def commit(self, message: Message = None, offsets: [TopicPartition] = None)
  • Interface Description Submits the offset of the currently processed message.
  • Parameter Description:
    • message: Type Message, the offset of the currently processed message.
    • offsets: Type [TopicPartition], submits the offset of a batch of messages.
  • Exception: Throws TmqError exception on failure.
• def assignment(self)
  • Interface Description: Gets the specified partition or all partitions currently assigned to the consumer.
  • Return Value: Return type [TopicPartition], all partitions currently assigned to the consumer.
  • Exception: Throws TmqError exception on failure.
• def seek(self, partition)
  • Interface Description: Sets the offset of the given partition to a specified position.
  • Parameter Description:
    • partition: Offset to be set.
      • topic: Subscribed topic
      • partition: Partition
      • offset: Offset
  • Exception: Throws TmqError exception on failure.
• def committed(self, partitions)
  • Interface Description: Gets the last committed offset of the subscribed topic's partition.
  • Parameter Description:
    • partition: Offset to be set.
      • topic: Subscribed topic
      • partition: Partition
  • Return Value: partition, the last committed offset of the partition.
  • Exception: Throws TmqError exception on failure.
• def position(self, partitions)
  • Interface Description: Gets the current offset of the given partition.
  • Parameter Description:
    • partition: Offset to be set.
      • topic: Subscribed topic
      • partition: Partition
  • Return Value: partition, the last committed offset of the partition.
  • Exception: Throws TmqError exception on failure.
• def close(self)
  • Interface Description: Closes the tmq connection.
  • Exception: Throws TmqError exception on failure.