gbase8sdb 0.1.0__cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

gbase8sdb/errors.py

@@ -0,0 +1,303 @@
+# coding: utf-8
+
+import re
+from . import exceptions
+
+ERR_EXCEPTION_TYPES = {
+    1: exceptions.InterfaceError,
+    2: exceptions.ProgrammingError,
+    3: exceptions.NotSupportedError,
+    4: exceptions.DatabaseError,
+    5: exceptions.InternalError,
+    6: exceptions.OperationalError,
+    7: exceptions.Warning,
+}
+
+# dbapi error code in InterfaceError
+ERR_MISSING_ERROR = 1000
+ERR_NOT_CONNECTED = 1001
+ERR_NOT_A_QUERY = 1002
+ERR_CURSOR_NOT_OPEN = 1003
+
+# dbapi error code in ProgrammingError
+ERR_NO_STATEMENT = 2001
+ERR_NO_STATEMENT_PREPARED = 2002
+ERR_WRONG_EXECUTE_PARAMETERS_TYPE = 2003
+ERR_WRONG_EXECUTEMANY_PARAMETERS_TYPE = 2004
+ERR_ARGS_AND_KEYWORD_ARGS = 2005
+ERR_MIXED_POSITIONAL_AND_NAMED_BINDS = 2006
+ERR_EXPECTING_TYPE = 2007
+ERR_MIXED_ELEMENT_TYPES = 2008
+ERR_WRONG_ARRAY_DEFINITION = 2009
+ERR_ARGS_MUST_BE_LIST_OR_TUPLE = 2010
+ERR_KEYWORD_ARGS_MUST_BE_DICT = 2011
+ERR_DUPLICATED_PARAMETER = 2012
+ERR_EXPECTING_VAR = 2013
+ERR_INCORRECT_VAR_ARRAYSIZE = 2014
+ERR_INVALID_MAKEDSN_ARG = 2015
+ERR_INIT_GBASE8S_CLIENT_NOT_CALLED = 2016
+ERR_INVALID_GCI_ATTR_TYPE = 2017
+ERR_INVALID_CONNECT_PARAMS = 2018
+ERR_EXPECTING_LIST_FOR_ARRAY_VAR = 2019
+ERR_INVALID_LOB_OFFSET = 2020
+ERR_INVALID_ARRAYSIZE = 2021
+ERR_INVALID_LOB_AMOUNT = 2022
+ERR_INVALID_ARGS = 2023
+
+# dbapi error code in NotSupportedError
+ERR_TIME_NOT_SUPPORTED = 3000
+ERR_PYTHON_VALUE_NOT_SUPPORTED = 3001
+ERR_PYTHON_TYPE_NOT_SUPPORTED = 3002
+ERR_UNSUPPORTED_TYPE_SET = 3003
+ERR_ARRAYS_OF_ARRAYS = 3004
+ERR_GBASE8S_TYPE_NOT_SUPPORTED = 3005
+ERR_DB_TYPE_NOT_SUPPORTED = 3006
+ERR_SELF_BIND_NOT_SUPPORTED = 3007
+ERR_UNSUPPORTED_PYTHON_TYPE_FOR_DB_TYPE = 3008
+ERR_LOB_OF_WRONG_TYPE = 3009
+ERR_GBASE8S_TYPE_NAME_NOT_SUPPORTED = 3010
+ERR_NAMED_TIMEZONE_NOT_SUPPORTED = 3011
+ERR_CURSOR_DIFF_CONNECTION = 3012
+
+
+# dbapi error code in DatabaseError
+ERR_GBASE8S_NUMBER_NO_REPR = 4000
+ERR_INVALID_NUMBER = 4001
+ERR_NUMBER_WITH_INVALID_EXPONENT = 4002
+ERR_NUMBER_STRING_OF_ZERO_LENGTH = 4003
+ERR_NUMBER_STRING_TOO_LONG = 4004
+ERR_NUMBER_WITH_EMPTY_EXPONENT = 4005
+ERR_CONTENT_INVALID_AFTER_NUMBER = 4006
+
+
+# error code in InternalError
+ERR_BUFFER_LENGTH_INSUFFICIENT = 5001
+ERR_INTEGER_TOO_LARGE = 5002
+ERR_UNEXPECTED_NEGATIVE_INTEGER = 5003
+ERR_UNEXPECTED_END_OF_DATA = 5004
+
+
+class ErrorWrapper:
+    regex_server_error = re.compile("ERROR:\s+\-(?P<code>[0-9]+):\s+.*")
+    regex_gci_error = re.compile("ERROR:\[GCI\]\s+.*")
+
+    def __init__(
+        self,
+        message: str = None,
+        context: str = None,
+        isrecoverable: bool = False,
+        iswarning: bool = False,
+        code: int = 0,
+        offset: int = 0,
+    ) -> None:      
+        self.exc_type = exceptions.DatabaseError
+        self.is_session_dead = False
+        self.offset = offset
+        self.code = code
+        self.full_code = ""
+        self.iswarning = iswarning
+        self.isrecoverable = isrecoverable
+        self.context = context
+        self.message = message
+        self._wrapper_error()
+
+    def _wrapper_error(self):
+        if self.message is not None:
+            if not self.message.startswith("ERROR"):    # GDPI ERROR
+                pos = self.message.find(":")
+                if pos > 0:
+                    self.full_code = self.message[:pos]
+            else:
+                match = self.regex_server_error.match(self.message)
+                if match is not None:                  #   Gbase8s error
+                    self.code = int(match.group("code"))
+                    self.full_code = f"GBA-{self.code}"
+                else:                                   #   GCI error
+                    match = self.regex_gci_error.match(self.message)
+                    if match is not None:
+                        self.full_code = f"GCI-{self.code}"
+
+        if self.full_code.startswith("DBAPI-"):
+            driver_error_num = int(self.full_code[6:])
+            self.exc_type = ERR_EXCEPTION_TYPES[driver_error_num // 1000]
+        elif self.full_code.startswith("GCI-"): # GCI error as InterfaceError
+            self.exc_type = exceptions.InterfaceError
+        elif self.code != 0:
+            if self.code in ERR_INTEGRITY_ERROR_CODES:
+                self.exc_type = exceptions.IntegrityError
+            elif self.code in ERR_PROGRAMMING_ERROR_CODES:
+                self.exc_type = exceptions.ProgrammingError
+            elif self.code in ERR_DATA_ERROR_CODES:
+                self.exc_type = exceptions.DataError
+
+
+    def __str__(self):
+        return self.message
+
+
+# error raise by gbase8sdb
+ERROR_TYPE = "DBAPI"
+
+def _get_whole_error(code: int, **kwargs) -> str:
+    msg_map = ERROR_MSG_MAPPING.get(code, None)
+    if not msg_map:
+        msg_map = f"not found error code: {code}."
+        kwargs = {}
+        code = ERR_MISSING_ERROR
+    try:
+        whole_msg = msg_map.format(**kwargs)
+    except KeyError:
+        whole_msg = msg_map + "\nformat error with :\n" + str(kwargs)
+    return f"{ERROR_TYPE}-{code:04}: {whole_msg}"
+
+
+def _create_error_wrapper(code: int, context_error_message: str = None, cause: Exception = None, **args) -> ErrorWrapper:
+    message = _get_whole_error(code, **args)
+    if context_error_message is None and cause is not None:
+        context_error_message = str(cause)
+    if context_error_message is not None:
+        message = f"{message}\n{context_error_message}"
+    return ErrorWrapper(message)
+
+
+def raise_error(error_num: int, context_error_message: str = None, cause: Exception = None, **args) -> None:
+    error = _create_error_wrapper(error_num, context_error_message, cause, **args)
+    raise error.exc_type(error) from cause
+
+
+
+# GBA codes in IntegrityError
+ERR_INTEGRITY_ERROR_CODES = [
+    268,  # unique constraint violated
+    391,  # cannot insert NULL
+    530,  # check constraint violated
+    691,  # referential constraint
+    703,  # Primary key on table has a field with a null key value
+]
+# GBA codes in ProgrammingError
+ERR_PROGRAMMING_ERROR_CODES = [
+    206,  # table not found
+    310,  # table already exists
+    201,  # syntax error 
+]
+
+# GBA codes in DataError
+ERR_DATA_ERROR_CODES = [
+    1202,  # divide by zero.
+]
+
+
+# mapping error code and error message
+ERROR_MSG_MAPPING = {
+    ERR_KEYWORD_ARGS_MUST_BE_DICT: (
+        '<keyword_parameters> must be dict'
+    ),
+    ERR_LOB_OF_WRONG_TYPE: (
+        "LOB must be type {expected_type_name}, not type {actual_type_name}"
+    ),
+    ERR_MIXED_ELEMENT_TYPES: (
+        "The element {element} does not match the data type of the preceding elements."
+    ),
+    ERR_MIXED_POSITIONAL_AND_NAMED_BINDS: (
+        "Positional and named bindings are not allowed to be used together"
+    ),
+    ERR_NAMED_TIMEZONE_NOT_SUPPORTED: (
+        "Other modes are incompatible with the use of named time zones"
+    ),
+    ERR_NO_STATEMENT: (
+        "Neither a statement is specified nor a prior one prepared"
+    ),
+    ERR_NO_STATEMENT_PREPARED: (
+        "statement should be prepared in advance"
+    ),
+    ERR_NOT_A_QUERY: (
+        "No rows are returned by the executed statement"
+    ),
+    ERR_NOT_CONNECTED: (
+        "The database connection is not established"
+    ),
+    ERR_NUMBER_STRING_OF_ZERO_LENGTH: "invalid number: zero length string",
+    ERR_NUMBER_STRING_TOO_LONG: "invalid number: string too long",
+    ERR_NUMBER_WITH_EMPTY_EXPONENT: "invalid number: empty exponent",
+    ERR_NUMBER_WITH_INVALID_EXPONENT: "invalid number: invalid exponent",
+    ERR_GBASE8S_NUMBER_NO_REPR: (
+        "The value is incapable of being expressed as a Gbase8s number"
+        ),
+    ERR_GBASE8S_TYPE_NAME_NOT_SUPPORTED: 'not support Gbase8s data type name "{name}"',
+    ERR_GBASE8S_TYPE_NOT_SUPPORTED: "not support Gbase8s data type {num}",
+    ERR_PYTHON_TYPE_NOT_SUPPORTED: "not support Python type {typ}",
+    ERR_PYTHON_VALUE_NOT_SUPPORTED: 'not support Python value of type "{type_name}"',
+    ERR_SELF_BIND_NOT_SUPPORTED: "binding to self is not supported",
+    ERR_TIME_NOT_SUPPORTED: (
+        "Gbase8s Database does not support time only variables"
+    ),
+    ERR_UNEXPECTED_END_OF_DATA: (
+        "unexpected end of data: want {num_bytes_wanted} bytes but "
+        "only {num_bytes_available} bytes are available"
+    ),
+    ERR_UNEXPECTED_NEGATIVE_INTEGER: (
+       "Internal error: a negative integer was read, "
+       "but a positive integer was anticipated"
+    ),
+    ERR_UNSUPPORTED_PYTHON_TYPE_FOR_DB_TYPE: (
+        "unsupported Python type {py_type_name} for database type "
+        "{db_type_name}"
+    ),
+    ERR_UNSUPPORTED_TYPE_SET: "type {db_type_name} does not support being set",
+    ERR_WRONG_ARRAY_DEFINITION: (
+        "expecting a list of two elements [type, numelems]"
+    ),
+    ERR_WRONG_EXECUTE_PARAMETERS_TYPE: (
+        "expecting a dictionary, list or tuple, or keyword args"
+    ),
+    ERR_WRONG_EXECUTEMANY_PARAMETERS_TYPE: (
+        'For the "parameters" argument, a list of sequences '
+        'or dictionaries is expected, '
+        "or alternatively, an integer to denote the execution count of the statement"
+    ), 
+    ERR_INVALID_GCI_ATTR_TYPE: "invalid GCI attribute type {attr_type}",
+    ERR_INVALID_NUMBER: "invalid number",
+    ERR_INVALID_MAKEDSN_ARG: '"{name}" argument contains invalid values',
+    ERR_INVALID_LOB_OFFSET: "LOB offset must be greater than zero",
+    ERR_INVALID_LOB_AMOUNT: "LOB amount must be greater than zero",
+    ERR_INVALID_CONNECT_PARAMS: "invalid connection params",
+    ERR_INVALID_ARRAYSIZE: "arraysize must be an integer greater than zero",
+    ERR_INTEGER_TOO_LARGE: (
+        "internal error: read integer of length {length} when expecting "
+        "integer of no more than length {max_length}"
+    ),   
+    ERR_INIT_GBASE8S_CLIENT_NOT_CALLED: (
+        "init_gbase8s_client() must be called first"
+    ),
+    ERR_INCORRECT_VAR_ARRAYSIZE: (
+        "variable array size of {var_arraysize} is "
+        "too small (should be at least {required_arraysize})"
+    ),
+    ERR_EXPECTING_VAR: (
+        "type handler should return None or the value returned by a call "
+        "to cursor.var()"
+    ),
+    ERR_EXPECTING_TYPE: "expected a type",
+    ERR_EXPECTING_LIST_FOR_ARRAY_VAR: (
+        "expecting list when setting array variables"
+    ),  
+    ERR_DUPLICATED_PARAMETER: (
+        '"{deprecated_name}" and "{new_name}" cannot be specified together'
+    ),
+    ERR_DB_TYPE_NOT_SUPPORTED: 'database type "{name}" is not supported',
+    ERR_CURSOR_NOT_OPEN: "cursor is not open",
+    ERR_CURSOR_DIFF_CONNECTION: (
+        "It is not supported to bind a cursor from a different connection."
+    ),
+    ERR_CONTENT_INVALID_AFTER_NUMBER: "invalid number (content after number)",   
+    ERR_BUFFER_LENGTH_INSUFFICIENT: (
+        "internal error: buffer of length {actual_buffer_len} "
+        "insufficient to hold {required_buffer_len} bytes"
+    ),
+    ERR_ARRAYS_OF_ARRAYS: "arrays of arrays are not supported",
+    ERR_ARGS_AND_KEYWORD_ARGS: (
+        "expecting positional arguments or keyword arguments, not both"
+    ),
+    ERR_ARGS_MUST_BE_LIST_OR_TUPLE: "arguments must be a list or tuple",
+    ERR_INVALID_ARGS: "Invalid arguments", 
+}

gbase8sdb/exceptions.py

@@ -0,0 +1,41 @@
+# coding: utf-8
+
+
+class Warning(Exception):
+    pass
+
+
+class Error(Exception):
+    pass
+
+
+class DatabaseError(Error):
+    pass
+
+
+class DataError(DatabaseError):
+    pass
+
+
+class IntegrityError(DatabaseError):
+    pass
+
+
+class InterfaceError(Error):
+    pass
+
+
+class InternalError(DatabaseError):
+    pass
+
+
+class NotSupportedError(DatabaseError):
+    pass
+
+
+class OperationalError(DatabaseError):
+    pass
+
+
+class ProgrammingError(DatabaseError):
+    pass

gbase8sdb/lob.py

@@ -0,0 +1,90 @@
+# coding: utf-8
+
+from typing import Any, Union
+
+
+from . import __name__ as MODULE_NAME
+from . import errors
+from .driver import DB_TYPE_BLOB
+
+
+
+class LOB:
+    __module__ = MODULE_NAME
+    
+    def __str__(self):        
+        return str(self.read())
+
+    def __del__(self):
+        self._cyobj.free_lob()
+
+    def __reduce__(self):
+        value = self.read()
+        return (type(value), (value,))
+
+    
+    @classmethod
+    def _create_with_cyobj(cls, cyobj):
+        lob = cls.__new__(cls)
+        lob._cyobj = cyobj
+        return lob
+
+    def _check_value_to_write(self, value):
+        if isinstance(value, bytes):
+            if self.type is DB_TYPE_BLOB:
+                return value
+            else:
+                return value.decode('utf-8')
+        elif isinstance(value, str):
+            if self.type is DB_TYPE_BLOB:
+                return value.encode('utf-8')
+            else:
+                return value
+        else:
+            raise TypeError("expecting string or bytes")        
+
+    def close(self):
+        self._cyobj.close()
+
+    def getchunksize(self):
+        return self._cyobj.get_chunk_size()
+
+    def isopen(self):
+        return self._cyobj.get_is_open()
+
+    def open(self):
+        self._cyobj.open()
+
+    def read(self, offset: int = 1, amount: int = None):
+        if amount is None:
+            amount = self._cyobj.get_max_amount()
+            if amount >= offset:
+                amount = amount - offset + 1
+            else:
+                amount = 1
+        elif amount <= 0:
+            errors.raise_error(errors.ERR_INVALID_LOB_AMOUNT)
+        if offset <= 0:
+            errors.raise_error(errors.ERR_INVALID_LOB_OFFSET)
+        return self._cyobj.read(offset, amount)
+
+    def size(self):
+        return self._cyobj.get_size()
+
+    def trim(self, new_size: int = 0, *, newSize: int = None):
+        if newSize is not None:
+            if new_size != 0:
+                errors.raise_error(
+                    errors.ERR_DUPLICATED_PARAMETER,
+                    deprecated_name="newSize",
+                    new_name="new_size",
+                )
+            new_size = newSize
+        self._cyobj.trim(new_size)
+
+    def write(self, data: Union[str, bytes], offset: int = 1):
+        self._cyobj.write(self._check_value_to_write(data), offset)
+
+    @property
+    def type(self):
+        return self._cyobj.dbtype

gbase8sdb/var.py

@@ -0,0 +1,79 @@
+# coding: utf-8
+
+from typing import Any, Callable
+from .driver import DbType
+
+
+class Var:
+    def __repr__(self):
+        value = self._cyobj.get_all_values()
+        if not self._cyobj.is_array and len(value) == 1:
+            value = value[0]
+        typ = self._type
+        return f"<gbase8sdb.Var of type {typ.name} with value {repr(value)}>"
+
+    @classmethod
+    def _create_with_cyobj(cls, impl, typ=None):
+        var = cls.__new__(cls)
+        var._cyobj = impl
+        if typ is not None:
+            var._type = typ
+        else:
+            var._type = impl.dbtype
+        return var
+
+    @property
+    def actual_elements(self) -> int:
+        if self._cyobj.is_array:
+            return self._cyobj.num_elements_in_array
+        return self._cyobj.num_elements
+
+    @property
+    def actualElements(self) -> int:
+        return self.actual_elements
+
+    @property
+    def buffer_size(self) -> int:
+        return self._cyobj.buffer_size
+
+    @property
+    def bufferSize(self) -> int:
+        return self.buffer_size
+
+    @property
+    def convert_nulls(self) -> bool:
+        return self._cyobj.convert_nulls
+
+    def getvalue(self, pos: int = 0) -> Any:
+        return self._cyobj.get_value(pos)
+
+    @property
+    def inconverter(self) -> Callable:
+        return self._cyobj.inconverter
+
+    @property
+    def num_elements(self) -> int:
+        return self._cyobj.num_elements
+
+    @property
+    def numElements(self) -> int:
+        return self.num_elements
+
+    @property
+    def outconverter(self) -> Callable:
+        return self._cyobj.outconverter
+
+    def setvalue(self, pos: int, value: Any) -> None:
+        self._cyobj.set_value(pos, value)
+
+    @property
+    def size(self) -> int:
+        return self._cyobj.size
+
+    @property
+    def type(self) -> DbType:
+        return self._type
+
+    @property
+    def values(self) -> list:
+        return self._cyobj.get_all_values()

gbase8sdb/version.py

@@ -0,0 +1,7 @@
+# coding: utf8
+"""
+The version of the driver.
+"""
+
+__version__ = ".".join(map(str, (0, 1, 0)))
+

gbase8sdb-0.1.0.dist-info/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (C) 2025 GBASE Technologies Co.,Ltd.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

gbase8sdb-0.1.0.dist-info/METADATA

@@ -0,0 +1,66 @@
+Metadata-Version: 2.2
+Name: gbase8sdb
+Version: 0.1.0
+Summary: Python interface to GBase 8s Database
+License: MIT
+Keywords: GBase 8s,database
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Cython
+Classifier: Topic :: Database
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+License-File: THIRD_PARTY_LICENSES.txt
+
+# python-gbase8sdb
+
+python-gbase8sdb 是一个 [Python 编程语言][python] 扩展模块，允许 Python 程序连接到 GBase 8s 数据库。
+
+该模块符合 [Python 数据库 API 2.0 规范][pep249]，并且包含大量扩展和少数排除项。
+
+
+## 安装
+
+运行 `python -m pip install gbase8sdb` 安装。
+
+
+## 依赖和互操作性
+
+- 支持的 Python 版本：3.7 至 3.12 。
+
+- 支持的 GBase 8s 数据库版本：GBase 8s V8.8_3.6.2版本及以上。
+
+- 支持的操作系统：Linux x86_64 。
+
+- 依赖 GSDK 3.0.0 版本及以上。
+
+
+## 文档
+
+进入 [/doc][doc]目录，执行如下编译命令生成 HTML 文档：
+
+```bash
+make html
+```
+编译后生成的HTML文档位于 */doc/build/html/index.html* 。
+
+## 示例
+
+示例代码位于 [/samples][samples] 目录中。
+
+## 测试
+
+请参阅 [/tests][tests]
+
+
+[python]: https://www.python.org/
+[pep249]: https://peps.python.org/pep-0249/
+[tests]: https://gitee.com/GBase8s/dev_gbaseDB/tree/master/tests
+[samples]: https://gitee.com/GBase8s/dev_gbaseDB/tree/master/samples
+[doc]: https://gitee.com/GBase8s/dev_gbaseDB/tree/master/doc

gbase8sdb-0.1.0.dist-info/RECORD

@@ -0,0 +1,20 @@
+gbase8sdb/__init__.py,sha256=1ajotGGMb-joNKKi7nUKn5gTy48qBQAuze4EecMIF3o,2946
+gbase8sdb/column_metadata.py,sha256=OjCsICwH1D8XIs5uM4FfBrKese2U7Bc-WYWC9JPEeTA,2793
+gbase8sdb/connection.py,sha256=611ZmiNWf3TYNt55btwzvbqeN8A201XyPk2vZF0zvNU,4410
+gbase8sdb/constructors.py,sha256=qXtsZ8Nyiq5wrlaSrN3lR7JYwUw7NcqIB9dsmgqoaNU,900
+gbase8sdb/cursor.py,sha256=pgACZ11dAeOcooOoi2ArtkNWGA5oTPkDDQ4M7bafEhg,12350
+gbase8sdb/defaults.py,sha256=KnjFBKnK4vnIjAN128spKEI7PB3DHypzNMTkwcUcyIw,993
+gbase8sdb/driver.cpython-310-x86_64-linux-gnu.so,sha256=m8e5iaMvm2hm0eMEwSdGZ5KQTbLAtnky8zNMx3_b34c,5539345
+gbase8sdb/dsn.py,sha256=LkQmQWebvUsPWcIxMLHj1yh6NxDgwx4hQcPZHNijEas,1552
+gbase8sdb/errors.py,sha256=_BK0qTTnukbJ3N6JEyxSMRnYZ3OQgwZPyUks0iI4ULY,11027
+gbase8sdb/exceptions.py,sha256=SjWBklHYQDIcQ1asBU2FDbvx94x_O89P6rC-7gDfpPA,456
+gbase8sdb/lob.py,sha256=hJnTzKfzhVJo4Cgknpyxhmcm0ZN-cy8Qvtt1hHIvIUg,2368
+gbase8sdb/var.py,sha256=zDEjUiijrpFeEUFeepFobT1GyazTEaUqi4MrqnxC2PY,1904
+gbase8sdb/version.py,sha256=HtzACVQOfk1TH4yi1sr8baIilnotG7T9GcBUO2iCGNk,96
+gbase8sdb-0.1.0.dist-info/LICENSE.txt,sha256=kDUGdWcTVtXFktGLHB-glp1LI92-VW5ipQlAVR4WKP4,1083
+gbase8sdb-0.1.0.dist-info/METADATA,sha256=FK9DPdy-gbtWTfhMAP0O_89_oTnEmsLEilaTc6lsZkA,1813
+gbase8sdb-0.1.0.dist-info/THIRD_PARTY_LICENSES.txt,sha256=88_Bn1SLiGFNZq9HNBedps7zemgR50FRat29TWtFkj4,28103
+gbase8sdb-0.1.0.dist-info/WHEEL,sha256=ViyZsTV2upbIniGkknQiIrLPLs1cJIoIfr1wsV7PMic,151
+gbase8sdb-0.1.0.dist-info/top_level.txt,sha256=5M_P75jEB53qPfRObJmPBMDvuPGpZil5omAJAMlaqlI,10
+gbase8sdb-0.1.0.dist-info/RECORD,,
+gbase8sdb.libs/libgdpic-25934479.so.3.6.2_2_3.0.0_1P20250226_temp_d4287d,sha256=NHbAprXqv8ToknEiEQPNbXPF75Qu1RjRfbfxQ3FTHKE,429969