sycommon-python-lib 0.1.9__py3-none-any.whl → 0.1.11__py3-none-any.whl

sycommon/services.py

@@ -2,12 +2,13 @@ from typing import Any, Callable, Dict, List, Tuple, Union, Optional, AsyncGener
 import asyncio
 import logging
 from contextlib import asynccontextmanager
-from fastapi import FastAPI
+from fastapi import FastAPI, applications
 from pydantic import BaseModel
 from sycommon.config.Config import SingletonMeta
 from sycommon.models.mqlistener_config import RabbitMQListenerConfig
 from sycommon.models.mqsend_config import RabbitMQSendConfig
 from sycommon.rabbitmq.rabbitmq_service import RabbitMQService
+from sycommon.tools.docs import custom_redoc_html, custom_swagger_ui_html
 
 
 class Services(metaclass=SingletonMeta):
@@ -53,6 +54,9 @@ class Services(metaclass=SingletonMeta):
         # 保存应用实例和配置
         cls._app = app
         cls._config = config
+        # 设置文档
+        applications.get_swagger_ui_html = custom_swagger_ui_html
+        applications.get_redoc_html = custom_redoc_html
 
         # 立即配置非异步服务（在应用启动前）
         if middleware:
@@ -125,11 +129,7 @@ class Services(metaclass=SingletonMeta):
         has_listeners: bool = False,
         has_senders: bool = False,
     ):
-        """异步设置MQ相关服务，保存发送器和监听器存在状态"""
-        # 保存状态到类变量
-        Services._has_listeners = has_listeners
-        Services._has_senders = has_senders
-
+        """异步设置MQ相关服务"""
         # 初始化RabbitMQ服务，传递状态
         RabbitMQService.init(self._config, has_listeners, has_senders)
 
@@ -141,6 +141,13 @@ class Services(metaclass=SingletonMeta):
         if rabbitmq_listeners:
             await self._setup_listeners_async(rabbitmq_listeners, has_senders)
 
+        # 验证初始化结果
+        if has_listeners:
+            listener_count = len(RabbitMQService._clients)
+            logging.info(f"监听器初始化完成，共启动 {listener_count} 个消费者")
+            if listener_count == 0:
+                logging.warning("未成功初始化任何监听器，请检查配置")
+
     async def _setup_senders_async(self, rabbitmq_senders, has_listeners: bool):
         Services._registered_senders = [
             sender.queue_name for sender in rabbitmq_senders]
@@ -158,7 +165,7 @@ class Services(metaclass=SingletonMeta):
         queue_name: str,
         data: Union[str, Dict[str, Any], BaseModel, None],
         max_retries: int = 3,
-        retry_delay: float = 1.0, ** kwargs
+        retry_delay: float = 1.0, **kwargs
     ) -> None:
         """发送消息，添加重试机制"""
         if not cls._initialized or not cls._loop:
@@ -168,7 +175,7 @@ class Services(metaclass=SingletonMeta):
         for attempt in range(max_retries):
             try:
                 if queue_name not in cls._registered_senders:
-                    cls._registered_senders = RabbitMQService.sender_client_names
+                    cls._registered_senders = RabbitMQService._sender_client_names
                     if queue_name not in cls._registered_senders:
                         raise ValueError(f"发送器 {queue_name} 未注册")
 
@@ -176,7 +183,7 @@ class Services(metaclass=SingletonMeta):
                 if not sender:
                     raise ValueError(f"发送器 '{queue_name}' 不存在")
 
-                await RabbitMQService.send_message(data, queue_name, **kwargs)
+                await RabbitMQService.send_message(data, queue_name, ** kwargs)
                 logging.info(f"消息发送成功（尝试 {attempt+1}/{max_retries}）")
                 return
 

sycommon/synacos/feign.py

@@ -1,6 +1,7 @@
 import io
 import os
 import time
+import inspect
 from urllib.parse import urljoin
 
 import aiohttp
@@ -14,163 +15,373 @@ from sycommon.synacos.nacos_service import NacosService
 """
 
 # 示例Feign客户端接口
-# @feign_client(service_name="user-service", path_prefix="/api/v1")
-# class UserServiceClient:
+# 1. 定义完整的Feign客户端接口
+# @feign_client(service_name="product-service", path_prefix="/api/v2")
+# class ProductServiceClient:
+#     """商品服务Feign客户端示例，涵盖所有参数类型"""
 #
-#     @feign_request("GET", "/users/{user_id}")
-#     async def get_user(self, user_id):
-#         """获取用户信息"""
+#     # ------------------------------
+#     # 场景1: Path参数 + Query参数
+#     # 请求示例: GET /products/{product_id}/reviews?status=APPROVED&page=1&size=10
+#     # ------------------------------
+#     @feign_request("GET", "/products/{product_id}/reviews")
+#     async def get_product_reviews(
+#         self,
+#         product_id: int,  # Path参数 (URL路径中的占位符)
+#         status: Optional[str] = None,  # Query参数 (URL查询字符串)
+#         page: int = 1,  # Query参数 (默认值)
+#         size: int = 10  # Query参数 (默认值)
+#     ) -> Dict[str, Any]:
+#         """获取商品评价列表"""
 #         pass
 #
-#     @feign_request("POST", "/users", headers={"Content-Type": "application/json"})
-#     async def create_user(self, user_data):
-#         """创建用户"""
+#     # ------------------------------
+#     # 场景2: 仅Query参数
+#     # 请求示例: GET /products?category=electronics&min_price=100&max_price=500&sort=price_asc
+#     # ------------------------------
+#     @feign_request("GET", "/products")
+#     async def search_products(
+#         self,
+#         category: str,  # 必选Query参数
+#         min_price: Optional[float] = None,  # 可选Query参数
+#         max_price: Optional[float] = None,  # 可选Query参数
+#         sort: str = "created_desc"  # 带默认值的Query参数
+#     ) -> Dict[str, Any]:
+#         """搜索商品（仅查询参数）"""
 #         pass
 #
-#     @feign_upload("avatar")
-#     @feign_request("POST", "/users/{user_id}/avatar")
-#     async def upload_avatar(self, user_id, file_path):
-#         """上传用户头像"""
+#     # ------------------------------
+#     # 场景3: JSON Body参数 (POST)
+#     # 请求示例: POST /products (请求体为JSON)
+#     # ------------------------------
+#     @feign_request("POST", "/products", headers={"s-y-version": "2.1"})
+#     async def create_product(
+#         self,
+#         product_data: Dict[str, Any]  # JSON请求体
+#     ) -> Dict[str, Any]:
+#         """创建商品（JSON请求体）"""
 #         pass
-
-# # 使用示例
-# async def get_user_info(user_id: int, request=None):
-#     """获取用户信息"""
-#     try:
-#         user_service = UserServiceClient()
-#         # 设置请求头中的版本信息
-#         user_service.get_user._feign_meta['headers']['s-y-version'] = "1.0.0"
-#         return await user_service.get_user(user_id=user_id, request=request)
-#     except Exception as e:
-#         SYLogger.error(f"获取用户信息失败: {str(e)}", TraceId(request))
-#         return None
+#
+#     # ------------------------------
+#     # 场景4: Path参数 + JSON Body (PUT)
+#     # 请求示例: PUT /products/{product_id} (请求体为JSON)
+#     # ------------------------------
+#     @feign_request("PUT", "/products/{product_id}")
+#     async def update_product(
+#         self,
+#         product_id: int,  # Path参数
+#         update_data: Dict[str, Any]  # JSON请求体
+#     ) -> Dict[str, Any]:
+#         """更新商品信息"""
+#         pass
+#
+#     # ------------------------------
+#     # 场景5: FormData表单提交 (x-www-form-urlencoded)
+#     # 请求示例: POST /products/batch-status (表单字段)
+#     # ------------------------------
+#     @feign_request(
+#         "POST",
+#         "/products/batch-status",
+#         headers={"Content-Type": "application/x-www-form-urlencoded"}
+#     )
+#     async def batch_update_status(
+#         self,
+#         product_ids: str,  # 表单字段 (多个ID用逗号分隔)
+#         status: str,  # 表单字段 (目标状态)
+#         operator: str  # 表单字段 (操作人)
+#     ) -> Dict[str, Any]:
+#         """批量更新商品状态（表单提交）"""
+#         pass
+#
+#     # ------------------------------
+#     # 场景6: 文件上传 + 表单字段混合
+#     # 请求示例: POST /products/{product_id}/images (multipart/form-data)
+#     # ------------------------------
+#     @feign_upload(field_name="image_file")  # 指定文件表单字段名
+#     @feign_request("POST", "/products/{product_id}/images")
+#     async def upload_product_image(
+#         self,
+#         product_id: int,  # Path参数
+#         file_path: str,  # 本地文件路径（会被转为文件上传）
+#         image_type: str,  # 表单字段（图片类型）
+#         is_primary: bool = False,  # 表单字段（是否主图）
+#         remark: Optional[str] = None  # 可选表单字段
+#     ) -> Dict[str, Any]:
+#         """上传商品图片（文件+表单字段）"""
+#         pass
+#
+#     # ------------------------------
+#     # 场景7: 多Path参数 + DELETE请求
+#     # 请求示例: DELETE /products/{product_id}/skus/{sku_id}
+#     # ------------------------------
+#     @feign_request("DELETE", "/products/{product_id}/skus/{sku_id}")
+#     async def delete_product_sku(
+#         self,
+#         product_id: int,  # Path参数1
+#         sku_id: int  # Path参数2
+#     ) -> Dict[str, Any]:
+#         """删除商品SKU（多路径参数）"""
+#         pass
+#
+#     # ------------------------------
+#     # 场景8: 复杂JSON Body + Query参数
+#     # 请求示例: POST /products/filter?include_out_of_stock=false
+#     # ------------------------------
+#     @feign_request("POST", "/products/filter")
+#     async def advanced_filter(
+#         self,
+#         filter_condition: Dict[str, Any],  # JSON请求体（复杂筛选条件）
+#         include_out_of_stock: bool = False,  # Query参数
+#         page: int = 1,  # Query参数
+#         size: int = 20  # Query参数
+#     ) -> Dict[str, Any]:
+#         """高级筛选商品（JSON体+查询参数）"""
+#         pass
+#
+#
+# # 2. 完整调用示例
+# async def feign_complete_demo():
+#     # ------------------------------
+#     # 调用场景1: Path参数 + Query参数
+#     # ------------------------------
+#     reviews = await ProductServiceClient().get_product_reviews(
+#         product_id=10086,  # Path参数
+#         status="APPROVED",  # Query参数
+#         page=1,
+#         size=20
+#     )
+#     print(f"场景1 - 商品评价: {reviews.get('total', 0)}条评价")
+#
+#     # ------------------------------
+#     # 调用场景2: 仅Query参数
+#     # ------------------------------
+#     electronics = await ProductServiceClient().search_products(
+#         category="electronics",  # 必选Query
+#         min_price=1000,
+#         max_price=5000,
+#         sort="price_asc"
+#     )
+#     print(f"场景2 - 搜索结果: {len(electronics.get('items', []))}个商品")
+#
+#     # ------------------------------
+#     # 调用场景3: JSON Body参数 (POST)
+#     # ------------------------------
+#     new_product = await ProductServiceClient().create_product({
+#         "name": "无线蓝牙耳机",
+#         "category": "electronics",
+#         "price": 299.99,
+#         "stock": 500,
+#         "attributes": {
+#             "brand": "Feign",
+#             "battery_life": "24h"
+#         }
+#     })
+#     print(f"场景3 - 新建商品: ID={new_product.get('id')}")
+#     product_id = new_product.get('id')  # 用于后续示例
+#
+#     # ------------------------------
+#     # 调用场景4: Path参数 + JSON Body (PUT)
+#     # ------------------------------
+#     if product_id:
+#         updated = await ProductServiceClient().update_product(
+#             product_id=product_id,
+#             update_data={
+#                 "price": 279.99,  # 降价
+#                 "stock": 600
+#             }
+#         )
+#         print(f"场景4 - 商品更新: 状态={updated.get('success')}")
+#
+#     # ------------------------------
+#     # 调用场景5: FormData表单提交
+#     # ------------------------------
+#     batch_result = await ProductServiceClient().batch_update_status(
+#         product_ids="1001,1002,1003",  # 多个ID用逗号分隔
+#         status="ON_SALE",
+#         operator="system"
+#     )
+#     print(f"场景5 - 批量更新: 成功{batch_result.get('success_count')}个")
+#
+#     # ------------------------------
+#     # 调用场景6: 文件上传 + 表单字段
+#     # ------------------------------
+#     if product_id:
+#         upload_result = await ProductServiceClient().upload_product_image(
+#             product_id=product_id,
+#             file_path="/tmp/product_main.jpg",  # 本地图片路径
+#             image_type="main",
+#             is_primary=True,
+#             remark="商品主图"
+#         )
+#         print(f"场景6 - 图片上传: URL={upload_result.get('image_url')}")
+#
+#     # ------------------------------
+#     # 调用场景7: 多Path参数 + DELETE
+#     # ------------------------------
+#     delete_result = await ProductServiceClient().delete_product_sku(
+#         product_id=10086,
+#         sku_id=5001
+#     )
+#     print(f"场景7 - 删除SKU: {delete_result.get('message')}")
+#
+#     # ------------------------------
+#     # 调用场景8: 复杂JSON Body + Query参数
+#     # ------------------------------
+#     filtered = await ProductServiceClient().advanced_filter(
+#         filter_condition={  # 复杂JSON条件
+#             "categories": ["electronics", "home"],
+#             "price_range": {"min": 500, "max": 3000},
+#             "tags": ["new", "promotion"]
+#         },
+#         include_out_of_stock=False,  # Query参数
+#         page=1,
+#         size=10
+#     )
+#     print(f"场景8 - 高级筛选: {filtered.get('total')}个匹配商品")
 
 
 def feign_client(service_name: str, path_prefix: str = "", default_timeout: float | None = None):
+    """Feign客户端装饰器，每次请求后自动关闭会话"""
     def decorator(cls):
         class FeignWrapper:
             def __init__(self):
                 self.service_name = service_name
-                self.nacos_manager = NacosService(None)
                 self.path_prefix = path_prefix
-                self.session = aiohttp.ClientSession()
                 self.default_timeout = default_timeout
+                self.nacos_manager = None  # 延迟初始化Nacos
+                self.session = None  # 延迟初始化aiohttp会话
 
             def __getattr__(self, name):
+                """动态获取方法并包装为Feign调用，请求后自动关闭会话"""
                 func = getattr(cls, name)
 
                 async def wrapper(*args, **kwargs):
-                    # 获取请求元数据
-                    request_meta = getattr(func, "_feign_meta", {})
-                    method = request_meta.get("method", "GET")
-                    path = request_meta.get("path", "")
-                    headers = request_meta.get(
-                        "headers", {}).copy()  # 复制 headers 避免修改原对象
-
-                    timeout = kwargs.pop('timeout', self.default_timeout)
-
-                    # 处理JSON请求的Content-Type
-                    is_json_request = method.upper() in [
-                        "POST", "PUT", "PATCH"] and not request_meta.get("files")
-                    if is_json_request and "Content-Type" not in headers:
-                        headers["Content-Type"] = "application/json"
-
-                    # 获取版本信息
-                    version = headers.get('s-y-version')
-
-                    # 构建完整URL
-                    full_path = f"{self.path_prefix}{path}"
-                    for k, v in kwargs.items():
-                        full_path = full_path.replace(f"{{{k}}}", str(v))
-
-                    # 服务发现与负载均衡
-                    instances = self.nacos_manager.get_service_instances(
-                        self.service_name, version=version)
-                    if not instances:
-                        SYLogger.error(
-                            f"nacos:未找到 {self.service_name} 的健康实例")
-                        raise RuntimeError(
-                            f"No instances available for {self.service_name}")
-
-                    # 简单轮询负载均衡
-                    instance = instances[int(time.time()) % len(instances)]
-                    base_url = f"http://{instance['ip']}:{instance['port']}"
-                    url = urljoin(base_url, full_path)
-
-                    SYLogger.info(
-                        f"nacos:调用服务: {self.service_name} -> {url}")
-                    SYLogger.info(f"nacos:请求头: {headers}")
-
-                    # 构建请求
-                    params = request_meta.get("params", {})
-                    body = request_meta.get("body", {})
-                    files = request_meta.get("files", None)
-                    form_data = request_meta.get("form_data", None)
-
-                    # 发送请求
+                    # 确保会话初始化
+                    if self.session is None:
+                        self.session = aiohttp.ClientSession()
+                    if self.nacos_manager is None:
+                        self.nacos_manager = NacosService(None)
+
                     try:
-                        # 处理文件上传
-                        if files or form_data:
-                            # 创建表单数据
-                            data = aiohttp.FormData()
-                            if form_data:
-                                for key, value in form_data.items():
-                                    data.add_field(key, value)
-                            if files:
-                                for field_name, (filename, content) in files.items():
-                                    data.add_field(
-                                        field_name, content, filename=filename)
-                            # 移除 Content-Type 头，让 aiohttp 自动设置 boundary
+                        # 1. 解析参数
+                        sig = inspect.signature(func)
+                        param_names = list(sig.parameters.keys())
+                        try:
+                            if param_names and param_names[0] == 'self':
+                                bound_args = sig.bind(self, *args, **kwargs)
+                            else:
+                                bound_args = sig.bind(*args, **kwargs)
+                            bound_args.apply_defaults()
+                            params = dict(bound_args.arguments)
+                            params.pop('self', None)
+                            SYLogger.debug(f"解析参数: {params}")
+                        except TypeError as e:
+                            SYLogger.error(f"参数绑定失败: {str(e)}")
+                            raise
+
+                        # 2. 构建请求
+                        request_meta = getattr(func, "_feign_meta", {})
+                        method = request_meta.get("method", "GET")
+                        path = request_meta.get("path", "")
+                        headers = request_meta.get("headers", {}).copy()
+                        timeout = kwargs.pop('timeout', self.default_timeout)
+
+                        full_path = f"{self.path_prefix}{path}"
+                        for param_name, param_value in params.items():
+                            if param_value is not None:
+                                full_path = full_path.replace(
+                                    f"{{{param_name}}}", str(param_value))
+
+                        is_json_request = method.upper() in ["POST", "PUT", "PATCH"] and \
+                            not request_meta.get("is_upload", False)
+                        if is_json_request and "Content-Type" not in headers:
+                            headers["Content-Type"] = "application/json"
+
+                        # 3. 服务发现
+                        version = headers.get('s-y-version')
+                        instances = self.nacos_manager.get_service_instances(
+                            self.service_name, version=version)
+                        if not instances:
+                            raise RuntimeError(
+                                f"未找到服务 {self.service_name} 的健康实例")
+
+                        instance = instances[int(time.time()) % len(instances)]
+                        base_url = f"http://{instance['ip']}:{instance['port']}"
+                        url = urljoin(base_url, full_path)
+                        SYLogger.info(f"请求: {method} {url}")
+
+                        # 4. 准备请求参数
+                        query_params = {k: v for k, v in params.items()
+                                        if f"{{{k}}}" not in path and v is not None}
+                        request_data = None
+                        files = None
+
+                        if request_meta.get("is_upload", False):
+                            files = aiohttp.FormData()
+                            file_path = params.get('file_path')
+                            if file_path and os.path.exists(file_path):
+                                file_field = request_meta.get(
+                                    "upload_field", "file")
+                                with open(file_path, 'rb') as f:
+                                    files.add_field(
+                                        file_field,
+                                        f.read(),
+                                        filename=os.path.basename(file_path)
+                                    )
+                            for key, value in params.items():
+                                if key != 'file_path' and value is not None:
+                                    files.add_field(key, str(value))
                             headers.pop('Content-Type', None)
-                            # 发送表单数据
-                            async with self.session.request(
-                                method=method,
-                                url=url,
-                                headers=headers,
-                                params=params,
-                                data=data,
-                                timeout=timeout
-                            ) as response:
-                                return await self._handle_response(response)
-                        else:
-                            # 普通请求（JSON）
-                            async with self.session.request(
-                                method=method,
-                                url=url,
-                                headers=headers,
-                                params=params,
-                                json=body,
-                                timeout=timeout
-                            ) as response:
-                                return await self._handle_response(response)
-                    except Exception as e:
-                        SYLogger.error(f"nacos:服务调用失败: {str(e)}")
-                        raise RuntimeError(f"Feign call failed: {str(e)}")
+                        elif is_json_request:
+                            body_params = [k for k in params if k not in query_params
+                                           and f"{{{k}}}" not in path]
+                            if body_params:
+                                request_data = params[body_params[0]] if len(body_params) == 1 else \
+                                    {k: params[k] for k in body_params}
+
+                        # 5. 发送请求并获取响应
+                        async with self.session.request(
+                            method=method,
+                            url=url,
+                            headers=headers,
+                            params=query_params,
+                            json=request_data if not files else None,
+                            data=files,
+                            timeout=timeout
+                        ) as response:
+                            return await self._handle_response(response)
+
+                    finally:
+                        # 请求完成后自动关闭会话
+                        if self.session:
+                            await self.session.close()
+                            self.session = None  # 重置会话，下次调用重新创建
+                            SYLogger.info(
+                                f"自动关闭aiohttp会话: {self.service_name}")
 
                 return wrapper
 
             async def _handle_response(self, response):
-                # 处理响应
-                if 200 <= response.status < 300:
+                """处理响应结果（保持不变）"""
+                status = response.status
+                if 200 <= status < 300:
                     content_type = response.headers.get('Content-Type', '')
                     if 'application/json' in content_type:
                         return await response.json()
                     else:
                         return await response.read()
-                raise RuntimeError(
-                    f"请求失败: {response.status} - {await response.text()}")
+                else:
+                    error_msg = await response.text()
+                    SYLogger.error(f"响应错误: {status} - {error_msg}")
+                    raise RuntimeError(f"HTTP {status}: {error_msg}")
 
-            async def close(self):
-                """关闭 aiohttp 会话"""
-                await self.session.close()
-
-        return FeignWrapper()
+        return FeignWrapper
     return decorator
 
 
 def feign_request(method: str, path: str, headers: dict = None):
+    """定义请求元数据的装饰器"""
     def decorator(func):
-        # 初始化请求元数据，确保headers是可修改的字典
         func._feign_meta = {
             "method": method.upper(),
             "path": path,
@@ -181,13 +392,12 @@ def feign_request(method: str, path: str, headers: dict = None):
 
 
 def feign_upload(field_name: str = "file"):
-    # 文件上传装饰器
+    """处理文件上传的装饰器"""
     def decorator(func):
         async def wrapper(*args, **kwargs):
             file_path = kwargs.get('file_path')
-            if not file_path:
-                raise ValueError("file_path is required for upload")
-
+            if not file_path or not os.path.exists(file_path):
+                raise ValueError(f"文件路径不存在: {file_path}")
             with open(file_path, 'rb') as f:
                 files = {field_name: (os.path.basename(file_path), f.read())}
                 kwargs['files'] = files
@@ -276,11 +486,13 @@ async def feign(service_name, api_path, method='GET', params=None, headers=None,
                 ) as response:
                     return await _handle_feign_response(response)
         except aiohttp.ClientError as e:
-            SYLogger.error(f"nacos:请求服务接口时出错ClientError: {e}")
+            SYLogger.error(
+                f"nacos:请求服务接口时出错ClientError path: {api_path} error:{e}")
             return None
     except Exception as e:
         import traceback
-        SYLogger.error(f"nacos:请求服务接口时出错: {traceback.format_exc()}")
+        SYLogger.error(
+            f"nacos:请求服务接口时出错 path: {api_path} error:{traceback.format_exc()}")
         return None
     finally:
         await session.close()

sycommon/tools/docs.py

@@ -0,0 +1,42 @@
+from fastapi.openapi.docs import get_swagger_ui_html, get_redoc_html, swagger_ui_default_parameters
+
+
+def custom_swagger_ui_html(*args, **kwargs):
+    custom_params = {
+        "dom_id": "#swagger-ui",
+        "layout": "BaseLayout",
+        "deepLinking": True,
+        "showExtensions": True,
+        "showCommonExtensionsExtensions": True,
+        "defaultModelsExpandDepth": -1,
+        "persistAuthorization": True,
+        "displayRequestDuration": True
+    }
+
+    # 初始化合并参数为默认参数的副本
+    merged_params = swagger_ui_default_parameters.copy()
+
+    # 安全地合并kwargs中的参数（处理可能为None的情况）
+    if "swagger_ui_parameters" in kwargs and kwargs["swagger_ui_parameters"] is not None:
+        merged_params.update(kwargs["swagger_ui_parameters"])
+
+    # 最后应用自定义参数
+    merged_params.update(custom_params)
+    kwargs["swagger_ui_parameters"] = merged_params
+
+    return get_swagger_ui_html(
+        *args, ** kwargs,
+        swagger_favicon_url="https://static.sytechnology.com/img/sylogopng.png",
+        swagger_js_url="https://cdn.bootcdn.net/ajax/libs/swagger-ui/5.27.1/swagger-ui-bundle.js",
+        swagger_css_url="https://cdn.bootcdn.net/ajax/libs/swagger-ui/5.27.1/swagger-ui.css",
+    )
+
+
+def custom_redoc_html(*args, **kwargs):
+    return get_redoc_html(
+        *args,
+        **kwargs,
+        redoc_favicon_url='https://static.sytechnology.com/img/sylogopng.png',
+        # redoc_js_url="https://cdn.jsdelivr.net/npm/@stardustai/redoc@2.0.0-rc.66/bundles/redoc.browser.lib.min.js",
+        with_google_fonts=False,
+    )

{sycommon_python_lib-0.1.9.dist-info → sycommon_python_lib-0.1.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sycommon-python-lib
-Version: 0.1.9
+Version: 0.1.11
 Summary: Add your description here
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown