lesscode-database 0.0.10__py3-none-any.whl → 0.0.12__py3-none-any.whl

lesscode_database/connect_pool.py

@@ -3,6 +3,7 @@ import asyncio
 import importlib
 import ssl
 from inspect import iscoroutine
+from xml.sax import parse
 
 from lesscode_database.connection_info import ConnectionInfo
 from lesscode_database.db_request import get_basic_auth
@@ -208,7 +209,7 @@ class Pool:
                                   mincached=conn_info.min_size, blocking=True, maxusage=conn_info.min_size,
                                   maxshared=conn_info.max_size, maxcached=conn_info.max_size,
                                   ping=1, maxconnections=conn_info.max_size, charset="utf8mb4", autocommit=True,
-                                  read_timeout=30)
+                                  read_timeout=30,ursorclass=pymysql.cursors.DictCursor)
         return pool
 
     @staticmethod
@@ -644,34 +645,63 @@ class Pool:
 
     @staticmethod
     async def create_clickhouse_pool(conn_info: ConnectionInfo):
-        try:
-            asynch = importlib.import_module("asynch")
-        except ImportError:
-            raise ImportError(f"asynch is not exist,run:pip install asynch")
-        pool = await asynch.create_pool(minsize=conn_info.min_size, maxsize=conn_info.max_size,
-                                        dsn=conn_info.dsn, host=conn_info.host,
-                                        user=conn_info.user, password=conn_info.password,
-                                        port=conn_info.port, database=conn_info.db_name)
+
+        params = conn_info.params if conn_info.params else {}
+        creator_type = params.pop("creator_type","asynch")
+        if creator_type == "clickhouse_connect":
+            try:
+                clickhouse_connect = importlib.import_module("clickhouse_connect")
+            except ImportError:
+                raise Exception(f"DBUtils is not exist,run:pip install clickhouse_connect==0.8.6")
+            pool = await clickhouse_connect.get_async_client(host=conn_info.host, port=conn_info.port,
+                                                              username=conn_info.user,
+                                                              password=conn_info.password, database=conn_info.db_name,
+                                                              **params)
+
+
+        else:
+            try:
+                asynch = importlib.import_module("asynch")
+            except ImportError:
+                raise ImportError(f"asynch is not exist,run:pip install asynch")
+            pool = await asynch.create_pool(minsize=conn_info.min_size, maxsize=conn_info.max_size,
+                                            dsn=conn_info.dsn, host=conn_info.host,
+                                            user=conn_info.user, password=conn_info.password,
+                                            port=conn_info.port, database=conn_info.db_name)
         return pool
 
     @staticmethod
     def sync_create_clickhouse_pool(conn_info: ConnectionInfo):
-        try:
-            pooled_db = importlib.import_module("dbutils.pooled_db")
-        except ImportError:
-            raise Exception(f"DBUtils is not exist,run:pip install DBUtils==3.0.2")
-        try:
-            clickhouse_driver = importlib.import_module("clickhouse_driver")
-        except ImportError:
-            raise Exception(f"clickhouse_driver is not exist,run:pip install clickhouse_driver")
-        params = conn_info.params
-        if not isinstance(params, dict):
-            params = dict()
+        params = conn_info.params if conn_info.params else {}
+        creator_type = params.pop("creator_type", "clickhouse_driver")
+        if creator_type == "clickhouse_connect":
+            try:
+                clickhouse_connect = importlib.import_module("clickhouse_connect")
+            except ImportError:
+                raise Exception(f"DBUtils is not exist,run:pip install clickhouse_connect==0.6.23")
+            params = conn_info.params
+            if not params:
+                params = dict()
+            pool = clickhouse_connect.get_client(host=conn_info.host, port=conn_info.port, username=conn_info.user,
+                                                   password=conn_info.password, database=conn_info.db_name, **params)
+        else:
+            try:
+                pooled_db = importlib.import_module("dbutils.pooled_db")
+            except ImportError:
+                raise Exception(f"DBUtils is not exist,run:pip install DBUtils==3.0.2")
+            try:
+                clickhouse_driver = importlib.import_module("clickhouse_driver")
+            except ImportError:
+                raise Exception(f"clickhouse_driver is not exist,run:pip install clickhouse_driver")
+            params = conn_info.params
+            if not isinstance(params, dict):
+                params = dict()
+
+            pool = pooled_db.PooledDB(creator=clickhouse_driver.connect, host=conn_info.host, port=conn_info.port,
+                                      user=conn_info.user,
+                                      password=conn_info.password, database=conn_info.db_name or "default",
+                                      **params)
 
-        pool = pooled_db.PooledDB(creator=clickhouse_driver.connect, host=conn_info.host, port=conn_info.port,
-                                  user=conn_info.user,
-                                  password=conn_info.password, database=conn_info.db_name or "default",
-                                  **params)
         return pool
 
     @staticmethod

lesscode_database/ds_helper.py

@@ -135,3 +135,87 @@ class DsHelper:
                 if i == num - 1:
                     raise e
         return res
+
+
+    def exec_(self,sql_type:str,sql):
+        if sql_type not in ["all", "first", "delete", "update", "insert"]:
+            raise Exception(f"sql_type must be all,first,delete,update,insert")
+        if self.connect_info.db_type  in ["mysql","doris","ocean_base","tidb"]:
+            if sql_type == "all":
+                with self.pool.dedicated_connection() as conn:
+                    conn.ping(reconnect=True)
+                    with conn.cursor() as cursor:
+                        cursor.execute(sql)
+                        rs = cursor.fetchall()
+                        return rs
+            elif sql_type == "first":
+                with self.pool.dedicated_connection() as conn:
+                    conn.ping(reconnect=True)
+                    with conn.cursor() as cursor:
+                        cursor.execute(sql)
+                        rs = cursor.fetchone()
+                        return rs
+            elif sql_type == "delete":
+                with self.pool.dedicated_connection() as conn:
+                    conn.ping(reconnect=True)
+                    with conn.cursor() as cursor:
+                        rs = cursor.execute(sql)
+                        return rs
+            elif sql_type == "update":
+                with self.pool.dedicated_connection() as conn:
+                    conn.ping(reconnect=True)
+                    with conn.cursor() as cursor:
+                        rs = cursor.execute(sql)
+                        return rs
+            else:
+                with self.pool.dedicated_connection() as conn:
+                    conn.ping(reconnect=True)
+                    with conn.cursor() as cursor:
+                        rs= cursor.execute(sql)
+                        return rs
+
+
+        elif self.connect_info.db_type == "neo4j":
+            return self.make_neo4j_session()
+        elif self.connect_info.db_type == "esapi":
+            return self.esapi
+        elif self.connect_info.db_type == "es":
+            return self.esapi
+        else:
+            return self.pool
+
+    async def async_exec_(self,sql_type:str,sql):
+        if sql_type not in ["all", "first", "delete", "update", "insert"]:
+            raise Exception(f"sql_type must be all,first,delete,update,insert")
+        if self.connect_info.db_type in ["mysql","doris","ocean_base","tidb"]:
+            if sql_type == "all":
+                async with self.pool.acquire() as conn:
+                    async with conn.cursor() as cursor:
+                        await cursor.execute(sql)
+                        rs = await cursor.fetchall()
+                        return rs
+            elif sql_type == "first":
+                async with self.pool.acquire() as conn:
+                    async with conn.cursor() as cursor:
+                        await cursor.execute(sql)
+                        rs = await cursor.fetchone()
+                        return rs
+            elif sql_type == "delete":
+                async with self.pool.acquire() as conn:
+                    async with conn.cursor() as cursor:
+                        rs = await cursor.execute(sql)
+                        return rs
+            elif sql_type == "update":
+                async with self.pool.acquire() as conn:
+                    async with conn.cursor() as cursor:
+                        rs = await cursor.execute(sql)
+                        return rs
+            else:
+                async with self.pool.acquire() as conn:
+                    async with conn.cursor() as cursor:
+                        rs= await cursor.execute(sql)
+                        return rs
+        elif self.connect_info.db_type == "neo4j":
+            return self.async_make_neo4
+        else:
+            return self.pool

lesscode_database/orm/orm_exec.py

@@ -0,0 +1,299 @@
+from typing import Union
+
+from lesscode_database.ds_helper import DsHelper
+from lesscode_database.orm.orm_func import OrmFunc
+from lesscode_database.orm.orm_model import BaseModel
+from lesscode_database.orm.orm_typing import BaseColumnType, BaseColumnTypeAlias, SubSelect, Int, TinyInt, SmallInt, \
+    MediumInt
+
+
+class Select:
+    def __init__(self, *args):
+        self._tables = []
+        self._column_tables = []
+        self._columns = []
+        self._origin_column_map = dict()
+        self._joins = []
+        self._conditions = []
+        self._group_by = []
+        self._having = []
+        self._order_by = []
+        self._limit = []
+        self._connect_name = None
+        for arg in args:
+            if isinstance(arg, BaseColumnType):
+                if hasattr(arg, "owner"):
+                    if not self._connect_name:
+                        self._connect_name = arg.owner.__bind_key__ if hasattr(arg.owner, '__bind_key__') else None
+                    _table_name = arg.owner.__table_name__ if hasattr(arg.owner, "__table_name__") else ""
+                    if _table_name and _table_name not in self._tables:
+                        self._column_tables.append(_table_name)
+                self._columns.append(arg._name)
+                self._origin_column_map = {arg._name: arg}
+
+            elif isinstance(arg, BaseColumnTypeAlias):
+                _ct = arg.column_type
+                if isinstance(_ct, BaseColumnType):
+                    if hasattr(_ct, "owner"):
+                        _table_name = _ct.owner.__table_name__ if hasattr(_ct, "__table_name__") else ""
+                        if _table_name and _table_name not in self._column_tables:
+                            self._column_tables.append(_table_name)
+                        if not self._connect_name:
+                            self._connect_name = _ct.owner.__bind_key__ if hasattr(_ct.owner, '__bind_key__') else None
+                self._origin_column_map = {arg.alias: arg}
+                self._columns.append(arg._name)
+
+            elif isinstance(arg, OrmFunc):
+                self._columns.append(str(arg))
+                self._origin_column_map = {arg._name: arg}
+
+            elif issubclass(arg, BaseModel):
+                if hasattr(arg, "__table_name__"):
+                    _table_name = arg.__table_name__
+                    if _table_name and _table_name not in self._column_tables:
+                        self._column_tables.append(_table_name)
+                if not self._connect_name:
+                    if hasattr(arg, "__bind_key__"):
+                        self._connect_name = arg.__bind_key__
+                _attrs = vars(arg)
+                for attr in _attrs:
+                    if hasattr(arg, attr):
+                        if isinstance(getattr(arg, attr), BaseColumnType):
+                            self._origin_column_map = {getattr(arg, attr)._name: getattr(arg, attr)}
+                            self._columns.append(getattr(arg, attr)._name)
+            else:
+                raise TypeError("args must be str or BaseColumnType")
+
+    def select_from(self, model):
+        if isinstance(model, list):
+            for _model in model:
+                if issubclass(_model, BaseModel):
+                    if hasattr(_model, "__table_name__"):
+                        if _model.__table_name__ not in self._tables:
+                            self._tables.append(_model.__table_name__)
+                    if not self._connect_name:
+                        if hasattr(_model, "__bind_key__"):
+                            self._connect_name = _model.__bind_key__
+                else:
+                    raise TypeError("model must be BaseModel")
+        elif issubclass(model, BaseModel):
+            if hasattr(model, "__table_name__"):
+                if model.__table_name__ not in self._tables:
+                    self._tables.append(model.__table_name__)
+            if not self._connect_name:
+                if hasattr(model, "__bind_key__"):
+                    self._connect_name = model.__bind_key__
+        else:
+            raise TypeError("model must be BaseModel")
+        return self
+
+    def join(self, model, relation_list: list, how="left join"):
+        if not issubclass(model, BaseModel):
+            raise TypeError("model must be BaseModel")
+        self._joins.append(f"{how} {model.__table_name__} ON {' and '.join(relation_list)}")
+        return self
+
+    def where(self, *args):
+        self._conditions = [arg for arg in args]
+        return self
+
+    def group_by(self, *args):
+        self._group_by = [arg for arg in args]
+        return self
+
+    def having(self, *args):
+        self._having = [arg for arg in args]
+        return self
+
+    def order_by(self, *args):
+        self._order_by = [arg for arg in args]
+        return self
+
+    def limit(self, offset=0, num=10):
+        self._limit = [offset, num]
+        return self
+
+    def sub(self, alias: str = None):
+        return SubSelect(sql=self._sql(), alias=alias)
+
+    def _sql(self):
+        sql = f"select {','.join(self._columns)}"
+        if self._tables:
+            sql += f" from {' , '.join(self._tables)}"
+        else:
+            if self._column_tables:
+                sql += f" from {' , '.join(self._column_tables)}"
+        if self._joins:
+            sql += " " + " ".join(self._joins)
+        if self._conditions:
+            sql += " where " + " and ".join(self._conditions)
+
+        if self._group_by:
+            sql += " group by " + " , ".join(self._group_by)
+        if self._having:
+            sql += " having " + " and ".join(self._having)
+        if self._order_by:
+            sql += " order by " + " , ".join(self._order_by)
+        if self._limit:
+            sql += f" limit {self._limit[0]},{self._limit[1]}"
+        return sql
+
+    def __repr__(self):
+        return self._sql()
+
+    def __str__(self) -> str:
+        return self.__repr__()
+
+
+class Update:
+    def __init__(self, model):
+        self._table = ""
+        self._conditions = []
+        self._connect_name = ""
+        self.update_values = {}
+        if issubclass(model, BaseModel):
+            self._table = model.__table_name__
+            self._connect_name = model.__bind_key__
+        else:
+            raise TypeError("model must be BaseModel")
+
+    def where(self, *args):
+        self._conditions = [arg for arg in args]
+        return self
+
+    def values(self, **kwargs):
+        self.update_values = kwargs
+
+    def _sql(self):
+        sql = f"update {self._table} set "
+        update_column_sql = ','.join([f"{k}={v}" for k, v in self.update_values.items()])
+        sql += update_column_sql
+        if self._conditions:
+            sql += " where " + " and ".join(self._conditions)
+        return sql
+
+
+class Delete:
+    def __init__(self, model):
+        self._table = ""
+        self._conditions = []
+        self._connect_name = ""
+        self.update_values = {}
+        if issubclass(model, BaseModel):
+            self._table = model.__table_name__
+            self._connect_name = model.__bind_key__
+        else:
+            raise TypeError("model must be BaseModel")
+
+    def where(self, *args):
+        self._conditions = [arg for arg in args]
+        return self
+
+    def _sql(self):
+        sql = f"delete from {self._table}"
+        if self._conditions:
+            sql += " where " + " and ".join(self._conditions)
+        return sql
+
+
+class Insert:
+    def __init__(self, model):
+        self._table = ""
+        self._connect_name = ""
+        self.insert_values = {}
+        if issubclass(model, BaseModel):
+            self._table = model.__table_name__
+            self._connect_name = model.__bind_key__
+        else:
+            raise TypeError("model must be BaseModel")
+
+    def values(self, data: Union[list, dict]):
+        self.insert_values = data
+
+    def _sql(self):
+        sql = f"insert into {self._table} "
+        insert_column_list = []
+        insert_value_list = []
+        if isinstance(self.insert_values, list):
+            one = self.insert_values[0]
+            insert_column_list = list(one.keys())
+            for _ in self.insert_values:
+                _insert_value_list = []
+                for k in insert_column_list:
+                    if _[k] is None:
+                        _insert_value_list.append("null")
+                    else:
+                        _insert_value_list.append(_[k])
+                insert_value_list.append(f"""({','.join(_insert_value_list)})""")
+        else:
+            _insert_value_list = []
+            for k, v in self.insert_values.items():
+                if v is None:
+                    insert_column_list.append(k)
+                    _insert_value_list.append("null")
+                else:
+                    insert_column_list.append(k)
+                    _insert_value_list.append(v)
+            insert_value_list.append(f"""({','.join(_insert_value_list)})""")
+        sql += f"({','.join(insert_column_list)}) values ({','.join(insert_value_list)})"
+        return sql
+
+
+class Exec:
+    __connect_name__ = None
+
+    def __init__(self, connect_name: str = None):
+        self.__connect_name__ = connect_name or self.__connect_name__
+        self._sql = ""
+        self._result = None
+        self.sql_type =""
+
+    def execute(self, sql_object: Union[Select, Update, Delete, Insert]):
+        if not self.__connect_name__:
+            self.__connect_name__ = sql_object._connect_name
+        self._sql = sql_object._sql()
+        if isinstance(sql_object, Select):
+            return self
+        else:
+            return self
+
+    def all(self):
+        self.sql_type = "all"
+        self._result = DsHelper(self.__connect_name__).exec_(self.sql_type, self._sql)
+        return self._result
+
+    def first(self):
+        self.sql_type = "first"
+        self._result = DsHelper(self.__connect_name__).exec_(self.sql_type, self._sql)
+        return self._result
+
+    def update(self):
+        self.sql_type = "update"
+        self._result = DsHelper(self.__connect_name__).exec_(self.sql_type, self._sql)
+        return self._result
+
+    def delete(self):
+        self.sql_type = "delete"
+        self._result = DsHelper(self.__connect_name__).exec_(self.sql_type, self._sql)
+        return self._result
+
+    def insert(self):
+        self.sql_type = "insert"
+        self._result = DsHelper(self.__connect_name__).exec_(self.sql_type, self._sql)
+        return self._result
+
+
+class TestModel(BaseModel):
+    __table_name__ = 'test_table'
+    __table_args__ = {'comment': '测试表'}
+    __bind_key__ = 'test_db'
+    id = Int('id', int, primary_key=True, autoincrement=True)
+    name = TinyInt('name', int)
+    age = SmallInt('age', int)
+    height = MediumInt('height', int)
+
+
+a = Select(TestModel.id.alias("a"))
+b = a.join(TestModel, [TestModel.id == TestModel.id]).where(TestModel.id == 1)
+
+print(Exec().execute(b))

lesscode_database/orm/orm_func.py

@@ -0,0 +1,45 @@
+from typing import Union
+
+from lesscode_database.orm.orm_typing import BaseColumnType
+
+
+class OrmFunc:
+    def __init__(self, func_name: str, alias: str = None, **kwargs):
+        self.func_name = func_name
+        self.alias = alias
+        self.kwargs = kwargs or dict()
+
+    def _name(self):
+        return self.alias or str(self)
+
+    def __repr__(self):
+        if self.func_name in ["sum", "argv", "min", "max"]:
+            column = self.kwargs.get("column")
+            if column is None:
+                return f"{self.func_name}()"
+            else:
+                if isinstance(column, BaseColumnType):
+                    return f"{self.func_name}({column._name}) as {self.alias}" if self.alias else f"{self.func_name}({column._name})"
+                else:
+                    return f"{self.func_name}({repr(column)}) as {self.alias}" if self.alias else f"{self.func_name}({repr(column)})"
+        else:
+            return f"{self.func_name}({self.kwargs})"
+
+    def __str__(self):
+        return self.__repr__()
+
+
+def func_sum(column: Union[BaseColumnType, int, float], alias=None):
+    return OrmFunc(func_name="sum", column=column, alias=alias)
+
+
+def func_min(column: Union[BaseColumnType, int, float], alias=None):
+    return OrmFunc(func_name="min", column=column, alias=alias)
+
+
+def func_max(column: Union[BaseColumnType, int, float], alias=None):
+    return OrmFunc(func_name="max", column=column, alias=alias)
+
+
+def func_argv(column: Union[BaseColumnType, int, float], alias=None):
+    return OrmFunc(func_name="argv", column=column, alias=alias)

lesscode_database/orm/orm_model.py

@@ -0,0 +1,21 @@
+from lesscode_database.orm.orm_typing import BaseColumnType
+
+
+class Meta(type):
+    def __new__(cls, name, bases, namespace):
+        for attr_name, attr_value in namespace.items():
+            if isinstance(attr_value, BaseColumnType):
+                attr_value.name = attr_name
+                attr_value.owner = None
+        new_cls = super().__new__(cls, name, bases, namespace)
+        for attr_value in namespace.values():
+            if isinstance(attr_value, BaseColumnType):
+                attr_value.owner = new_cls
+                attr_value.connect_name = new_cls.__bind_key__ if hasattr(new_cls, '__bind_key__') else None
+        return new_cls
+
+
+class BaseModel(metaclass=Meta):
+    __table_name__ = 'base'
+    __table_args__ = {}
+    __bind_key__ = 'default'

lesscode_database/orm/orm_typing.py

@@ -0,0 +1,412 @@
+import datetime
+import time
+from typing import Optional, Union, Any
+from decimal import Decimal as _Decimal
+
+
+class SubSelect:
+    def __init__(self, sql: str, alias: str):
+        self.sql = sql
+        self.alias = alias
+
+
+class BaseColumnType:
+
+    def __init__(self, name: Optional[str], type_: Optional[Any],
+                 default: Optional[Any] = None, index: Optional[bool] = None,
+                 unique: Optional[bool] = None, nullable: Optional[bool] = True,
+                 primary_key: Optional[bool] = False,
+                 alias: Optional[str] = None,
+                 is_symbol: Optional[bool] = False, symbol="`",
+                 comment=""):
+        super(BaseColumnType, self).__init__()
+        self.name = name or self.__class__.__name__.lower()
+        self.name = f"{symbol}{self.name}{symbol}" if is_symbol else self.name
+        self.alias = alias or self.name
+        self.type_ = type_
+        self.default = default
+        self.index = index
+        self.unique = unique
+        self.nullable = nullable
+        self.primary_key = primary_key
+        self.comment = comment
+
+    def _check_value(self, value):
+        if not isinstance(value, self.type_):
+            raise Exception(f"{value} is not {self.type_} type")
+
+    def __eq__(self, other):
+        # 返回格式化的字符串
+        if not issubclass(other.__class__, BaseColumnType):
+            return f"{self._name}={other}"
+        else:
+            return f"{self._name}={other._name}"
+
+    def __ge__(self, other):
+        # 返回格式化的字符串
+        return f"{self._name}>={other._name}"
+
+    def __gt__(self, other):
+        # 返回格式化的字符串
+        return f"{self._name}>{other._name}"
+
+    def __le__(self, other):
+        # 返回格式化的字符串
+        return f"{self._name}<={other._name}"
+
+    def __lt__(self, other):
+        # 返回格式化的字符串
+        return f"{self._name}<{other._name}"
+
+    def __ne__(self, other):
+        # 返回格式化的字符串
+        return f"{self._name}!={other._name}"
+
+    @property
+    def _name(self):
+        _table_name = self.owner.__table_name__ if hasattr(self, "owner") else ""
+        return f"{_table_name}.{self.name}"
+
+    def in_(self, value: Union[list, tuple, SubSelect]):
+        if isinstance(value, SubSelect):
+            return f"{self._name} in ({value.sql})"
+        else:
+            return f"{self._name} in {repr(value)}"
+
+    def not_in(self, value: Union[list, tuple, SubSelect]):
+        if isinstance(value, SubSelect):
+            return f"{self._name} not in ({value.sql})"
+        else:
+            return f"{self._name} not in {repr(value)}"
+
+    def like(self, value: str):
+        return f"{self._name} like {repr(value)}"
+
+    def not_like(self, value: str):
+        return f"{self._name} not like {repr(value)}"
+
+    def is_null(self, value="null"):
+        return f"{self._name} is {value}"
+
+    def is_not_null(self, value="null"):
+        return f"{self._name} is not {value}"
+
+    def desc(self):
+        return f"{self._name} desc"
+
+    def asc(self):
+        return f"{self._name} asc"
+
+    def alias(self, name):
+        self.alias = name
+
+
+class BaseColumnTypeAlias:
+    def __init__(self, column_type, alias):
+        self.column_type = column_type
+        self.alias = alias
+
+    @property
+    def _name(self):
+        return f"{self.column_type._name} as {self.alias}"
+
+
+class TinyInt(BaseColumnType):
+
+    def __init__(self, name: Optional[str], type_: Optional[Any] = int,
+                 default: Optional[Any] = None,
+                 nullable: Optional[bool] = True,
+                 comment=""):
+        if not issubclass(type_, int):
+            raise Exception("type_ must be int")
+        super().__init__(name=name, type_=type_, default=default, nullable=nullable,
+                         comment=comment)
+
+
+class SmallInt(BaseColumnType):
+
+    def __init__(self, name: Optional[str], type_: Optional[Any] = int,
+                 default: Optional[Any] = None, index: Optional[bool] = None,
+                 unique: Optional[bool] = None, nullable: Optional[bool] = True, primary_key: Optional[bool] = False,
+                 comment=""):
+        if not issubclass(type_, int):
+            raise Exception("type_ must be int")
+        super().__init__(name=name, type_=type_, default=default, index=index, unique=unique, nullable=nullable,
+                         primary_key=primary_key, comment=comment)
+
+
+class MediumInt(BaseColumnType):
+
+    def __init__(self, name: Optional[str], type_: Optional[Any] = int,
+                 default: Optional[Any] = None, index: Optional[bool] = None,
+                 unique: Optional[bool] = None, nullable: Optional[bool] = True, primary_key: Optional[bool] = False,
+                 comment=""):
+        if not issubclass(type_, int):
+            raise Exception("type_ must be int")
+        super().__init__(name=name, type_=type_, default=default, index=index, unique=unique, nullable=nullable,
+                         primary_key=primary_key, comment=comment)
+
+
+class Int(BaseColumnType):
+
+    def __init__(self, name: Optional[str], type_: Optional[Any] = int,
+                 default: Optional[Any] = None, index: Optional[bool] = None,
+                 unique: Optional[bool] = None, nullable: Optional[bool] = True, primary_key: Optional[bool] = False,
+                 comment="", autoincrement: bool = False):
+        if not issubclass(type_, int):
+            raise Exception("type_ must be int")
+        super().__init__(name=name, type_=type_, default=default, index=index, unique=unique, nullable=nullable,
+                         primary_key=primary_key, comment=comment)
+        self.autoincrement = autoincrement
+
+
+class BigInt(BaseColumnType):
+    def __init__(self, name: Optional[str], type_: Optional[Any] = int,
+                 default: Optional[Any] = None, index: Optional[bool] = None,
+                 unique: Optional[bool] = None, nullable: Optional[bool] = True, primary_key: Optional[bool] = False,
+                 comment="", autoincrement: bool = False):
+        if not issubclass(type_, int):
+            raise Exception("type_ must be int")
+        super().__init__(name=name, type_=type_, default=default, index=index, unique=unique, nullable=nullable,
+                         primary_key=primary_key, comment=comment)
+        self.autoincrement = autoincrement
+
+
+class Decimal(BaseColumnType):
+    def __init__(self, name: Optional[str], type_: Optional[Any] = _Decimal,
+                 precision: int = 10, scale: int = 2,
+                 default: Optional[Any] = None, index: Optional[bool] = None,
+                 unique: Optional[bool] = None, nullable: Optional[bool] = True, primary_key: Optional[bool] = False,
+                 comment=""):
+        if not issubclass(type_, _Decimal):
+            raise Exception("type_ must be decimal")
+        super().__init__(name=name, type_=type_, default=default, index=index, unique=unique, nullable=nullable,
+                         primary_key=primary_key, comment=comment)
+        self.precision = precision
+        self.scale = scale
+
+
+class Float(Decimal):
+    def __init__(self, name: Optional[str], type_: Optional[Any] = float,
+                 precision: int = 10, scale: int = 2,
+                 default: Optional[Any] = None, index: Optional[bool] = None,
+                 unique: Optional[bool] = None, nullable: Optional[bool] = True, primary_key: Optional[bool] = False,
+                 comment=""):
+        if not issubclass(type_, int):
+            raise Exception("type_ must be float")
+        super().__init__(name=name, type_=type_, default=default, index=index, unique=unique, nullable=nullable,
+                         primary_key=primary_key, comment=comment)
+        self.precision = precision
+        self.scale = scale
+
+
+class Double(Decimal):
+    def __init__(self, name: Optional[str], type_: Optional[Any] = float,
+                 precision: int = 10, scale: int = 2,
+                 default: Optional[Any] = None, index: Optional[bool] = None,
+                 unique: Optional[bool] = None, nullable: Optional[bool] = True, primary_key: Optional[bool] = False,
+                 comment=""):
+        if not issubclass(type_, int):
+            raise Exception("type_ must be float")
+        super().__init__(name=name, type_=type_, default=default, index=index, unique=unique, nullable=nullable,
+                         primary_key=primary_key, comment=comment)
+        self.precision = precision
+        self.scale = scale
+
+
+class Numeric(Decimal):
+    def __init__(self, name: Optional[str], type_: Optional[Any] = _Decimal,
+                 precision: int = 10, scale: int = 2,
+                 default: Optional[Any] = None, index: Optional[bool] = None,
+                 unique: Optional[bool] = None, nullable: Optional[bool] = True, primary_key: Optional[bool] = False,
+                 comment=""):
+        if not issubclass(type_, _Decimal):
+            raise Exception("type_ must be decimal")
+        super().__init__(name=name, type_=type_, default=default, index=index, unique=unique, nullable=nullable,
+                         primary_key=primary_key, comment=comment)
+        self.precision = precision
+        self.scale = scale
+
+
+class Real(Decimal):
+    def __init__(self, name: Optional[str], type_: Optional[Any] = float,
+                 precision: int = 10, scale: int = 2,
+                 default: Optional[Any] = None, index: Optional[bool] = None,
+                 unique: Optional[bool] = None, nullable: Optional[bool] = True, primary_key: Optional[bool] = False,
+                 comment=""):
+        if not issubclass(type_, int):
+            raise Exception("type_ must be float")
+        super().__init__(name=name, type_=type_, default=default, index=index, unique=unique, nullable=nullable,
+                         primary_key=primary_key, comment=comment)
+        self.precision = precision
+        self.scale = scale
+
+
+class Date(BaseColumnType):
+    def __init__(self, name: Optional[str], type_: Optional[Any] = datetime.date,
+                 default: Optional[Any] = None, index: Optional[bool] = None,
+                 unique: Optional[bool] = None, nullable: Optional[bool] = True, primary_key: Optional[bool] = False,
+                 comment=""):
+        if not issubclass(type_, datetime.date):
+            raise Exception("type_ must be Date")
+        super().__init__(name=name, type_=type_, default=default, index=index, unique=unique, nullable=nullable,
+                         primary_key=primary_key, comment=comment)
+
+
+class DateTime(BaseColumnType):
+    def __init__(self, name: Optional[str], type_: Optional[Any] = datetime.datetime,
+                 default: Optional[Any] = None, index: Optional[bool] = None,
+                 unique: Optional[bool] = None, nullable: Optional[bool] = True, primary_key: Optional[bool] = False,
+                 comment=""):
+        if not issubclass(type_, datetime.datetime):
+            raise Exception("type_ must be DateTime")
+        super().__init__(name=name, type_=type_, default=default, index=index, unique=unique, nullable=nullable,
+                         primary_key=primary_key, comment=comment)
+
+
+class TimeStamp(BaseColumnType):
+    def __init__(self, name: Optional[str], type_: Optional[Any] = datetime.datetime,
+                 default: Optional[Any] = None, index: Optional[bool] = None,
+                 unique: Optional[bool] = None, nullable: Optional[bool] = True, primary_key: Optional[bool] = False,
+                 comment=""):
+        if not issubclass(type_, datetime.datetime):
+            raise Exception("type_ must be TimeStamp")
+        super().__init__(name=name, type_=type_, default=default, index=index, unique=unique, nullable=nullable,
+                         primary_key=primary_key, comment=comment)
+
+
+class Time(BaseColumnType):
+    def __init__(self, name: Optional[str], type_: Optional[Any] = datetime.time,
+                 default: Optional[Any] = None, index: Optional[bool] = None,
+                 unique: Optional[bool] = None, nullable: Optional[bool] = True, primary_key: Optional[bool] = False,
+                 comment=""):
+        if not issubclass(type_, datetime.time):
+            raise Exception("type_ must be Time")
+        super().__init__(name=name, type_=type_, default=default, index=index, unique=unique, nullable=nullable,
+                         primary_key=primary_key, comment=comment)
+
+
+class Year(BaseColumnType):
+    def __init__(self, name: Optional[str], type_: Optional[Any] = int,
+                 default: Optional[Any] = None, index: Optional[bool] = None,
+                 unique: Optional[bool] = None, nullable: Optional[bool] = True, primary_key: Optional[bool] = False,
+                 comment=""):
+        if not issubclass(type_, int):
+            raise Exception("type_ must be Year")
+        super().__init__(name=name, type_=type_, default=default, index=index, unique=unique, nullable=nullable,
+                         primary_key=primary_key, comment=comment)
+
+
+class Char(BaseColumnType):
+    def __init__(self, name: Optional[str], type_: Optional[Any] = str,
+                 default: Optional[Any] = None, index: Optional[bool] = None,
+                 unique: Optional[bool] = None, nullable: Optional[bool] = True, primary_key: Optional[bool] = False,
+                 comment=""):
+        if not issubclass(type_, str):
+            raise Exception("type_ must be Char")
+        super().__init__(name=name, type_=type_, default=default, index=index, unique=unique, nullable=nullable,
+                         primary_key=primary_key, comment=comment)
+
+
+class Text(BaseColumnType):
+    def __init__(self, name: Optional[str], type_: Optional[Any] = str,
+                 default: Optional[Any] = None, index: Optional[bool] = None,
+                 unique: Optional[bool] = None, nullable: Optional[bool] = True, primary_key: Optional[bool] = False,
+                 comment=""):
+        if not issubclass(type_, str):
+            raise Exception("type_ must be Text")
+        super().__init__(name=name, type_=type_, default=default, index=index, unique=unique, nullable=nullable,
+                         primary_key=primary_key, comment=comment)
+
+
+class Varchar(BaseColumnType):
+    def __init__(self, name: Optional[str], type_: Optional[Any] = str,
+                 default: Optional[Any] = None, index: Optional[bool] = None,
+                 unique: Optional[bool] = None, nullable: Optional[bool] = True, primary_key: Optional[bool] = False,
+                 comment=""):
+        if not issubclass(type_, str):
+            raise Exception("type_ must be Text")
+        super().__init__(name=name, type_=type_, default=default, index=index, unique=unique, nullable=nullable,
+                         primary_key=primary_key, comment=comment)
+
+
+class Binary(BaseColumnType):
+    def __init__(self, name: Optional[str], type_: Optional[Any] = bytes,
+                 default: Optional[Any] = None, index: Optional[bool] = None,
+                 unique: Optional[bool] = None, nullable: Optional[bool] = True, primary_key: Optional[bool] = False,
+                 comment=""):
+        if not issubclass(type_, bytes):
+            raise Exception("type_ must be Binary")
+        super().__init__(name=name, type_=type_, default=default, index=index, unique=unique, nullable=nullable,
+                         primary_key=primary_key, comment=comment)
+
+
+class Varbinary(BaseColumnType):
+    def __init__(self, name: Optional[str], type_: Optional[Any] = bytes,
+                 default: Optional[Any] = None, index: Optional[bool] = None,
+                 unique: Optional[bool] = None, nullable: Optional[bool] = True, primary_key: Optional[bool] = False,
+                 comment=""):
+        if not issubclass(type_, bytes):
+            raise Exception("type_ must be Varbinary")
+        super().__init__(name=name, type_=type_, default=default, index=index, unique=unique, nullable=nullable,
+                         primary_key=primary_key, comment=comment)
+
+
+class Bolb(BaseColumnType):
+    def __init__(self, name: Optional[str], type_: Optional[Any] = bytes,
+                 default: Optional[Any] = None, index: Optional[bool] = None,
+                 unique: Optional[bool] = None, nullable: Optional[bool] = True, primary_key: Optional[bool] = False,
+                 comment=""):
+        if not issubclass(type_, bytes):
+            raise Exception("type_ must be Bolb")
+        super().__init__(name=name, type_=type_, default=default, index=index, unique=unique, nullable=nullable,
+                         primary_key=primary_key, comment=comment)
+
+
+class Boolean(BaseColumnType):
+    def __init__(self, name: Optional[str], type_: Optional[Any] = bool,
+                 default: Optional[Any] = None, index: Optional[bool] = None,
+                 unique: Optional[bool] = None, nullable: Optional[bool] = True, primary_key: Optional[bool] = False,
+                 comment=""):
+        if not issubclass(type_, bool):
+            raise Exception("type_ must be Boolean")
+        super().__init__(name=name, type_=type_, default=default, index=index, unique=unique, nullable=nullable,
+                         primary_key=primary_key, comment=comment)
+
+
+class Bool(BaseColumnType):
+    def __init__(self, name: Optional[str], type_: Optional[Any] = bool,
+                 default: Optional[Any] = None, index: Optional[bool] = None,
+                 unique: Optional[bool] = None, nullable: Optional[bool] = True, primary_key: Optional[bool] = False,
+                 comment=""):
+        if not issubclass(type_, bool):
+            raise Exception("type_ must be Boolean")
+        super().__init__(name=name, type_=type_, default=default, index=index, unique=unique, nullable=nullable,
+                         primary_key=primary_key, comment=comment)
+
+
+class ResultColumnType:
+    def __init__(self, name: str = None, type_: Any = None, column: BaseColumnType = None, alias: str = None,
+                 value: Any = None):
+        self.name = name or alias or column.name
+        self.type_ = type_ or column.type_
+        self.column = column
+        self.alias = alias
+        self.value = value
+
+
+class ResultRow:
+    def __init__(self, **kwargs):
+        for k, v in kwargs.items():
+            setattr(self, k, v)
+
+
+class Result:
+    def __init__(self, rows: list):
+        self.rows = rows
+
+    def to(self):
+        result = []
+        for row in self.rows:
+            _d = vars(row)
+            result.append(_d)

{lesscode_database-0.0.10.dist-info → lesscode_database-0.0.12.dist-info}/METADATA

@@ -1,15 +1,19 @@
 Metadata-Version: 2.1
 Name: lesscode-database
-Version: 0.0.10
+Version: 0.0.12
 Summary: lesscode_database是数据库连接工具包
-Author: navysummer
-Author-email: navysummer@yeah.net
-Platform: python
-Classifier: Programming Language :: Python :: 3
+Author-email: navysummer <navysummer@yeah.net>
+License: MIT License
+        
+        Copyright (c) [year] [fullname]
+        
+        Permission is hereby granted...
+License-File: LICENSE
+Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.6
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.7
 Description-Content-Type: text/markdown
-License-File: LICENSE
 
 # lesscode_database
 

lesscode_database-0.0.12.dist-info/RECORD

@@ -0,0 +1,17 @@
+lesscode_database/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lesscode_database/connect_pool.py,sha256=7mj3CRFvyGeE4ymPXRYJOzRX7otbknaRRhB74yJyZDY,48182
+lesscode_database/connection_info.py,sha256=HMlA-hA0LE7jGUS8crZAgrBMB-o6B9mxrWYEywgqXHg,1307
+lesscode_database/db_options.py,sha256=Z8Iy3pqDYW5YVVfvoFSsAYecK9LfiwRasYc3fzqIBt8,1928
+lesscode_database/db_request.py,sha256=siZGXIdPuTlY4NwVLnU8098bVM_6jgQzSzeO4BzkDrA,4832
+lesscode_database/ds_helper.py,sha256=XfXkcBfRgrv0rojl_EtdWrIHNeCdZYfoD75ZJOu6tQg,8568
+lesscode_database/dynamic_import_package.py,sha256=J8hgGRHe6KrprOgOq-xbKHVAYHSjUBcNyTaSPvBmvIk,164
+lesscode_database/mongo_base_model.py,sha256=cKHNmi5GJBGRxCtqsggEcrzIZK7__Z_4cVaIHxmqZsc,6406
+lesscode_database/orm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lesscode_database/orm/orm_exec.py,sha256=B4gwULU2kbXeIhwX3HTmAPw9_rO3Z7xMGj3xXV68xiM,10885
+lesscode_database/orm/orm_func.py,sha256=-ZKO8XQQM1mUz5el-j8FkApjhI50zomg-FNfQVzwc5U,1570
+lesscode_database/orm/orm_model.py,sha256=yMt9rE9e2gYqE8Fynzk-LeaPn6-TOzLoAWmgycSz1Ow,776
+lesscode_database/orm/orm_typing.py,sha256=3roHzs4omS2XXcQ3yat0pb5otJZWiY52B9fsPlz9DDg,18568
+lesscode_database-0.0.12.dist-info/METADATA,sha256=30YBdqfdqBxYZeavLimIzGtSLm82lqRPUeOlrQfxwsc,12213
+lesscode_database-0.0.12.dist-info/WHEEL,sha256=KGYbc1zXlYddvwxnNty23BeaKzh7YuoSIvIMO4jEhvw,87
+lesscode_database-0.0.12.dist-info/licenses/LICENSE,sha256=ELM9gDFm8bfsS-M5bQfUC0jn272Riqpsso986u5PdBQ,77
+lesscode_database-0.0.12.dist-info/RECORD,,

{lesscode_database-0.0.10.dist-info → lesscode_database-0.0.12.dist-info}/WHEEL

@@ -1,5 +1,4 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.41.2)
+Generator: hatchling 1.17.1
 Root-Is-Purelib: true
 Tag: py3-none-any
-

lesscode_database-0.0.12.dist-info/licenses/LICENSE

@@ -0,0 +1,5 @@
+MIT License
+
+Copyright (c) [year] [fullname]
+
+Permission is hereby granted...

lesscode_database/version.py

@@ -1 +0,0 @@
-__version__ = "0.0.10"

lesscode_database-0.0.10.dist-info/LICENSE

@@ -1,201 +0,0 @@
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.

lesscode_database-0.0.10.dist-info/RECORD

@@ -1,14 +0,0 @@
-lesscode_database/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lesscode_database/connect_pool.py,sha256=6iFUU8w4sNs2HgGiH5M0PZI7wuEUnlNgzx-hT65USyo,46467
-lesscode_database/connection_info.py,sha256=HMlA-hA0LE7jGUS8crZAgrBMB-o6B9mxrWYEywgqXHg,1307
-lesscode_database/db_options.py,sha256=Z8Iy3pqDYW5YVVfvoFSsAYecK9LfiwRasYc3fzqIBt8,1928
-lesscode_database/db_request.py,sha256=siZGXIdPuTlY4NwVLnU8098bVM_6jgQzSzeO4BzkDrA,4832
-lesscode_database/ds_helper.py,sha256=W3VrTe_l0mGX0uEbN7UI6NlQbruLpr2WXgO7AexzQ-k,4845
-lesscode_database/dynamic_import_package.py,sha256=J8hgGRHe6KrprOgOq-xbKHVAYHSjUBcNyTaSPvBmvIk,164
-lesscode_database/mongo_base_model.py,sha256=cKHNmi5GJBGRxCtqsggEcrzIZK7__Z_4cVaIHxmqZsc,6406
-lesscode_database/version.py,sha256=-nNlMKS9nph3FR78_ZG9RGKrbxseeNp2K6nMr0pVGaU,23
-lesscode_database-0.0.10.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-lesscode_database-0.0.10.dist-info/METADATA,sha256=w3pRRvHPOi0bcIoGKVKlmNKtVIWpYFyrIXflWvEL5Ns,12066
-lesscode_database-0.0.10.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
-lesscode_database-0.0.10.dist-info/top_level.txt,sha256=h6cg13be6kkDfNaX9nWeDcfducTb5bKG5iYRO2JPmAM,18
-lesscode_database-0.0.10.dist-info/RECORD,,

lesscode_database-0.0.10.dist-info/top_level.txt

@@ -1 +0,0 @@
-lesscode_database