gomyck-tools 1.0.0__py3-none-any.whl → 1.4.7__py3-none-any.whl

ctools/web/aio_web_server.py

@@ -0,0 +1,186 @@
+#!/usr/bin/env python
+# -*- coding: UTF-8 -*-
+"""A lightweight async HTTP server based on aiohttp."""
+
+__author__ = 'haoyang'
+__date__ = '2025/5/30 09:54'
+
+import asyncio
+import sys
+from pathlib import Path
+from typing import Optional, Dict, Any
+
+from aiohttp import web
+from ctools import sys_info, cjson
+from ctools.sys_log import flog as log
+from ctools.web.api_result import R
+
+DEFAULT_PORT = 8888
+
+@web.middleware
+async def response_wrapper_middleware(request, handler):
+  try:
+    result = await handler(request)
+    if isinstance(result, web.Response):
+      return result
+    elif isinstance(result, str):
+      return web.Response(text=result, content_type='application/json')
+    elif isinstance(result, dict):
+      return web.Response(text=cjson.dumps(result), content_type='application/json')
+    else:
+      return result
+  except web.HTTPException as http_exc:
+    raise http_exc
+  except Exception as e:
+    log.error(f"Error in response_wrapper_middleware: {e}", exc_info=True)
+    return web.json_response(text=R.error(str(e)), status=500, content_type='application/json')
+
+
+class AioHttpServer:
+  def __init__(self, port: int = DEFAULT_PORT, app: Optional[web.Application] = None, routes: Optional[web.RouteTableDef] = None, async_func=None):
+    """
+    Initialize the HTTP server.
+
+    Args:
+        port: Port number to listen on
+        app: Optional existing aiohttp Application instance
+    """
+    self.app = app or web.Application(middlewares=[response_wrapper_middleware])
+    self.port = port
+    self.index_root = Path('./')
+    self.index_filename = 'index.html'
+    self.is_tpl = False
+    self.template_args: Dict[str, Any] = {}
+    self.redirect_url: Optional[str] = None
+    self.static_root = Path('./static')
+    self.download_root = Path('./download')
+    self.routes = routes
+    self.async_func = async_func
+
+    # Register routes
+    self.app.add_routes([
+      web.get('/', self.handle_index),
+      web.get('/index', self.handle_index),
+      web.get('/static/{filepath:.*}', self.handle_static),
+      web.get('/download/{filepath:.*}', self.handle_download)
+    ])
+    if self.routes:
+      self.app.add_routes(self.routes)
+
+  async def handle_index(self, request: web.Request) -> web.StreamResponse:
+    """Handle requests to the index page."""
+    if self.redirect_url:
+      return web.HTTPFound(self.redirect_url)
+
+    index_path = self.index_root / self.index_filename
+
+    if not index_path.exists():
+      return web.HTTPNotFound()
+
+    if self.is_tpl:
+      return web.FileResponse(
+        index_path,
+        headers={'Content-Type': 'text/html'}
+      )
+    return web.FileResponse(index_path)
+
+  async def handle_static(self, request: web.Request) -> web.StreamResponse:
+    """Handle static file requests."""
+    filepath = Path(request.match_info['filepath'])
+    full_path = self.static_root / filepath
+
+    if not full_path.exists():
+      return web.HTTPNotFound()
+
+    return web.FileResponse(full_path)
+
+  async def handle_download(self, request: web.Request) -> web.StreamResponse:
+    """Handle file download requests."""
+    filepath = Path(request.match_info['filepath'])
+    full_path = self.download_root / filepath
+
+    if not full_path.exists():
+      return web.HTTPNotFound()
+
+    return web.FileResponse(
+      full_path,
+      headers={'Content-Disposition': f'attachment; filename="{filepath.name}"'}
+    )
+
+  def set_index(
+    self,
+    filename: str = 'index.html',
+    root: str = './',
+    is_tpl: bool = False,
+    redirect_url: Optional[str] = None,
+    **kwargs: Any
+  ) -> None:
+    """
+    Configure index page settings.
+
+    Args:
+        filename: Name of the index file
+        root: Root directory for index file
+        is_tpl: Whether the file is a template
+        redirect_url: URL to redirect to instead of serving index
+        kwargs: Additional template arguments
+    """
+    self.index_root = Path(root)
+    self.index_filename = filename
+    self.is_tpl = is_tpl
+    self.redirect_url = redirect_url
+    self.template_args = kwargs
+
+  def set_static(self, root: str = './static') -> None:
+    """Set the root directory for static files."""
+    self.static_root = Path(root)
+
+  def set_download(self, root: str = './download') -> None:
+    """Set the root directory for downloadable files."""
+    self.download_root = Path(root)
+
+  async def run(self) -> None:
+    """Run the server."""
+    if self.async_func:
+      await self.async_func()
+
+    print(
+      'Server running at:\n'
+      f'\tLocal: http://localhost:{self.port}\n'
+      f'\tNetwork: http://{sys_info.get_local_ipv4()}:{self.port}',
+      file=sys.stderr
+    )
+    runner = None
+    try:
+      runner = web.AppRunner(self.app)
+      await runner.setup()
+      site = web.TCPSite(runner, host='0.0.0.0', port=self.port)
+      await site.start()
+      while True: await asyncio.sleep(3600)
+    except Exception as e:
+      print(f"Server failed to start: {e}", file=sys.stderr)
+    finally:
+      await runner.cleanup()
+
+
+def init_routes() -> web.RouteTableDef:
+  return web.RouteTableDef()
+
+
+def init_server(routes: Optional[web.RouteTableDef] = None, app: Optional[web.Application] = None, port: int = DEFAULT_PORT, async_func=None) -> AioHttpServer:
+  """Initialize and return a new AioHttpServer instance."""
+  return AioHttpServer(port=port, app=app, routes=routes, async_func=async_func)
+
+
+async def get_stream_resp(request, content_type: str = 'text/event-stream') -> web.StreamResponse:
+  resp = web.StreamResponse(
+    status=200,
+    reason='OK',
+    headers={
+      'Content-Type': content_type,
+      'Cache-Control': 'no-cache',
+      'X-Accel-Buffering': 'no',
+    }
+  )
+  await resp.prepare(request)
+  return resp

ctools/web/api_result.py

@@ -0,0 +1,56 @@
+from ctools import cjson
+
+cjson.str_value_keys = [
+  "obj_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_str(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, to_json_str=True):
+    if not to_json_str:
+      return R(resp.code, msg if msg is not None else resp.message, data)
+    return R(resp.code, msg if msg is not None else resp.message, data)._to_json_str()
+
+  @staticmethod
+  def fail(msg=None, resp=Code.FAIL, data=None, to_json_str=True):
+    if not to_json_str:
+      return R(resp.code, msg if msg is not None else resp.message, data)
+    return R(resp.code, msg if msg is not None else resp.message, data)._to_json_str()
+
+  @staticmethod
+  def error(msg=None, resp=Code.ERROR, data=None, to_json_str=True):
+    if not to_json_str:
+      return R(resp.code, msg if msg is not None else resp.message, data)
+    return R(resp.code, msg if msg is not None else resp.message, data)._to_json_str()

ctools/web/bottle_web_base.py

@@ -0,0 +1,239 @@
+import inspect
+import threading
+from functools import wraps
+
+import bottle
+from bottle import response, Bottle, request
+
+from ctools import call
+from ctools.dict_wrapper import DictWrapper
+from ctools.sys_log import flog as log
+from ctools.util.cklock import try_lock
+from ctools.web import ctoken
+from ctools.web.api_result import R
+
+bottle.BaseRequest.MEMFILE_MAX = 1024 * 1024 * 50
+func_has_params = {}
+app_cache = {}
+
+class GlobalState:
+  lock = threading.Lock()
+  withOutLoginURI = {
+    '/',
+    '/index',
+    '/login',
+    '/favicon.ico',
+    '/static/',
+  }
+  allowRemoteCallURI = set()
+  auth_ignore_func = set()
+  token = {}
+  interceptors = []
+
+def join_path(*parts):
+  """拼接 url"""
+  cleaned_parts = [p.strip('/') for p in parts if p and p.strip('/')]
+  return '/' + '/'.join(cleaned_parts)
+
+@call.once
+def cache_white_list(app):
+  """缓存白名单"""
+  for route in app.routes:
+    real_func = route.config.get('mountpoint.target')
+    if not real_func: continue
+    for method, routes in real_func.router.static.items():
+      for path, tuples in routes.items():
+        req_func = inspect.getmodule(tuples[0].callback).__name__ + "." + tuples[0].callback.__name__
+        if req_func in GlobalState.auth_ignore_func:
+          print("add white list: {}".format(route.rule))
+          GlobalState.withOutLoginURI.add(join_path(app.context_path, real_func.context_path, path))
+
+def init_app(context_path="/", main_app=False):
+  with try_lock(block=True):
+    cache_app = app_cache.get(context_path)
+    if cache_app: return cache_app
+    app = Bottle()
+    app_cache[context_path] = app
+    app.context_path = context_path if context_path else "/"
+
+  def init_main_app():
+    @app.hook('before_request')
+    def before_request():
+      for v in GlobalState.withOutLoginURI:
+        if v.endswith('/'):
+          if request.path.startswith(v): return
+        else:
+          if v in request.path: return
+      for interceptor in GlobalState.interceptors:
+        res: R = interceptor['func']()
+        if res.code != 200: bottle.abort(res.code, res.message)
+
+    @app.error(401)
+    def unauthorized(error):
+      response.status = 401
+      log.error("系统未授权: {} {} {}".format(error.body, request.method, request.fullpath))
+      return R.error(resp=R.Code.cus_code(401, "系统未授权! {}".format(error.body)))
+
+    @app.error(403)
+    def unauthorized(error):
+      response.status = 403
+      log.error("访问受限: {} {} {}".format(error.body, request.method, request.fullpath))
+      return R.error(resp=R.Code.cus_code(403, "访问受限: {}".format(error.body)))
+
+    @app.error(404)
+    def not_found(error):
+      response.status = 404
+      log.error("404 not found : {} {} {}".format(error.body, request.method, request.fullpath))
+      return R.error(resp=R.Code.cus_code(404, "资源未找到: {}".format(error.body)))
+
+    @app.error(405)
+    def method_not_allow(error):
+      response.status = 405
+      log.error("请求方法错误: {} {} {}".format(error.status_line, request.method, request.fullpath))
+      return R.error(resp=R.Code.cus_code(405, '请求方法错误: {}'.format(error.status_line)))
+
+    @app.error(500)
+    def internal_error(error):
+      response.status = 500
+      log.error("系统发生错误: {} {} {}".format(error.body, request.method, request.fullpath))
+      return R.error(msg='系统发生错误: {}'.format(error.exception))
+
+    @app.hook('after_request')
+    def after_request():
+      enable_cors()
+
+  if main_app: init_main_app()
+  app.install(params_resolve)
+  return app
+
+
+def enable_cors():
+  response.headers['Access-Control-Allow-Origin'] = '*'
+  response.headers['Access-Control-Allow-Methods'] = 'GET, POST, PUT, DELETE, OPTIONS'
+  request_headers = request.headers.get('Access-Control-Request-Headers')
+  response.headers['Access-Control-Allow-Headers'] = request_headers if request_headers else ''
+  response.headers['Access-Control-Expose-Headers'] = '*'
+
+
+# annotation
+def before_intercept(order=0):
+  def decorator(func):
+    for interceptor in GlobalState.interceptors:
+      if interceptor['func'].__name__ == func.__name__:
+        log.info("duplicate interceptor: {}".format(func.__name__))
+        return
+    log.info("add before interceptor: {}".format(func.__name__))
+    GlobalState.interceptors.append({'order': order, 'func': func})
+    GlobalState.interceptors = sorted(GlobalState.interceptors, key=lambda x: x['order'])
+
+  return decorator
+
+# annotation
+# 接口请求地址后面带不带斜杠都会影响: /api/xxx/ 和 /api/xxx 是不一样的
+def auth_ignore(func):
+  """忽略登录验证的接口"""
+  ignore_req_func = inspect.getmodule(func).__name__ + "." + func.__name__
+  if ignore_req_func in GlobalState.auth_ignore_func: raise Exception("duplicate ignore func: {}".format(ignore_req_func))
+  GlobalState.auth_ignore_func.add(ignore_req_func)
+  @wraps(func)
+  def decorated(*args, **kwargs):
+    return func(*args, **kwargs)
+  return decorated
+
+# annotation
+def rule(key):
+  def return_func(func):
+    @wraps(func)
+    def decorated(*args, **kwargs):
+      rules = ctoken.get_token_attr("rules") or []
+      if _match_rule_by_prefix(key, rules):
+        return func(*args, **kwargs)
+      else:
+        return R.error("权限不足, 请联系管理员: {}".format(key))
+    return decorated
+  return return_func
+
+def _match_rule_by_prefix(key, rules):
+  for r in rules:
+    if key.startswith(r):
+      return True
+  return False
+
+# annotation or plugins, has auto install, don't need to call
+def params_resolve(func):
+  @wraps(func)
+  def decorated(*args, **kwargs):
+    if func_has_params.get(request.fullpath) is not None and not func_has_params.get(request.fullpath):
+      return func(*args, **kwargs)
+    if func_has_params.get(request.fullpath) is None:
+      sig = inspect.signature(func)
+      params = sig.parameters
+      if not params.get('params'):
+        func_has_params[request.fullpath] = False
+        return func(*args, **kwargs)
+      else:
+        func_has_params[request.fullpath] = True
+    if request.method == 'GET' or request.method == 'DELETE':
+      queryStr = request.query.decode('utf-8')
+      page_info = PageInfo(
+        page_size=int(request.query.page_size)   if request.headers.get('page_size') is None else int(request.headers.get('page_size')),
+        page_index=int(request.query.page_index) if request.headers.get('page_index') is None else int(request.headers.get('page_index'))
+      )
+      queryStr = auto_exchange(func, queryStr)
+      queryStr.page_info = page_info
+      return func(params=queryStr, *args, **kwargs)
+    elif request.method == 'POST' or request.method == 'PUT':
+      query_params = request.query.decode('utf-8')
+      content_type = request.get_header('content-type')
+      if content_type == 'application/json':
+        params = request.json or {}
+        dict_wrapper = DictWrapper(params)
+        dict_wrapper.update(query_params.dict)
+        return func(params=auto_exchange(func, dict_wrapper), *args, **kwargs)
+      elif 'multipart/form-data' in content_type:
+        form_data = request.forms.decode()
+        form_files = request.files.decode()
+        dict_wrapper = DictWrapper(form_data)
+        dict_wrapper.update(query_params.dict)
+        dict_wrapper.files = form_files
+        return func(params=auto_exchange(func, dict_wrapper), *args, **kwargs)
+      elif 'application/x-www-form-urlencoded' in content_type:
+        params = request.forms.decode()
+        dict_wrapper = DictWrapper(params.dict)
+        dict_wrapper.update(query_params.dict)
+        return func(params=auto_exchange(func, dict_wrapper), *args, **kwargs)
+      elif 'text/plain' in content_type:
+        params = request.body.read().decode('utf-8')
+        dict_wrapper = DictWrapper({'body': params})
+        dict_wrapper.update(query_params.dict)
+        return func(params=auto_exchange(func, dict_wrapper), *args, **kwargs)
+    else:
+      return func(*args, **kwargs)
+
+  return decorated
+
+# 自动转换参数类型
+def auto_exchange(func, dict_wrapper):
+  model_class = func.__annotations__.get('params')
+  if model_class:
+    try:
+      model_instance = model_class(**dict_wrapper)
+      return model_instance
+    except Exception as e:
+      log.exception(e)
+      return dict_wrapper
+  else:
+    return dict_wrapper
+
+# 分页信息对象
+class PageInfo:
+  def __init__(self, page_size, page_index):
+    self.page_size = page_size
+    self.page_index = page_index
+
+
+# 通用的鉴权方法
+def common_auth_verify() -> R:
+  valid = ctoken.is_valid()
+  if valid: return R.ok(to_json_str=False)
+  return R.error(resp=R.Code.cus_code(401, "请登录!"), to_json_str=False)

ctools/web/bottle_webserver.py

@@ -0,0 +1,191 @@
+import os
+import sys
+from socketserver import ThreadingMixIn
+from wsgiref.simple_server import WSGIServer, WSGIRequestHandler, make_server
+
+from bottle import ServerAdapter, Bottle, template, static_file, abort, redirect, response, request
+
+from ctools import sys_info
+from ctools.pkg.dynamic_imp import load_modules_from_package
+from ctools.web.api_result import R
+from ctools.web.bottle_web_base import cache_white_list, auth_ignore, GlobalState
+
+"""
+import controllers
+from ctools import patch
+from ctools.database import database
+from ctools.util.config_util import load_config
+from ctools.web import bottle_web_base, bottle_webserver
+from key_word_cloud.db_core.db_init import init_partitions
+from patch_manager import patch_funcs
+
+database.init_db('postgresql://postgres:123123@192.168.xx.xx:5432/xxx', default_schema='xxx', auto_gen_table=False, echo=False)
+
+config = load_config('application.ini')
+
+patch.sync_version(config.base.app_name, config.base.version, patch_funcs)
+init_partitions()
+
+app = bottle_web_base.init_app("/api", True)
+
+@bottle_web_base.before_intercept(0)
+def token_check():
+    return bottle_web_base.common_auth_verify(config.base.secret_key)
+
+if __name__ == '__main__':
+  main_server = bottle_webserver.init_bottle(app)
+  main_server.auto_mount(controllers)
+  main_server.run()
+"""
+
+_default_port = 8888
+
+
+class CBottle:
+
+  def __init__(self, bottle: Bottle, port=_default_port, quiet=False):
+    self.port = port
+    self.quiet = quiet
+    self.bottle = bottle
+    self.index_root = './'
+    self.index_filename = 'index.html'
+    self.is_tpl = False
+    self.tmp_args = {}
+    self.redirect_url = None
+    self.static_root = './static'
+    self.download_root = './download'
+    self.template_root = './templates'
+
+    @self.bottle.route(['/', '/index'])
+    def index():
+      try:
+        if self.redirect_url: return redirect(self.redirect_url)
+        if self.is_tpl: return template(f"{self.index_root}/{self.index_filename}", self.tmp_args)
+        return static_file(filename=self.index_filename, root=self.index_root)
+      except FileNotFoundError:
+        abort(404, "File not found...")
+
+    @self.bottle.route('/template/<filepath:path>')
+    def tpl(filepath, tmp_args):
+      try:
+        return template(f"{self.template_root}/{filepath}", tmp_args)
+      except FileNotFoundError:
+        abort(404, "File not found...")
+
+    @self.bottle.route('/static/<filepath:path>')
+    def static(filepath):
+      try:
+        return static_file(filepath, root=self.static_root)
+      except FileNotFoundError:
+        abort(404, "File not found...")
+
+    @self.bottle.route('/download/<filepath:path>')
+    def download(filepath):
+      return static_file(filepath, root=self.download_root, download=True)
+
+    @self.bottle.route('/favicon.ico')
+    def favicon():
+      response.content_type = 'image/svg+xml'
+      svg_icon = '''<?xml version="1.0" encoding="UTF-8"?>
+      <svg width="32" height="32" viewBox="0 0 32 32" xmlns="http://www.w3.org/2000/svg">
+          <circle cx="16" cy="16" r="14" fill="#007bff"/>
+          <path d="M16 8a8 8 0 0 0-8 8h2a6 6 0 0 1 12 0h2a8 8 0 0 0-8-8z" fill="white"/>
+          <circle cx="16" cy="20" r="2" fill="white"/>
+      </svg>
+      '''
+      return svg_icon
+
+  def auto_register_statics(self, dist_root='./static'):
+    for d in os.listdir(dist_root):
+      full_path = os.path.join(dist_root, d)
+      if os.path.isdir(full_path):
+        self.add_static_route(f'/{d}', full_path)
+
+  def add_static_route(self, url_prefix, root):
+    """动态添加静态资源映射"""
+    if not url_prefix.startswith('/'):
+      url_prefix = '/' + url_prefix
+    if not url_prefix.endswith('/'):
+      url_prefix += '/'
+    route_path = f"{url_prefix}<filepath:path>"
+    @self.bottle.route(route_path)
+    def static_handler(filepath):
+      try:
+        return static_file(filepath, root=root)
+      except FileNotFoundError:
+        abort(404, f"{filepath} not found in {root}")
+    GlobalState.withOutLoginURI.add(url_prefix)
+    print(f"[static] mounted {url_prefix} -> {root}")
+
+  def run(self):
+    http_server = WSGIRefServer(port=self.port)
+    print('Click the link below to open the service homepage %s' % '\n \t\t http://localhost:%s \n \t\t http://%s:%s' % (self.port, sys_info.get_local_ipv4(), self.port), file=sys.stderr)
+    cache_white_list(self.bottle)
+    self.bottle.run(server=http_server, quiet=self.quiet)
+
+  def enable_spa_mode(self):
+    @self.bottle.error(404)
+    def error_404_handler(error):
+      if request.path.startswith('/api/'): return R.error(resp=R.Code.cus_code(404, "资源未找到: {}".format(error.body)))
+      return static_file(filename=self.index_filename, root=self.index_root)
+
+  def set_index(self, filename='index.html', root='./', is_tpl=False, redirect_url=None, spa=False, **kwargs):
+    self.index_root = root
+    self.index_filename = filename
+    self.is_tpl = is_tpl
+    self.redirect_url = redirect_url
+    if spa: self.enable_spa_mode()
+    self.tmp_args = kwargs
+
+  def set_static(self, root='./static'):
+    self.static_root = root
+
+  def set_template(self, root='./templates'):
+    self.template_root = root
+
+  def set_download(self, root='./download'):
+    self.download_root = root
+
+  def mount(self, context_path, app, **kwargs):
+    if not context_path: return
+    self.bottle.mount(context_path, app, **kwargs)
+
+  def auto_mount(self, package, exclude=None, recursive=True):
+    for module in load_modules_from_package(package, exclude, recursive):
+      if self.bottle.context_path != '/':
+        if module.app.context_path == '/':
+          ctx_path = self.bottle.context_path
+        else:
+          ctx_path = self.bottle.context_path + module.app.context_path
+      else:
+        ctx_path = module.app.context_path
+      print("mount: %s on %s" % (ctx_path, module.__name__))
+      self.bottle.mount(ctx_path, module.app)
+
+def init_bottle(app: Bottle = None, port=_default_port, quiet=False) -> CBottle:
+  bottle = app or Bottle()
+  return CBottle(bottle, port, quiet)
+
+
+class ThreadedWSGIServer(ThreadingMixIn, WSGIServer):
+  daemon_threads = True
+
+
+class CustomWSGIHandler(WSGIRequestHandler):
+  def log_request(*args, **kw): pass
+
+
+class WSGIRefServer(ServerAdapter):
+
+  def __init__(self, host='0.0.0.0', port=_default_port):
+    super().__init__(host, port)
+    self.server = None
+
+  def run(self, handler):
+    req_handler = WSGIRequestHandler
+    if self.quiet: req_handler = CustomWSGIHandler
+    self.server = make_server(self.host, self.port, handler, server_class=ThreadedWSGIServer, handler_class=req_handler)
+    self.server.serve_forever()
+
+  def stop(self):
+    self.server.shutdown()