gomyck-tools 1.0.0__tar.gz → 1.0.2__tar.gz

{gomyck-tools-1.0.0 → gomyck-tools-1.0.2}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: gomyck-tools
-Version: 1.0.0
-Summary: A ctools for python development
+Version: 1.0.2
+Summary: A ctools for python development by hao474798383
 Home-page: https://blog.gomyck.com
 Author: gomyck
 Author-email: hao474798383@163.com

gomyck-tools-1.0.2/ctools/api_result.py

@@ -0,0 +1,51 @@
+from ctools import cjson
+
+cjson.str_value_keys = [
+  "obj_id",
+  "script_id",
+  "template_id"
+]
+
+
+class _ResEnum(object):
+  def __init__(self, code: int, message: str):
+    self.code = code
+    self.message = message
+
+  def __eq__(self, o: object) -> bool:
+    return self.code == o
+
+class R(object):
+  class Code:
+
+    @staticmethod
+    def cus_code(code, msg):
+      return _ResEnum(code, msg)
+
+    SUCCESS = _ResEnum(200, "成功")
+    FAIL    = _ResEnum(400, "失败")
+    ERROR   = _ResEnum(500, "异常")
+
+  def __init__(self, code: int, message: str, data=""):
+    self.code = code
+    self.message = message
+    self.data = data
+
+  def _to_json(self):
+    return cjson.unify_to_str(cjson.dumps(self))
+
+  @staticmethod
+  def parser(r_json: str):
+    return R(**cjson.loads(r_json))
+
+  @staticmethod
+  def ok(data=None, resp=Code.SUCCESS, msg=None):
+    return R(resp.code, msg if msg is not None else resp.message, data)._to_json()
+
+  @staticmethod
+  def fail(msg=None, resp=Code.FAIL, data=None):
+    return R(resp.code, msg if msg is not None else resp.message, data)._to_json()
+
+  @staticmethod
+  def error(msg=None, resp=Code.ERROR, data=None):
+    return R(resp.code, msg if msg is not None else resp.message, data)._to_json()

{gomyck-tools-1.0.0 → gomyck-tools-1.0.2}/ctools/bottle_server.py

@@ -4,6 +4,39 @@ from wsgiref.simple_server import WSGIServer, WSGIRequestHandler, make_server
 from geventwebsocket.handler import WebSocketHandler
 from ctools import sys_log
 
+"""
+app = init_app('/doc_download')
+
+@app.get('/queryList')
+@mvc.parameter_handler()
+@rule('DOC:DOWNLOAD')
+def query_list(params, pageInfo):
+"""
+
+"""
+module_names = list(globals().keys())
+def get_modules():
+  mods = []
+  for modname in module_names:
+    if modname == 'base' or modname == 'online' or modname.startswith('__') or modname == 'importlib': continue
+    module = globals()[modname]
+    mods.append(module)
+  return mods
+
+def get_ws_modules():
+  from . import websocket
+  return [websocket]
+"""
+
+"""
+http_app = Bottle()
+for module in controller.get_modules():
+  log.debug('正在挂载http路由: {}'.format(module.app.context_path))
+  http_app.mount(module.app.context_path, module.app)
+http_server = bottle_server.WSGIRefServer(port=application.Server.port)
+http_app.run(server=http_server, quiet=True)
+"""
+
 class ThreadedWSGIServer(ThreadingMixIn, WSGIServer): pass
 
 class CustomWSGIHandler(WSGIRequestHandler):
@@ -36,7 +69,7 @@ class WSGIRefServer(ServerAdapter):
 
 class WebSocketServer(ServerAdapter):
 
-  def __init__(self, host='0.0.0.0', port=8012):
+  def __init__(self, host='0.0.0.0', port=8011):
     super().__init__(host, port)
     self.server = None
 

{gomyck-tools-1.0.0 → gomyck-tools-1.0.2}/ctools/call.py

@@ -3,7 +3,7 @@ import threading
 import time
 from functools import wraps
 
-
+# annotation
 def once(func):
   """
   decorator to initialize a function once
@@ -24,7 +24,7 @@ def once(func):
 
   return wrapper
 
-
+# annotation
 def init(func):
   """
   decorator to initialize a function automic
@@ -38,7 +38,7 @@ def init(func):
 
   return wrapper
 
-
+# annotation
 def schd(interval_seconds, start_by_call: bool = False):
   start_flag = False
   run_flag = False

{gomyck-tools-1.0.0 → gomyck-tools-1.0.2}/ctools/cjson.py

@@ -1,10 +1,11 @@
 import jsonpickle
 
+# 需要转换成str的属性
+str_value_keys = []
 jsonpickle.set_preferred_backend('json')
 jsonpickle.set_encoder_options('json', ensure_ascii=False)
 jsonpickle.set_decoder_options('json', encoding='utf-8')
 
-
 def dumps(obj) -> str:
   """
   将对象转换为json字符串
@@ -12,9 +13,9 @@ def dumps(obj) -> str:
   :return: json 字符串
   """
   if obj is None: return None
+  if type(obj) == str: return obj
   return f'{jsonpickle.encode(obj, unpicklable=False)}'
 
-
 def loads(json_str: str) -> dict:
   """
   将json字符串转换为对象
@@ -23,11 +24,6 @@ def loads(json_str: str) -> dict:
   """
   return jsonpickle.decode(json_str)
 
-
-# 需要转换成str的属性
-str_value_keys = []
-
-
 def unify_to_str(json_str: str) -> str:
   if not str_value_keys: return json_str
   obj = loads(json_str)
@@ -37,7 +33,6 @@ def unify_to_str(json_str: str) -> str:
     _handle_dict(obj)
   return dumps(obj)
 
-
 def _handle_list(data):
   for o in data:
     if isinstance(o, list):
@@ -45,7 +40,6 @@ def _handle_list(data):
     elif isinstance(o, dict):
       _handle_dict(o)
 
-
 def _handle_dict(data):
   for k, v in data.items():
     if isinstance(v, list):

gomyck-tools-1.0.2/ctools/ckafka.py

@@ -0,0 +1,152 @@
+#!/usr/bin/env python
+# -*- coding: UTF-8 -*-
+__author__ = 'haoyang'
+__date__ = '2024/9/5 10:39'
+
+import signal
+import sys
+import time
+from threading import Thread, Lock
+
+from kafka import KafkaProducer, errors, KafkaConsumer
+from kafka.producer.future import FutureRecordMetadata
+
+from ctools import thread_pool
+from ctools.cjson import dumps
+
+"""
+import time
+
+from ctools import thread_pool
+from ctools.ckafka import CKafka
+
+c = CKafka(kafka_url='192.168.3.160:9094', secure=True)
+
+def send_msg():
+  while True:
+    time.sleep(3)
+    c.send_msg('test', 'test')
+
+thread_pool.submit(send_msg)
+c.get_msg('test')
+"""
+
+class CKafka:
+
+  def __init__(self, kafka_url: str = '127.0.0.1:9092', secure: bool = False, username: str = 'client', password: str = 'hylink_user_password', consumer_group: str = 'ck-py-kafka-consumer'):
+    self.consumer: KafkaConsumer = None
+    self.producer: KafkaProducer = None
+    self.start_consumer = False
+    self.consumer_callback = {"topic_key": []}
+    self.consumer_group = consumer_group
+    self.kafka_url = kafka_url
+    self.init_producer = False
+    self.init_consumer = False
+    self.secure = secure
+    self.username = username
+    self.password = password
+    self.locker = Lock()
+    self.quited = False
+
+  def _create_producer(self) -> KafkaProducer:
+    print("[ Producer ] Connecting to Kafka brokers")
+    for i in range(0, 6):
+      try:
+        if self.secure:
+          self.producer = KafkaProducer(
+            bootstrap_servers=self.kafka_url,
+            sasl_plain_username=self.username,
+            sasl_plain_password=self.password,
+            security_protocol='SASL_PLAINTEXT',
+            sasl_mechanism='PLAIN',
+            value_serializer=lambda x: dumps(x).encode('utf-8'))
+        else:
+          self.producer = KafkaProducer(
+            bootstrap_servers=self.kafka_url,
+            value_serializer=lambda x: dumps(x).encode('utf-8'))
+        print("[ Producer ] Connected to Kafka...")
+        self.init_producer = True
+        return self.producer
+      except errors.NoBrokersAvailable:
+        print("[ Producer ] Waiting for brokers to become available...")
+        time.sleep(3)
+    raise RuntimeError("[ Producer ] Failed to connect to brokers within 60 seconds")
+
+  def _create_consumer(self) -> KafkaProducer:
+    print("[ Consumer ] Connecting to Kafka brokers")
+    for i in range(0, 6):
+      try:
+        if self.secure:
+          self.consumer = KafkaConsumer(
+            group_id=self.consumer_group,
+            bootstrap_servers=self.kafka_url,
+            sasl_plain_username=self.username,
+            sasl_plain_password=self.password,
+            security_protocol='SASL_PLAINTEXT',
+            sasl_mechanism='PLAIN',
+            value_deserializer=lambda x: x.decode('utf-8'))
+        else:
+          self.consumer = KafkaProducer(
+            bootstrap_servers=self.kafka_url,
+            value_deserializer=lambda x: x.decode('utf-8'))
+        print("[ Consumer ] Connected to Kafka...")
+        self.init_consumer = True
+        return self.consumer
+      except errors.NoBrokersAvailable:
+        print("[ Consumer ] Waiting for brokers to become available...")
+        time.sleep(3)
+    raise RuntimeError("[ Consumer ] Failed to connect to brokers within 60 seconds")
+
+  # FutureRecordMetadata 可以添加回调, 来监听是否发送成功
+  # r.add_callback(lambda x: print(x))
+  # r.get() 可以同步获取结果
+  def send_msg(self, topic, msg, key: str=None, partition:int=None) -> FutureRecordMetadata:
+    if self.quited: return None
+    if not self.init_producer:
+      with self.locker:
+        if not self.init_producer:
+          self._create_producer()
+    return self.producer.send(topic=topic, value=msg, key=None if key is None else key.encode('utf-8'), partition=partition)
+
+  def get_msg(self, topics: str, callBack=print):
+    if not self.init_consumer:
+      with self.locker:
+        if not self.init_consumer:
+          self._create_consumer()
+    for topic in topics.split(','):
+      if topic not in self.consumer_callback.keys():
+        self.consumer_callback[topic] = []
+        self.consumer.subscribe(self.consumer_callback.keys())
+      self.consumer_callback[topic].append(callBack)
+    if not self.start_consumer:
+      t = Thread(target=self._start_consumer_poll)
+      t.start()
+
+  def _start_consumer_poll(self):
+    self.start_consumer = True
+    for msg in self.consumer:
+      if self.quited: break
+      taskList = []
+      funcList = []
+      begin_time = time.time()
+      for func in self.consumer_callback[msg.topic]:
+        if self.quited: break
+        f = thread_pool.submit(func, (msg, ))
+        taskList.append(f)
+        funcList.append(func.__name__)
+      for f in taskList:
+        if self.quited: break
+        f.result()
+      end_time = time.time()
+      if end_time - begin_time > 1: print(f"kafka consume too slow!!! {funcList} time cost: ", f'{round(end_time - begin_time, 2)}s')
+      taskList.clear()
+      funcList.clear()
+
+  def shutdown(self):
+    self.quited = True
+    try: self.consumer.close()
+    except Exception: pass
+    try: self.producer.close()
+    except Exception: pass
+    thread_pool.shutdown(wait=True)
+

{gomyck-tools-1.0.0 → gomyck-tools-1.0.2}/ctools/cron_lite.py

@@ -7,10 +7,26 @@ import traceback
 from datetime import datetime
 from functools import wraps
 from typing import Optional, Dict
-
 import pytz
 from croniter import croniter
 
+"""
+@cron_lite.cron_task('0/1 * * * * ? *')
+def demo():
+  print('hello world')
+
+@cron_lite.cron_task('0/1 * * * * ? *')
+def demo1():
+  print('hello world111')
+
+def demo2(xx, fff):
+  print('hello world222', xx, fff)
+
+cron_lite.apply_cron_task('0/1 * * * * ? *', demo2, (123123123, 34534534))
+print(123123)
+
+cron_lite.start_all()
+"""
 
 class SchedulerMeta:
   timer_task_name: str = None
@@ -22,8 +38,8 @@ class SchedulerMeta:
 
 scheduler_map: Dict[str, SchedulerMeta] = {}  # {timer_task_name: SchedulerMeta}
 _switch = False
+_info_handler  = print
 _error_handler = print
-_info_handler = print
 _time_zone: Optional[pytz.BaseTzInfo] = None
 
 
@@ -31,75 +47,8 @@ def set_time_zone(time_zone_name: str):
   global _time_zone
   _time_zone = pytz.timezone(time_zone_name)
 
-
-def _register_next(timer_task_name, base_func, cron_expr, till_time_stamp):
-  cron_obj = croniter(cron_expr)
-  if _time_zone:
-    cron_obj.set_current(datetime.now(tz=_time_zone))
-  next_time = int(cron_obj.get_next())
-  if scheduler_map.get(timer_task_name) is None:
-    scheduler_meta = SchedulerMeta()
-    scheduler_meta.timer_task_name = timer_task_name
-    scheduler_meta.switch = True
-    scheduler_meta.scheduler = sched.scheduler(time.time, time.sleep)
-    scheduler_map[timer_task_name] = scheduler_meta
-  if till_time_stamp is None or next_time <= till_time_stamp:
-    scheduler_map[timer_task_name].event = scheduler_map[timer_task_name].scheduler.enterabs(next_time, 0, base_func)
-
-
-def _run_sched(scheduler_meta: SchedulerMeta):
-  active(scheduler_meta.timer_task_name)
-  while True:
-    scheduler = scheduler_meta.scheduler
-    if not _switch or not scheduler_meta.switch:
-      scheduler.empty()
-      inactive(scheduler_meta.timer_task_name)
-      return
-    t = scheduler.run(False)
-    if t is None:
-      inactive(scheduler_meta.timer_task_name)
-      return
-    st = time.time()
-    while time.time() - st < t:
-      if not _switch or not scheduler_meta.switch:
-        scheduler.empty()
-        inactive(scheduler_meta.timer_task_name)
-        return
-      time.sleep(0.5)
-
-
-def _start():
-  global _switch
-  _info_handler("cron started")
-  tl = []
-  for timer_task_name, scheduler_meta in scheduler_map.items():
-    print("Registering Job:", timer_task_name)
-    t = threading.Thread(target=_run_sched, args=(scheduler_meta,), daemon=True)
-    # 有些task非常耗时，会影响退出。目前设计改为退出时不保证task完成
-    t.start()
-    tl.append(t)
-
-  for t in tl:
-    t.join()
-  _info_handler("cron finished")
-  _switch = False  # ensure close when there are no more tasks with switch open
-  scheduler_map.clear()
-
-
-def convert_cron(cron_expr):
-  res_cron = ""
-  cron_list = cron_expr.split(" ")
-  if len(cron_list) > 6:
-    for cron in cron_list[1:]:
-      if cron != "?":
-        res_cron += "%s " % cron
-    res_cron += "%s" % cron_list[0]
-  else:
-    res_cron = cron_expr
-  return res_cron
-
-
-def cron_task(cron_expr: str, till_time_stamp: int = None):
+# @annotation
+def cron_task(cron_expr: str, task_name: str = None, till_time_stamp: int = None):
   """
   cron_task decorator to register a function as crontab task
   :param cron_expr: the croniter accepted cron_expression. NOTICE: the default timezone is UTC and can be changed by
@@ -107,7 +56,7 @@ def cron_task(cron_expr: str, till_time_stamp: int = None):
   :param till_time_stamp: run this jog till when. None means forever
   :return: the real decorator
   """
-  cron_expr = convert_cron(cron_expr)
+  cron_expr = _convert_cron(cron_expr)
   assert len(cron_expr.split(" ")) in (5, 6), \
     "only supported <min hour day month weekday> and <min hour day month weekday sec>"
 
@@ -121,15 +70,15 @@ def cron_task(cron_expr: str, till_time_stamp: int = None):
           _error_handler(f"run {func.__name__} failed\n" + traceback.format_exc())
         except Exception:
           _error_handler(f"run {func.__name__} failed\n")
-      _register_next(inner, inner, cron_expr, till_time_stamp)
+      _register_next(inner.__name__ if task_name is None else task_name, inner, cron_expr, till_time_stamp)
 
-    _register_next(inner, inner, cron_expr, till_time_stamp)
+    _register_next(inner.__name__ if task_name is None else task_name, inner, cron_expr, till_time_stamp, init=True)
     return inner
 
   return deco
 
 
-def apply_cron_task(timer_task_name, func, params, cron_expr, till_time_stamp=None):
+def apply_cron_task(cron_expr, func, params, timer_task_name=None, till_time_stamp=None):
   """
   cron_task decorator to register a function as crontab task
   :param func: task callback function
@@ -140,37 +89,32 @@ def apply_cron_task(timer_task_name, func, params, cron_expr, till_time_stamp=No
   :param till_time_stamp: run this jog till when. None means forever
   :return: the real decorator
   """
-  cron_expr = convert_cron(cron_expr)
-  assert len(cron_expr.split(" ")) in (5, 6), \
-    "Only supported <minute hour day month weekday> and <minute hour day month weekday second>"
-
+  cron_expr = _convert_cron(cron_expr)
+  assert len(cron_expr.split(" ")) in (5, 6),  "Only supported <minute hour day month weekday> and <minute hour day month weekday second>"
+  task_name = func.__name__ if timer_task_name is None else timer_task_name
   @wraps(func)
   def wrapper(*args, **kwargs):
     try:
-      func(timer_task_name, params, *args, **kwargs)
+      nonlocal params
+      func.__taskName__ = task_name
+      func(*params, *args, **kwargs)
     except Exception as exc:
       _error_handler(f"Run {func.__name__} failed with error: {str(exc)}")
     finally:
-      _register_next(timer_task_name, wrapper, cron_expr, till_time_stamp)
+      _register_next(task_name, wrapper, cron_expr, till_time_stamp)
 
-  _register_next(timer_task_name, wrapper, cron_expr, till_time_stamp)
+  _register_next(task_name, wrapper, cron_expr, till_time_stamp, init=True)
+  # 不使用 submit, 因为提交的任务, 不是 daemon 线程
+  t = threading.Thread(target=_start, args=(timer_task_name, ))
+  t.setDaemon(True)
+  t.start()
+  return t
 
-  global _switch
-  _switch = True
-
-  scheduler = scheduler_map.get(timer_task_name)
-  if scheduler:
-    scheduler.switch = True
-    t = threading.Thread(target=_run_sched, name=timer_task_name, args=(scheduler,), daemon=True)
-    # 有些task非常耗时，会影响退出。目前设计改为退出时不保证task完成
-    t.start()
-  return wrapper
-
-
-def start_all(spawn: bool = True, info_handler=None, error_handler=None) -> Optional[threading.Thread]:
+def start_all(spawn: bool = True, daemon: bool = True, info_handler=None, error_handler=None) -> Optional[threading.Thread]:
   """
   start_all starts all cron tasks registered before.
   :param spawn: whether to start a new thread for scheduler. If not, the action will block the current thread
+  :param daemon: the new thread is daemon if True
   :param info_handler: handle info output (scheduler start / stop), default = print, can use logging.info
   :param error_handler: handle error output (task execute exception), default = print, can use logging.error
   :raise RuntimeError: if the tasks are already started and still running we cannot start again. The feature is not
@@ -179,16 +123,14 @@ def start_all(spawn: bool = True, info_handler=None, error_handler=None) -> Opti
   """
   global _switch, _info_handler, _error_handler
   if _switch:
-    raise RuntimeError("the crontab was already started")
+    raise RuntimeError("the crontab was already started...")
   if info_handler:
     _info_handler = info_handler
   if error_handler:
     _error_handler = error_handler
-
-  _switch = True
   if spawn:
     t = threading.Thread(target=_start)
-    t.setDaemon(True)
+    t.setDaemon(daemon)
     t.start()
     return t
   else:
@@ -237,3 +179,73 @@ def stop_all(wait_thread: Optional[threading.Thread] = None):
     scheduler_map.get(timer_task_name).switch = False
   if wait_thread:
     wait_thread.join()
+
+
+def _register_next(timer_task_name, base_func, cron_expr, till_time_stamp, init: bool = False):
+  cron_obj = croniter(cron_expr)
+  if _time_zone:
+    cron_obj.set_current(datetime.now(tz=_time_zone))
+  next_time = int(cron_obj.get_next())
+  if scheduler_map.get(timer_task_name) is None:
+    scheduler_meta = SchedulerMeta()
+    scheduler_meta.timer_task_name = timer_task_name
+    scheduler_meta.switch = True
+    scheduler_meta.scheduler = sched.scheduler(time.time, time.sleep)
+    scheduler_map[timer_task_name] = scheduler_meta
+  elif init:
+    raise ValueError(f"task name: {timer_task_name} already exists!!!!!")
+  if till_time_stamp is None or next_time <= till_time_stamp:
+    scheduler_map[timer_task_name].event = scheduler_map[timer_task_name].scheduler.enterabs(next_time, 0, base_func)
+
+
+def _run_sched(scheduler_meta: SchedulerMeta):
+  active(scheduler_meta.timer_task_name)
+  while True:
+    scheduler = scheduler_meta.scheduler
+    if not _switch or not scheduler_meta.switch:
+      scheduler.empty()
+      inactive(scheduler_meta.timer_task_name)
+      return
+    t = scheduler.run(False)
+    if t is None:
+      inactive(scheduler_meta.timer_task_name)
+      return
+    st = time.time()
+    while time.time() - st < t:
+      if not _switch or not scheduler_meta.switch:
+        scheduler.empty()
+        inactive(scheduler_meta.timer_task_name)
+        return
+      time.sleep(0.5)
+
+
+def _start(taskName: str = None):
+  global _switch
+  _switch = True
+  _info_handler("cron job begin start...")
+  taskList = []
+  for timer_task_name, scheduler_meta in scheduler_map.items():
+    if taskName is not None and timer_task_name != taskName: continue
+    print("register job: ", timer_task_name)
+    thread = threading.Thread(target=_run_sched, args=(scheduler_meta, ))
+    thread.setDaemon(True)
+    thread.start()
+    taskList.append(thread)
+  for task in taskList: task.join()
+  _info_handler("cron job execute finished...")
+  _switch = False
+  scheduler_map.clear()
+
+
+def _convert_cron(cron_expr):
+  res_cron = ""
+  cron_list = cron_expr.split(" ")
+  if len(cron_list) > 6:
+    for cron in cron_list[1:]:
+      if cron != "?":
+        res_cron += "%s " % cron
+    res_cron += "%s" % cron_list[0]
+  else:
+    res_cron = cron_expr
+  return res_cron
+

{gomyck-tools-1.0.0 → gomyck-tools-1.0.2}/ctools/database.py

@@ -8,6 +8,13 @@ from sqlalchemy.sql import text
 from ctools import call, string_tools
 from ctools.thread_pool import thread_local
 
+"""
+database.init_db('postgresql://postgres:123456@192.168.3.107:32566/abc', default_schema='public', db_key='source', pool_size=100)
+with database.get_session('source') as s:
+  s.execute(text('insert into xxx (name) values (:name)'), {'name': string_tools.get_random_str(5)})
+  s.commit()
+"""
+
 Base = None
 inited_db = {}
 engines = {}
@@ -21,11 +28,8 @@ def _init():
   global Base
   Base = declarative_base()
 
-def set_search_path(dbapi_connection, default_schema):
-  with dbapi_connection.cursor() as cursor:
-    cursor.execute(f'SET search_path TO {default_schema}')
-
 # 密码里的@  要替换成 %40
+# sqlite connect_args={"check_same_thread": False}  sqlite:///{}.format(db_url)
 def init_db(db_url: str, db_key: str='default', connect_args: dict={}, default_schema: str=None, pool_size: int=5, max_overflow: int=25, echo: bool=False):
   if inited_db.get(db_key): raise Exception('db {} already init!!!'.format(db_key))
   global engines, sessionMakers
@@ -33,7 +37,11 @@ def init_db(db_url: str, db_key: str='default', connect_args: dict={}, default_s
   engines[db_key] = engine
   sessionMakers[db_key] = sessionMaker
   inited_db[db_key] = True
-  if default_schema: event.listen(engine, 'connect', lambda dbapi_connection, connection_record: set_search_path(dbapi_connection, default_schema))
+  if default_schema: event.listen(engine, 'connect', lambda dbapi_connection, connection_record: _set_search_path(dbapi_connection, default_schema))
+
+def _set_search_path(dbapi_connection, default_schema):
+  with dbapi_connection.cursor() as cursor:
+    cursor.execute(f'SET search_path TO {default_schema}')
 
 def _create_connection(db_url: str, pool_size: int=5, max_overflow: int=25, connect_args={}, echo: bool=False):
   engine = create_engine('{}'.format(db_url),