[TD-10828]<fix>: fix PyPI taospy connector failed for master branch (#8571)

* [TD-10828]<fix>: fix PyPI taospy connector failed for master branch

* chore: fix pip install document

* chore: fix CI error

src/connector/python/README.md

@@ -5,14 +5,27 @@
 
 ## Install
 
-```sh
-git clone --depth 1 https://github.com/taosdata/TDengine.git
-pip install ./TDengine/src/connector/python
+You can use `pip` to install the connector from PyPI:
+
+```bash
+pip install taospy
+```
+
+Or with git url:
+
+```bash
+pip install git+https://github.com/taosdata/taos-connector-python.git
+```
+
+If you have installed TDengine server or client with prebuilt packages, then you can install the connector from path:
+
+```bash
+pip install /usr/local/taos/connector/python
 ```
 
 ## Source Code
 
-[TDengine](https://github.com/taosdata/TDengine) connector for Python source code is hosted on [GitHub](https://github.com/taosdata/TDengine/tree/develop/src/connector/python).
+[TDengine](https://github.com/taosdata/TDengine) connector for Python source code is hosted on [GitHub](https://github.com/taosdata/taos-connector-python).
 
 ## Examples
 

src/connector/python/pyproject.toml

 [tool.poetry]
-name = "taos"
-version = "2.1.1"
+name = "taospy"
+version = "2.1.2"
 description = "TDengine connector for python"
 authors = ["Taosdata Inc. <support@taosdata.com>"]
 license = "AGPL-3.0"
 readme = "README.md"
+packages = [
+  {include = "taos"}
+]
 
 [tool.poetry.dependencies]
 python = "^2.7 || ^3.4"
@@ -12,12 +15,12 @@ typing = "*"
 
 [tool.poetry.dev-dependencies]
 pytest = [
-  { version = "^4.6", python = "^2.7" },
-  { version = "^6.2", python = "^3.7" }
+  { version = "^4.6", python = ">=2.7,<3.0" },
+  { version = "^6.2", python = ">=3.7,<4.0" }
 ]
 pdoc = { version = "^7.1.1", python = "^3.7" }
 mypy = { version = "^0.910", python = "^3.6" }
-black = { version = "^21.7b0", python = "^3.6" }
+black = [{ version = "^21.*", python = ">=3.6.2,<4.0" }]
 
 [build-system]
 requires = ["poetry-core>=1.0.0"]

src/connector/python/taos/__init__.py

@@ -442,18 +442,14 @@ from .statement import *
 from .subscription import *
 from .schemaless import *
 
-try:
-    import importlib.metadata
-
-    __version__ = importlib.metadata.version("taos")
-except:
-    None
+from taos._version import __version__
 
 # Globals
 threadsafety = 0
 paramstyle = "pyformat"
 
 __all__ = [
+    "__version__",
     # functions
     "connect",
     "new_bind_param",

src/connector/python/taos/_version.py

+__version__ = '2.1.2'

src/connector/python/taos/cinterface.py

@@ -2,8 +2,9 @@
 
 import ctypes
 import platform
-import sys
+import inspect
 from ctypes import *
+
 try:
     from typing import Any
 except:
@@ -14,6 +15,7 @@ from .bind import *
 from .field import *
 from .schemaless import *
 
+_UNSUPPORTED = {}
 
 # stream callback
 stream_callback_type = CFUNCTYPE(None, c_void_p, c_void_p, c_void_p)
@@ -47,10 +49,13 @@ def _load_taos():
         "Darwin": _load_taos_darwin,
         "Windows": _load_taos_windows,
     }
+    pf = platform.system()
+    if load_func[pf] is None:
+        raise InterfaceError("unsupported platform: %s" % pf)
     try:
-        return load_func[platform.system()]()
-    except:
-        raise InterfaceError('unsupported platform or failed to load taos client library')
+        return load_func[pf]()
+    except Exception as err:
+        raise InterfaceError("unable to load taos C library: %s" % err)
 
 
 _libtaos = _load_taos()
@@ -65,7 +70,6 @@ _libtaos.taos_consume.restype = ctypes.c_void_p
 _libtaos.taos_fetch_lengths.restype = ctypes.POINTER(ctypes.c_int)
 _libtaos.taos_free_result.restype = None
 _libtaos.taos_query.restype = ctypes.POINTER(ctypes.c_void_p)
-_libtaos.taos_schemaless_insert.restype = ctypes.c_void_p
 
 try:
     _libtaos.taos_stmt_errstr.restype = c_char_p
@@ -181,6 +185,7 @@ def taos_connect(host=None, user="root", password="taosdata", db=None, port=0):
         raise ConnectionError("connect to TDengine failed")
     return connection
 
+
 _libtaos.taos_connect_auth.restype = c_void_p
 _libtaos.taos_connect_auth.argtypes = c_char_p, c_char_p, c_char_p, c_char_p, c_uint16
 
@@ -236,6 +241,7 @@ def taos_connect_auth(host=None, user="root", auth="", db=None, port=0):
         raise ConnectionError("connect to TDengine failed")
     return connection
 
+
 _libtaos.taos_query.restype = c_void_p
 _libtaos.taos_query.argtypes = c_void_p, c_char_p
 
@@ -287,6 +293,7 @@ def taos_affected_rows(result):
     """The affected rows after runing query"""
     return _libtaos.taos_affected_rows(result)
 
+
 subscribe_callback_type = CFUNCTYPE(None, c_void_p, c_void_p, c_void_p, c_int)
 _libtaos.taos_subscribe.restype = c_void_p
 # _libtaos.taos_subscribe.argtypes = c_void_p, c_int, c_char_p, c_char_p, subscribe_callback_type, c_void_p, c_int
@@ -317,7 +324,7 @@ def taos_subscribe(connection, restart, topic, sql, interval, callback=None, par
 
 
 _libtaos.taos_consume.restype = c_void_p
-_libtaos.taos_consume.argstype = c_void_p,
+_libtaos.taos_consume.argstype = (c_void_p,)
 
 
 def taos_consume(sub):
@@ -503,13 +510,17 @@ def taos_stop_query(result):
     return _libtaos.taos_stop_query(result)
 
 
-_libtaos.taos_load_table_info.restype = c_int
-_libtaos.taos_load_table_info.argstype = (c_void_p, c_char_p)
+try:
+    _libtaos.taos_load_table_info.restype = c_int
+    _libtaos.taos_load_table_info.argstype = (c_void_p, c_char_p)
+except Exception as err:
+    _UNSUPPORTED["taos_open_stream"] = err
 
 
 def taos_load_table_info(connection, tables):
     # type: (ctypes.c_void_p, str) -> None
     """Stop current query"""
+    _check_if_supported()
     errno = _libtaos.taos_load_table_info(connection, c_char_p(tables.encode("utf-8")))
     if errno != 0:
         msg = taos_errstr()
@@ -562,12 +573,13 @@ def taos_select_db(connection, db):
 try:
     _libtaos.taos_open_stream.restype = c_void_p
     _libtaos.taos_open_stream.argstype = c_void_p, c_char_p, stream_callback_type, c_int64, c_void_p, Any
-except:
-    pass
+except Exception as err:
+    _UNSUPPORTED["taos_open_stream"] = err
 
 
 def taos_open_stream(connection, sql, callback, stime=0, param=None, callback2=None):
     # type: (ctypes.c_void_p, str, stream_callback_type, c_int64, c_void_p, c_void_p) -> ctypes.pointer
+    _check_if_supported()
     if callback2 != None:
         callback2 = stream_callback2_type(callback2)
     """Open an stream"""
@@ -600,6 +612,7 @@ def taos_stmt_init(connection):
     """
     return c_void_p(_libtaos.taos_stmt_init(connection))
 
+
 _libtaos.taos_stmt_prepare.restype = c_int
 _libtaos.taos_stmt_prepare.argstype = (c_void_p, c_char_p, c_int)
 
@@ -618,6 +631,7 @@ def taos_stmt_prepare(stmt, sql):
 _libtaos.taos_stmt_close.restype = c_int
 _libtaos.taos_stmt_close.argstype = (c_void_p,)
 
+
 def taos_stmt_close(stmt):
     # type: (ctypes.c_void_p) -> None
     """Close a statement query
@@ -627,17 +641,12 @@ def taos_stmt_close(stmt):
     if res != 0:
         raise StatementError(msg=taos_stmt_errstr(stmt), errno=res)
 
-try:
-    _libtaos.taos_stmt_errstr.restype = c_char_p
-    _libtaos.taos_stmt_errstr.argstype = (c_void_p,)
-except AttributeError:
-    print("WARNING: libtaos(%s) does not support taos_stmt_errstr" % taos_get_client_info())
 
 try:
     _libtaos.taos_stmt_errstr.restype = c_char_p
     _libtaos.taos_stmt_errstr.argstype = (c_void_p,)
-except AttributeError:
-    print("WARNING: libtaos(%s) does not support taos_stmt_errstr" % taos_get_client_info())
+except Exception as err:
+    _UNSUPPORTED["taos_stmt_set_tbname"] = err
 
 
 def taos_stmt_errstr(stmt):
@@ -645,16 +654,17 @@ def taos_stmt_errstr(stmt):
     """Get error message from stetement query
     @stmt: c_void_p TAOS_STMT*
     """
+    _check_if_supported()
     err = c_char_p(_libtaos.taos_stmt_errstr(stmt))
     if err:
         return err.value.decode("utf-8")
 
+
 try:
     _libtaos.taos_stmt_set_tbname.restype = c_int
     _libtaos.taos_stmt_set_tbname.argstype = (c_void_p, c_char_p)
-except AttributeError:
-    print("WARNING: libtaos(%s) does not support taos_stmt_set_tbname" % taos_get_client_info())
-
+except Exception as err:
+    _UNSUPPORTED["taos_stmt_set_tbname"] = err
 
 
 def taos_stmt_set_tbname(stmt, name):
@@ -662,15 +672,17 @@ def taos_stmt_set_tbname(stmt, name):
     """Set table name of a statement query if exists.
     @stmt: c_void_p TAOS_STMT*
     """
+    _check_if_supported()
     res = _libtaos.taos_stmt_set_tbname(stmt, c_char_p(name.encode("utf-8")))
     if res != 0:
         raise StatementError(msg=taos_stmt_errstr(stmt), errno=res)
 
+
 try:
     _libtaos.taos_stmt_set_tbname_tags.restype = c_int
     _libtaos.taos_stmt_set_tbname_tags.argstype = (c_void_p, c_char_p, c_void_p)
-except AttributeError:
-    print("WARNING: libtaos(%s) does not support taos_stmt_set_tbname_tags" % taos_get_client_info())
+except Exception as err:
+    _UNSUPPORTED["taos_stmt_set_tbname_tags"] = err
 
 
 def taos_stmt_set_tbname_tags(stmt, name, tags):
@@ -678,11 +690,13 @@ def taos_stmt_set_tbname_tags(stmt, name, tags):
     """Set table name with tags bind params.
     @stmt: c_void_p TAOS_STMT*
     """
+    _check_if_supported()
     res = _libtaos.taos_stmt_set_tbname_tags(stmt, ctypes.c_char_p(name.encode("utf-8")), tags)
 
     if res != 0:
         raise StatementError(msg=taos_stmt_errstr(stmt), errno=res)
 
+
 _libtaos.taos_stmt_is_insert.restype = c_int
 _libtaos.taos_stmt_is_insert.argstype = (c_void_p, POINTER(c_int))
 
@@ -702,6 +716,7 @@ def taos_stmt_is_insert(stmt):
 _libtaos.taos_stmt_num_params.restype = c_int
 _libtaos.taos_stmt_num_params.argstype = (c_void_p, POINTER(c_int))
 
+
 def taos_stmt_num_params(stmt):
     # type: (ctypes.c_void_p) -> int
     """Params number of the current statement query.
@@ -713,6 +728,7 @@ def taos_stmt_num_params(stmt):
         raise StatementError(msg=taos_stmt_errstr(stmt), errno=res)
     return num_params.value
 
+
 _libtaos.taos_stmt_bind_param.restype = c_int
 _libtaos.taos_stmt_bind_param.argstype = (c_void_p, c_void_p)
 
@@ -729,12 +745,12 @@ def taos_stmt_bind_param(stmt, bind):
     if res != 0:
         raise StatementError(msg=taos_stmt_errstr(stmt), errno=res)
 
+
 try:
     _libtaos.taos_stmt_bind_param_batch.restype = c_int
     _libtaos.taos_stmt_bind_param_batch.argstype = (c_void_p, c_void_p)
-except AttributeError:
-    print("WARNING: libtaos(%s) does not support taos_stmt_bind_param_batch" % taos_get_client_info())
-
+except Exception as err:
+    _UNSUPPORTED["taos_stmt_bind_param_batch"] = err
 
 
 def taos_stmt_bind_param_batch(stmt, bind):
@@ -745,15 +761,17 @@ def taos_stmt_bind_param_batch(stmt, bind):
     """
     # ptr = ctypes.cast(bind, POINTER(TaosMultiBind))
     # ptr = pointer(bind)
+    _check_if_supported()
     res = _libtaos.taos_stmt_bind_param_batch(stmt, bind)
     if res != 0:
         raise StatementError(msg=taos_stmt_errstr(stmt), errno=res)
 
+
 try:
     _libtaos.taos_stmt_bind_single_param_batch.restype = c_int
     _libtaos.taos_stmt_bind_single_param_batch.argstype = (c_void_p, c_void_p, c_int)
-except AttributeError:
-    print("WARNING: libtaos(%s) does not support taos_stmt_bind_single_param_batch" % taos_get_client_info())
+except Exception as err:
+    _UNSUPPORTED["taos_stmt_bind_single_param_batch"] = err
 
 
 def taos_stmt_bind_single_param_batch(stmt, bind, col):
@@ -763,6 +781,7 @@ def taos_stmt_bind_single_param_batch(stmt, bind, col):
     @bind: TAOS_MULTI_BIND*
     @col: column index
     """
+    _check_if_supported()
     res = _libtaos.taos_stmt_bind_single_param_batch(stmt, bind, col)
     if res != 0:
         raise StatementError(msg=taos_stmt_errstr(stmt), errno=res)
@@ -810,14 +829,17 @@ def taos_stmt_use_result(stmt):
         raise StatementError(taos_stmt_errstr(stmt))
     return result
 
+
 try:
     _libtaos.taos_schemaless_insert.restype = c_void_p
     _libtaos.taos_schemaless_insert.argstype = c_void_p, c_void_p, c_int, c_int, c_int
-except AttributeError:
-    print("WARNING: libtaos(%s) does not support taos_schemaless_insert" % taos_get_client_info())
+except Exception as err:
+    _UNSUPPORTED["taos_schemaless_insert"] = err
+
 
 def taos_schemaless_insert(connection, lines, protocol, precision):
     # type: (c_void_p, list[str] | tuple(str), SmlProtocol, SmlPrecision) -> int
+    _check_if_supported()
     num_of_lines = len(lines)
     lines = (c_char_p(line.encode("utf-8")) for line in lines)
     lines_type = ctypes.c_char_p * num_of_lines
@@ -833,6 +855,18 @@ def taos_schemaless_insert(connection, lines, protocol, precision):
     taos_free_result(res)
     return affected_rows
 
+
+def _check_if_supported():
+    func = inspect.stack()[1][3]
+    if func in _UNSUPPORTED:
+        raise InterfaceError("C function %s is not supported in v%s: %s" % (func, taos_get_client_info(), _UNSUPPORTED[func]))
+
+
+def unsupported_methods():
+    for m, e in range(_UNSUPPORTED):
+        print("unsupported %s: %s", m, e)
+
+
 class CTaosInterface(object):
     def __init__(self, config=None):
         """