hello-datap-component-base 0.2.0__py3-none-any.whl

hello_datap_component_base/discover.py

@@ -0,0 +1,187 @@
+import importlib
+import inspect
+import pkgutil
+from pathlib import Path
+from typing import List, Type, Optional, Tuple
+from .base import BaseService
+
+
+def find_service_classes(
+        search_path: str = ".",
+        exclude_dirs: List[str] = None
+) -> List[Tuple[str, Type[BaseService]]]:
+    """
+    查找所有继承自 BaseService 的类
+
+    Args:
+        search_path: 搜索路径
+        exclude_dirs: 排除的目录
+
+    Returns:
+        列表，每个元素是 (模块名, 类) 的元组
+    """
+    if exclude_dirs is None:
+        exclude_dirs = ["__pycache__", ".git", ".pytest_cache", "venv", "env", ".venv", 
+                        "hello_datap_component_base.egg-info", "build", "dist"]
+
+    import sys
+    import os
+    
+    # 确保搜索路径在 Python 路径中，以便能够导入模块
+    search_path_obj = Path(search_path).resolve()
+    search_path_str = str(search_path_obj)
+    
+    # 确保当前工作目录和搜索路径都在 sys.path 中
+    current_dir = os.getcwd()
+    if current_dir not in sys.path:
+        sys.path.insert(0, current_dir)
+    if search_path_str not in sys.path:
+        sys.path.insert(0, search_path_str)
+    # 确保 '.' 也在路径中（相对导入）
+    if '.' not in sys.path:
+        sys.path.insert(0, '.')
+
+    service_classes = []
+
+    # 遍历目录查找 Python 文件
+    for py_file in search_path_obj.rglob("*.py"):
+        # 跳过排除的目录
+        py_file_str = str(py_file)
+        py_file_parts = py_file.parts
+        
+        # 检查是否在排除的目录中
+        if any(exclude in py_file_parts for exclude in exclude_dirs):
+            continue
+        
+        # 跳过包目录（hello_datap_component_base）下的文件
+        # 但允许根目录下的其他文件（如 example_service.py）
+        if "hello_datap_component_base" in py_file_parts:
+            # 如果文件在包目录内（不是包目录本身作为文件名），跳过
+            idx = py_file_parts.index("hello_datap_component_base")
+            if idx < len(py_file_parts) - 1:  # 包目录下还有子路径
+                continue
+
+        # 计算模块路径
+        relative_path = py_file.relative_to(search_path_obj)
+        module_path = str(relative_path.with_suffix('')).replace('/', '.')
+
+        try:
+            # 动态导入模块
+            module = importlib.import_module(module_path)
+
+            # 查找模块中继承自 BaseService 的类
+            for name, obj in inspect.getmembers(module, inspect.isclass):
+                try:
+                    # 检查是否是 BaseService 的子类
+                    if (inspect.isclass(obj) and 
+                        issubclass(obj, BaseService) and
+                        obj is not BaseService and
+                        not inspect.isabstract(obj)):
+
+                        # 检查是否实现了 process 方法
+                        if hasattr(obj, 'process'):
+                            service_classes.append((module_path, obj))
+                except (TypeError, AttributeError) as e:
+                    # 跳过不是类的对象或无法检查的对象
+                    continue
+
+        except (ImportError, ValueError, AttributeError) as e:
+            # 对于根目录下的用户文件，输出错误信息以便调试
+            # 检查是否是搜索路径下的直接文件（不是包内的文件）
+            relative_to_search = py_file.relative_to(search_path_obj)
+            is_root_file = len(relative_to_search.parts) == 1 and py_file.name not in ["__init__.py"]
+            
+            if is_root_file:
+                # 输出到stderr以便用户看到
+                import sys
+                error_msg = str(e)
+                # 检查是否是缺少模块的错误
+                if "No module named" in error_msg or "ModuleNotFoundError" in error_msg:
+                    print(f"⚠️  警告: 导入 {module_path} 失败，缺少依赖: {error_msg}", file=sys.stderr)
+                    print(f"   提示: 请检查配置文件的 runtime_env.pip 是否包含所需的包", file=sys.stderr)
+                else:
+                    print(f"⚠️  警告: 导入 {module_path} 失败: {error_msg}", file=sys.stderr)
+            continue
+        except Exception as e:
+            # 对于根目录下的用户文件，输出错误信息以便调试
+            relative_to_search = py_file.relative_to(search_path_obj)
+            is_root_file = len(relative_to_search.parts) == 1 and py_file.name not in ["__init__.py"]
+            
+            if is_root_file:
+                import sys
+                error_msg = str(e)
+                if "No module named" in error_msg or "ModuleNotFoundError" in error_msg:
+                    print(f"⚠️  警告: 导入 {module_path} 失败，缺少依赖: {error_msg}", file=sys.stderr)
+                    print(f"   提示: 请检查配置文件的 runtime_env.pip 是否包含所需的包", file=sys.stderr)
+                else:
+                    print(f"⚠️  警告: 导入 {module_path} 时出错: {error_msg}", file=sys.stderr)
+                    import traceback
+                    traceback.print_exc(file=sys.stderr)
+            continue
+
+    return service_classes
+
+
+def get_single_service_class(
+        search_path: str = ".",
+        class_name: Optional[str] = None
+) -> Type[BaseService]:
+    """
+    获取单个服务类
+
+    Args:
+        search_path: 搜索路径
+        class_name: 指定的类名（可选）
+
+    Returns:
+        服务类
+
+    Raises:
+        ValueError: 如果找到0个或多个服务类
+    """
+    service_classes = find_service_classes(search_path)
+
+    if not service_classes:
+        import os
+        current_dir = os.getcwd()
+        search_abs = os.path.abspath(search_path)
+        
+        # 尝试列出一些可能的服务文件
+        possible_files = []
+        for py_file in Path(search_abs).rglob("*.py"):
+            if "example" in str(py_file).lower() and "service" in str(py_file).lower():
+                possible_files.append(str(py_file.relative_to(search_abs)))
+            if len(possible_files) >= 3:
+                break
+        
+        error_msg = (
+            f"No service class found in '{search_abs}' (current directory: {current_dir}).\n"
+            f"Please ensure:\n"
+            f"  1. You are in the project root directory\n"
+            f"  2. There is a Python file containing a class that inherits from BaseService\n"
+            f"  3. The service class implements the 'process' method\n"
+        )
+        if possible_files:
+            error_msg += f"\nPossible service files found:\n"
+            for f in possible_files:
+                error_msg += f"  - {f}\n"
+            error_msg += f"\nTry using --class-name to specify the service class name."
+        
+        raise ValueError(error_msg)
+
+    if class_name:
+        # 查找指定类名的服务
+        for module_path, cls in service_classes:
+            if cls.__name__ == class_name:
+                return cls
+        raise ValueError(f"Service class '{class_name}' not found")
+
+    # 检查是否只有一个服务类
+    if len(service_classes) > 1:
+        class_list = [f"{module}.{cls.__name__}" for module, cls in service_classes]
+        raise ValueError(
+            f"Multiple service classes found: {class_list}. "
+            f"Please specify which one to use with --class-name."
+        )
+
+    return service_classes[0][1]

hello_datap_component_base/logger.py

@@ -0,0 +1,290 @@
+import logging
+import sys
+from typing import Optional, Dict, Any
+import json
+from datetime import datetime
+from pythonjsonlogger import jsonlogger
+
+
+class ServiceLoggerAdapter(logging.LoggerAdapter):
+    """服务日志适配器，自动在每条日志中添加服务名称和版本信息"""
+    
+    def __init__(self, logger: logging.Logger, service_name: str, version: Optional[str] = None):
+        super().__init__(logger, {})
+        self.service_name = service_name
+        self.version = version
+    
+    def process(self, msg, kwargs):
+        """处理日志消息，添加服务信息"""
+        # 确保 extra 字典存在
+        if 'extra' not in kwargs:
+            kwargs['extra'] = {}
+        
+        # 添加服务名称和版本信息
+        kwargs['extra']['service'] = self.service_name
+        if self.version:
+            kwargs['extra']['version'] = self.version
+        
+        return msg, kwargs
+
+
+class CustomJsonFormatter(jsonlogger.JsonFormatter):
+    """自定义 JSON 格式化器"""
+
+    def add_fields(self, log_record: Dict[str, Any], record: logging.LogRecord, message_dict: Dict[str, Any]):
+        super().add_fields(log_record, record, message_dict)
+
+        # 添加时间戳
+        if not log_record.get('timestamp'):
+            log_record['timestamp'] = datetime.utcnow().isoformat()
+
+        # 添加日志级别
+        if not log_record.get('level'):
+            log_record['level'] = record.levelname
+
+        # 添加进程信息
+        log_record['pid'] = record.process
+        log_record['process_name'] = record.processName
+
+        # 添加文件位置
+        log_record['file'] = record.filename
+        log_record['line'] = record.lineno
+        log_record['function'] = record.funcName
+        
+        # 确保服务信息在 JSON 日志中（如果 extra 中有的话）
+        if 'service' in log_record:
+            log_record['service'] = log_record['service']
+        if 'version' in log_record:
+            log_record['version'] = log_record['version']
+
+
+def setup_logging(
+        level: str = "INFO",
+        json_format: bool = False,
+        service_name: str = "unknown",
+        version: Optional[str] = None
+):
+    """
+    设置日志配置
+    
+    兼容 Ray 分布式计算框架：日志输出到 stdout/stderr，Ray 会自动收集这些日志。
+
+    Args:
+        level: 日志级别
+        json_format: 是否使用 JSON 格式
+        service_name: 服务名称
+        version: 服务版本（可选）
+    """
+    # 检测是否在 Ray 环境中运行
+    is_ray_env = False
+    try:
+        import ray
+        is_ray_env = ray.is_initialized()
+    except ImportError:
+        pass
+    
+    # 移除所有现有的处理器
+    root_logger = logging.getLogger()
+    for handler in root_logger.handlers[:]:
+        root_logger.removeHandler(handler)
+
+    # 设置日志级别
+    numeric_level = getattr(logging, level.upper(), None)
+    if not isinstance(numeric_level, int):
+        numeric_level = logging.INFO
+
+    root_logger.setLevel(numeric_level)
+
+    # 创建处理器
+    if json_format:
+        formatter = CustomJsonFormatter(
+            '%(timestamp)s %(level)s %(name)s %(message)s',
+            rename_fields={
+                'level': 'levelname',
+                'timestamp': 'asctime'
+            }
+        )
+    else:
+        # 改进日志格式，包含服务名称和版本
+        version_str = f" v{version}" if version else ""
+        formatter = logging.Formatter(
+            f'%(asctime)s - [{service_name}{version_str}] - %(levelname)s - '
+            f'%(filename)s:%(lineno)d - %(message)s',
+            datefmt='%Y-%m-%d %H:%M:%S'
+        )
+
+    # 控制台处理器（输出到 stdout，Ray 会自动捕获）
+    console_handler = logging.StreamHandler(sys.stdout)
+    console_handler.setFormatter(formatter)
+    root_logger.addHandler(console_handler)
+    
+    # 错误日志输出到 stderr（Ray 也会捕获）
+    error_handler = logging.StreamHandler(sys.stderr)
+    error_handler.setFormatter(formatter)
+    error_handler.setLevel(logging.ERROR)
+    root_logger.addHandler(error_handler)
+
+    # 文件处理器（在 Ray 环境中可能不可用，优雅处理）
+    if not is_ray_env:
+        # 非 Ray 环境才尝试创建文件日志
+        try:
+            file_handler = logging.FileHandler(f"{service_name}.log", encoding='utf-8')
+            file_handler.setFormatter(formatter)
+            root_logger.addHandler(file_handler)
+        except (IOError, PermissionError):
+            pass  # 无法创建日志文件，只输出到控制台
+
+
+def get_service_logger(name: str, version: Optional[str] = None) -> ServiceLoggerAdapter:
+    """
+    获取服务专用的日志器（带服务名称和版本信息）
+    
+    兼容 Ray 分布式计算框架：日志输出到 stdout/stderr，Ray 会自动收集。
+
+    Args:
+        name: 服务名称
+        version: 服务版本（可选）
+
+    Returns:
+        配置好的日志适配器
+    """
+    logger = logging.getLogger(f"service.{name}")
+
+    # 如果还没有处理器，添加一个默认的
+    if not logger.handlers:
+        # 检测是否在 Ray 环境中运行
+        is_ray_env = False
+        try:
+            import ray
+            is_ray_env = ray.is_initialized()
+        except ImportError:
+            pass
+        
+        # stdout 处理器（Ray 会自动捕获）
+        console_handler = logging.StreamHandler(sys.stdout)
+        # 改进日志格式，包含服务名称和版本
+        version_str = f" v{version}" if version else ""
+        formatter = logging.Formatter(
+            f'%(asctime)s - [{name}{version_str}] - %(levelname)s - %(message)s',
+            datefmt='%Y-%m-%d %H:%M:%S'
+        )
+        console_handler.setFormatter(formatter)
+        logger.addHandler(console_handler)
+        
+        # stderr 处理器用于错误日志（Ray 也会捕获）
+        error_handler = logging.StreamHandler(sys.stderr)
+        error_handler.setFormatter(formatter)
+        error_handler.setLevel(logging.ERROR)
+        logger.addHandler(error_handler)
+        
+        logger.setLevel(logging.INFO)
+        
+        # 在非 Ray 环境中，尝试添加文件处理器
+        if not is_ray_env:
+            try:
+                file_handler = logging.FileHandler(f"{name}.log", encoding='utf-8')
+                file_handler.setFormatter(formatter)
+                logger.addHandler(file_handler)
+            except (IOError, PermissionError):
+                pass
+
+    # 返回适配器，自动添加服务信息
+    return ServiceLoggerAdapter(logger, name, version)
+
+
+# 全局 logger 实例，方便用户直接导入使用
+_global_logger: Optional[ServiceLoggerAdapter] = None
+_global_service_name: Optional[str] = None
+_global_version: Optional[str] = None
+
+
+def set_service_context(service_name: str, version: Optional[str] = None):
+    """
+    设置全局服务上下文（服务名称和版本）
+    
+    当服务初始化时，会自动调用此函数设置上下文。
+    设置后，全局 logger 会自动包含服务信息。
+    
+    Args:
+        service_name: 服务名称
+        version: 服务版本（可选）
+    """
+    global _global_logger, _global_service_name, _global_version
+    _global_service_name = service_name
+    _global_version = version
+    # 重新创建 logger 以应用新的上下文
+    _global_logger = get_service_logger(service_name, version)
+
+
+def get_logger() -> ServiceLoggerAdapter:
+    """
+    获取全局 logger 实例
+    
+    如果已经设置了服务上下文（通过 set_service_context），返回带服务信息的 logger。
+    否则返回一个默认的 logger。
+    
+    Returns:
+        日志适配器实例
+    """
+    global _global_logger, _global_service_name, _global_version
+    
+    if _global_logger is None:
+        # 如果还没有设置服务上下文，创建一个默认的 logger
+        if _global_service_name:
+            _global_logger = get_service_logger(_global_service_name, _global_version)
+        else:
+            # 使用默认名称创建 logger
+            _global_logger = get_service_logger("unknown", None)
+    
+    return _global_logger
+
+
+# 创建一个延迟加载的 logger 包装类，确保在 Ray 环境中也能正常工作
+class _LazyLogger:
+    """
+    延迟加载的 logger 包装类，确保在 Ray 环境中也能正常工作
+    
+    这个类通过 __getattr__ 代理所有方法调用到底层的 ServiceLoggerAdapter 实例，
+    避免了模块级别全局变量在 Ray 序列化时可能出现的问题。
+    """
+    
+    def __getattr__(self, name):
+        """
+        延迟获取 logger 实例的属性
+        
+        每次访问属性时都会获取最新的 logger 实例，确保在 Ray 环境中
+        即使模块被重新导入，也能获取到正确的 logger。
+        """
+        logger_instance = get_logger()
+        attr = getattr(logger_instance, name)
+        # 如果属性是可调用的，返回一个包装函数以确保每次调用都使用最新的 logger
+        if callable(attr):
+            def wrapper(*args, **kwargs):
+                current_logger = get_logger()
+                method = getattr(current_logger, name)
+                return method(*args, **kwargs)
+            return wrapper
+        return attr
+    
+    def __call__(self, *args, **kwargs):
+        """如果 logger 被当作函数调用"""
+        logger_instance = get_logger()
+        return logger_instance(*args, **kwargs)
+    
+    def __repr__(self):
+        """返回 logger 的字符串表示"""
+        logger_instance = get_logger()
+        return repr(logger_instance)
+    
+    def __str__(self):
+        """返回 logger 的字符串表示"""
+        logger_instance = get_logger()
+        return str(logger_instance)
+    
+    def __dir__(self):
+        """返回 logger 的所有属性，用于 IDE 自动补全"""
+        logger_instance = get_logger()
+        return dir(logger_instance)
+
+# 创建延迟加载的 logger 实例
+logger = _LazyLogger()