wagent-framework 1.4.4__tar.gz → 1.5.2__tar.gz

{wagent_framework-1.4.4 → wagent_framework-1.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wagent-framework
-Version: 1.4.4
+Version: 1.5.2
 Summary: Python enterprise agent framework with AOP, IOC, and sandbox security
 Home-page: https://github.com/LuckyStar2456/W-Agent-FrameWork
 Author: LuckyStar2456
@@ -58,7 +58,7 @@ Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary
 
-# W-Agent v1.4.4
+# W-Agent v1.5.0
 
 [English](./README_EN.md) | 简体中文
 
@@ -670,12 +670,25 @@ export W_AGENT_RESILIENCE_RETRY_MAX_ATTEMPTS=5
 ## 📦 PyPI 包
 
 - **包名**: `wagent-framework`
-- **版本**: 1.4.4
+- **版本**: 1.5.1
 - **安装**: `pip install wagent-framework`
 - **PyPI 地址**: [https://pypi.org/project/wagent-framework/](https://pypi.org/project/wagent-framework/)
 
 ## 📝 更新日志
 
+### v1.5.1 (2026-04-27)
+- **版本更新**: 版本号更新至 1.5.1
+- **文档更新**: 完善了更新日志内容
+- **Bug 修复**: 修复了 LangChain 适配器在未安装 LangChain 时的导入错误
+- **Bug 修复**: 修复了生命周期方法绑定问题
+
+### v1.5.0 (2026-04-27)
+- **版本更新**: 版本号更新至 1.5.0
+- **Bug 修复**: 修复了 LangChain 适配器在未安装 LangChain 时的导入错误
+- **Bug 修复**: 修复了生命周期方法绑定问题
+- **文档更新**: 统一更新所有文档的导入路径
+- **文档修复**: 修复了 chat-agent 文档中的 Python 版本要求
+
 ### v1.4.4 (2026-04-26)
 - **框架优化**: 完善了核心功能的稳定性和性能
 - **代码质量**: 提升了代码的可维护性和可读性

{wagent_framework-1.4.4 → wagent_framework-1.5.2}/README.md

@@ -1,4 +1,4 @@
-# W-Agent v1.4.4
+# W-Agent v1.5.0
 
 [English](./README_EN.md) | 简体中文
 
@@ -610,12 +610,25 @@ export W_AGENT_RESILIENCE_RETRY_MAX_ATTEMPTS=5
 ## 📦 PyPI 包
 
 - **包名**: `wagent-framework`
-- **版本**: 1.4.4
+- **版本**: 1.5.1
 - **安装**: `pip install wagent-framework`
 - **PyPI 地址**: [https://pypi.org/project/wagent-framework/](https://pypi.org/project/wagent-framework/)
 
 ## 📝 更新日志
 
+### v1.5.1 (2026-04-27)
+- **版本更新**: 版本号更新至 1.5.1
+- **文档更新**: 完善了更新日志内容
+- **Bug 修复**: 修复了 LangChain 适配器在未安装 LangChain 时的导入错误
+- **Bug 修复**: 修复了生命周期方法绑定问题
+
+### v1.5.0 (2026-04-27)
+- **版本更新**: 版本号更新至 1.5.0
+- **Bug 修复**: 修复了 LangChain 适配器在未安装 LangChain 时的导入错误
+- **Bug 修复**: 修复了生命周期方法绑定问题
+- **文档更新**: 统一更新所有文档的导入路径
+- **文档修复**: 修复了 chat-agent 文档中的 Python 版本要求
+
 ### v1.4.4 (2026-04-26)
 - **框架优化**: 完善了核心功能的稳定性和性能
 - **代码质量**: 提升了代码的可维护性和可读性

{wagent_framework-1.4.4 → wagent_framework-1.5.2}/setup.py

@@ -8,7 +8,7 @@ with open(os.path.join(here, 'README.md'), 'r', encoding='utf-8') as f:
 
 setup(
     name="wagent-framework",
-    version="1.4.4",
+    version="1.5.2",
     description="Python enterprise agent framework with AOP, IOC, and sandbox security",
     long_description=long_description,
     long_description_content_type="text/markdown",

{wagent_framework-1.4.4 → wagent_framework-1.5.2}/w_agent/__init__.py

@@ -1,6 +1,6 @@
 """W-Agent 框架包"""
 
-__version__ = "1.4.4"
+__version__ = "1.5.1"
 __author__ = "LuckyStar2456"
 __license__ = "MIT"
 
@@ -10,7 +10,7 @@ from w_agent.container.bean_factory import BeanFactory, BeanDefinition, Scope
 from w_agent.config.dynamic_config import DynamicConfigManager
 from w_agent.core.decorators import (
     AgentComponent, ServiceComponent, ToolComponent,
-    RepositoryComponent, ControllerComponent,
+    RepositoryComponent, ControllerComponent, Component,
     PostConstruct, PreDestroy, Autowired, Qualifier,
     Retry, CircuitBreaker
 )
@@ -31,6 +31,9 @@ from w_agent.skills.sandbox.wasm_sandbox import WasmSkillSandbox
 from w_agent.skills.sandbox.nsjail_sandbox import NsJailSkillSandbox
 from w_agent.skills.skill import Skill
 from w_agent.exceptions.framework_errors import BeanNotFoundError, InjectionError
+from w_agent.scanner.parallel_scanner import ParallelASTScanner
+from w_agent.lifecycle.graceful_shutdown import GracefulShutdownManager
+from w_agent.tools.langchain_adapter import LangChainToolAdapter
 
 __all__ = [
     "BaseAgent",
@@ -43,6 +46,7 @@ __all__ = [
     "ToolComponent",
     "RepositoryComponent",
     "ControllerComponent",
+    "Component",
     "PostConstruct",
     "PreDestroy",
     "Autowired",
@@ -55,6 +59,7 @@ __all__ = [
     "Doctor",
     "LifecycleManager",
     "LifecycleOrder",
+    "GracefulShutdownManager",
     "ResilienceManager",
     "AspectJPointcut",
     "BeforeAdvice",
@@ -74,5 +79,7 @@ __all__ = [
     "NsJailSkillSandbox",
     "Skill",
     "BeanNotFoundError",
-    "InjectionError"
+    "InjectionError",
+    "ParallelASTScanner",
+    "LangChainToolAdapter"
 ]

{wagent_framework-1.4.4 → wagent_framework-1.5.2}/w_agent/__main__.py

@@ -34,7 +34,7 @@ async def main():
         result = await agent.arun(prompt)
         print(result)
     else:
-        print("W-Agent v1.4.4")
+        print("W-Agent v1.5.0")
         print("Usage: python -m w_agent <prompt>")
 
 if __name__ == "__main__":

{wagent_framework-1.4.4 → wagent_framework-1.5.2}/w_agent/aop/aspects.py

@@ -1,162 +1,162 @@
-"""AOP切面实现"""
-
-from typing import Callable, Any
-import asyncio
-import time
-from w_agent.aop.pointcut import AroundAdvice
-from w_agent.core.event_bus import EventBus, Event
-from w_agent.observability.tracing import global_tracer
-
-class RetryAspect:
-    """重试切面"""
-    def __init__(self, event_bus: EventBus = None):
-        self.event_bus = event_bus
-    
-    def create_advice(self, func: Callable) -> AroundAdvice:
-        """创建重试通知"""
-        max_attempts = getattr(func, "__retry_max_attempts__", 3)
-        delay = getattr(func, "__retry_delay__", 0.1)
-        backoff = getattr(func, "__retry_backoff__", 2.0)
-        retry_exceptions = getattr(func, "__retry_exceptions__", (Exception,))
-        
-        async def advice(joinpoint, proceed):
-            span = global_tracer.start_span("aop.retry", attributes={"function": f"{func.__module__}.{func.__name__}", "max_attempts": max_attempts})
-            attempts = 0
-            current_delay = delay
-            fallback_method = getattr(func, "__retry_fallback__", None)
-            
-            try:
-                while attempts < max_attempts:
-                    try:
-                        if self.event_bus:
-                            await self.event_bus.emit(Event(
-                                name="retry.attempt",
-                                payload={"attempt": attempts + 1, "max_attempts": max_attempts}
-                            ))
-                        
-                        sub_span = global_tracer.start_span("aop.retry.attempt", attributes={"attempt": attempts + 1})
-                        result = await proceed()
-                        global_tracer.end_span(sub_span)
-                        return result
-                    except retry_exceptions as e:
-                        attempts += 1
-                        if attempts >= max_attempts:
-                            if self.event_bus:
-                                await self.event_bus.emit(Event(
-                                    name="retry.failed",
-                                    payload={"attempts": attempts, "error": str(e)}
-                                ))
-                            # 尝试调用fallback方法
-                            if fallback_method and hasattr(joinpoint.target, fallback_method):
-                                try:
-                                    fallback = getattr(joinpoint.target, fallback_method)
-                                    return fallback(*joinpoint.args, **joinpoint.kwargs)
-                                except Exception as fallback_error:
-                                    raise Exception(f"Retry failed after {max_attempts} attempts, and fallback method {fallback_method} also failed: {str(fallback_error)}") from e
-                            raise Exception(f"Retry failed after {max_attempts} attempts: {str(e)}") from e
-                        
-                        if self.event_bus:
-                            await self.event_bus.emit(Event(
-                                name="retry.retrying",
-                                payload={"attempt": attempts, "delay": current_delay, "error": str(e)}
-                            ))
-                        
-                        await asyncio.sleep(current_delay)
-                        current_delay *= backoff
-            finally:
-                global_tracer.end_span(span)
-        
-        return AroundAdvice(advice)
-
-class CircuitBreakerAspect:
-    """断路器切面"""
-    def __init__(self, event_bus: EventBus = None):
-        self.event_bus = event_bus
-        self._state = {}
-    
-    def create_advice(self, func: Callable) -> AroundAdvice:
-        """创建断路器通知"""
-        failure_threshold = getattr(func, "__circuit_breaker_failure_threshold__", 5)
-        recovery_timeout = getattr(func, "__circuit_breaker_recovery_timeout__", 30.0)
-        fallback_method = getattr(func, "__circuit_breaker_fallback_method__", None)
-        
-        func_key = f"{func.__module__}.{func.__name__}"
-        
-        # 初始化状态
-        if func_key not in self._state:
-            self._state[func_key] = {
-                "state": "CLOSED",  # CLOSED, OPEN, HALF_OPEN
-                "failure_count": 0,
-                "last_failure_time": 0,
-                "consecutive_successes": 0
-            }
-        
-        async def advice(joinpoint, proceed):
-            span = global_tracer.start_span("aop.circuit_breaker", attributes={"function": func_key, "state": self._state[func_key]["state"]})
-            state = self._state[func_key]
-            
-            try:
-                # 检查是否应该从OPEN状态切换到HALF_OPEN
-                if state["state"] == "OPEN":
-                    if time.time() - state["last_failure_time"] > recovery_timeout:
-                        state["state"] = "HALF_OPEN"
-                        if self.event_bus:
-                            await self.event_bus.emit(Event(
-                                name="circuit_breaker.half_open",
-                                payload={"function": func_key}
-                            ))
-                    else:
-                        # 快速失败
-                        if self.event_bus:
-                            await self.event_bus.emit(Event(
-                                name="circuit_breaker.open",
-                                payload={"function": func_key}
-                            ))
-                        if fallback_method and hasattr(joinpoint.target, fallback_method):
-                            try:
-                                fallback = getattr(joinpoint.target, fallback_method)
-                                return fallback(*joinpoint.args, **joinpoint.kwargs)
-                            except Exception as fallback_error:
-                                raise Exception(f"Circuit breaker is open, and fallback method {fallback_method} also failed: {str(fallback_error)}")
-                        raise Exception(f"Circuit breaker is open for {func_key}")
-                
-                try:
-                    sub_span = global_tracer.start_span("aop.circuit_breaker.execute")
-                    result = await proceed()
-                    global_tracer.end_span(sub_span)
-                    
-                    # 处理成功
-                    if state["state"] == "HALF_OPEN":
-                        state["consecutive_successes"] += 1
-                        if state["consecutive_successes"] >= 3:  # 连续成功3次后关闭
-                            state["state"] = "CLOSED"
-                            state["failure_count"] = 0
-                            state["consecutive_successes"] = 0
-                            if self.event_bus:
-                                await self.event_bus.emit(Event(
-                                    name="circuit_breaker.closed",
-                                    payload={"function": func_key}
-                                ))
-                    else:
-                        state["failure_count"] = 0
-                    
-                    return result
-                except Exception as e:
-                    # 处理失败
-                    state["failure_count"] += 1
-                    state["last_failure_time"] = time.time()
-                    state["consecutive_successes"] = 0
-                    
-                    if state["state"] == "CLOSED" and state["failure_count"] >= failure_threshold:
-                        state["state"] = "OPEN"
-                        if self.event_bus:
-                            await self.event_bus.emit(Event(
-                                name="circuit_breaker.opened",
-                                payload={"function": func_key, "failure_count": state["failure_count"]}
-                            ))
-                    
-                    raise
-            finally:
-                global_tracer.end_span(span)
-        
+"""AOP切面实现"""
+
+from typing import Callable, Any
+import asyncio
+import time
+from w_agent.aop.pointcut import AroundAdvice
+from w_agent.core.event_bus import EventBus, Event
+from w_agent.observability.tracing import global_tracer
+
+class RetryAspect:
+    """重试切面"""
+    def __init__(self, event_bus: EventBus = None):
+        self.event_bus = event_bus
+    
+    def create_advice(self, func: Callable) -> AroundAdvice:
+        """创建重试通知"""
+        max_attempts = getattr(func, "__retry_max_attempts__", 3)
+        delay = getattr(func, "__retry_delay__", 0.1)
+        backoff = getattr(func, "__retry_backoff__", 2.0)
+        retry_exceptions = getattr(func, "__retry_exceptions__", (Exception,))
+        
+        async def advice(joinpoint, proceed):
+            span = global_tracer.start_span("aop.retry", attributes={"function": f"{func.__module__}.{func.__name__}", "max_attempts": max_attempts})
+            attempts = 0
+            current_delay = delay
+            fallback_method = getattr(func, "__retry_fallback__", None)
+            
+            try:
+                while attempts < max_attempts:
+                    try:
+                        if self.event_bus:
+                            await self.event_bus.emit(Event(
+                                name="retry.attempt",
+                                payload={"attempt": attempts + 1, "max_attempts": max_attempts}
+                            ))
+                        
+                        sub_span = global_tracer.start_span("aop.retry.attempt", attributes={"attempt": attempts + 1})
+                        result = await proceed()
+                        global_tracer.end_span(sub_span)
+                        return result
+                    except retry_exceptions as e:
+                        attempts += 1
+                        if attempts >= max_attempts:
+                            if self.event_bus:
+                                await self.event_bus.emit(Event(
+                                    name="retry.failed",
+                                    payload={"attempts": attempts, "error": str(e)}
+                                ))
+                            # 尝试调用fallback方法
+                            if fallback_method and hasattr(joinpoint.target, fallback_method):
+                                try:
+                                    fallback = getattr(joinpoint.target, fallback_method)
+                                    return fallback(*joinpoint.args, **joinpoint.kwargs)
+                                except Exception as fallback_error:
+                                    raise Exception(f"Retry failed after {max_attempts} attempts, and fallback method {fallback_method} also failed: {str(fallback_error)}") from e
+                            raise Exception(f"Retry failed after {max_attempts} attempts: {str(e)}") from e
+                        
+                        if self.event_bus:
+                            await self.event_bus.emit(Event(
+                                name="retry.retrying",
+                                payload={"attempt": attempts, "delay": current_delay, "error": str(e)}
+                            ))
+                        
+                        await asyncio.sleep(current_delay)
+                        current_delay *= backoff
+            finally:
+                global_tracer.end_span(span)
+        
+        return AroundAdvice(advice)
+
+class CircuitBreakerAspect:
+    """断路器切面"""
+    def __init__(self, event_bus: EventBus = None):
+        self.event_bus = event_bus
+        self._state = {}
+    
+    def create_advice(self, func: Callable) -> AroundAdvice:
+        """创建断路器通知"""
+        failure_threshold = getattr(func, "__circuit_breaker_failure_threshold__", 5)
+        recovery_timeout = getattr(func, "__circuit_breaker_recovery_timeout__", 30.0)
+        fallback_method = getattr(func, "__circuit_breaker_fallback_method__", None)
+        
+        func_key = f"{func.__module__}.{func.__name__}"
+        
+        # 初始化状态
+        if func_key not in self._state:
+            self._state[func_key] = {
+                "state": "CLOSED",  # CLOSED, OPEN, HALF_OPEN
+                "failure_count": 0,
+                "last_failure_time": 0,
+                "consecutive_successes": 0
+            }
+        
+        async def advice(joinpoint, proceed):
+            span = global_tracer.start_span("aop.circuit_breaker", attributes={"function": func_key, "state": self._state[func_key]["state"]})
+            state = self._state[func_key]
+            
+            try:
+                # 检查是否应该从OPEN状态切换到HALF_OPEN
+                if state["state"] == "OPEN":
+                    if time.time() - state["last_failure_time"] > recovery_timeout:
+                        state["state"] = "HALF_OPEN"
+                        if self.event_bus:
+                            await self.event_bus.emit(Event(
+                                name="circuit_breaker.half_open",
+                                payload={"function": func_key}
+                            ))
+                    else:
+                        # 快速失败
+                        if self.event_bus:
+                            await self.event_bus.emit(Event(
+                                name="circuit_breaker.open",
+                                payload={"function": func_key}
+                            ))
+                        if fallback_method and hasattr(joinpoint.target, fallback_method):
+                            try:
+                                fallback = getattr(joinpoint.target, fallback_method)
+                                return fallback(*joinpoint.args, **joinpoint.kwargs)
+                            except Exception as fallback_error:
+                                raise Exception(f"Circuit breaker is open, and fallback method {fallback_method} also failed: {str(fallback_error)}")
+                        raise Exception(f"Circuit breaker is open for {func_key}")
+                
+                try:
+                    sub_span = global_tracer.start_span("aop.circuit_breaker.execute")
+                    result = await proceed()
+                    global_tracer.end_span(sub_span)
+                    
+                    # 处理成功
+                    if state["state"] == "HALF_OPEN":
+                        state["consecutive_successes"] += 1
+                        if state["consecutive_successes"] >= 3:  # 连续成功3次后关闭
+                            state["state"] = "CLOSED"
+                            state["failure_count"] = 0
+                            state["consecutive_successes"] = 0
+                            if self.event_bus:
+                                await self.event_bus.emit(Event(
+                                    name="circuit_breaker.closed",
+                                    payload={"function": func_key}
+                                ))
+                    else:
+                        state["failure_count"] = 0
+                    
+                    return result
+                except Exception as e:
+                    # 处理失败
+                    state["failure_count"] += 1
+                    state["last_failure_time"] = time.time()
+                    state["consecutive_successes"] = 0
+                    
+                    if state["state"] == "CLOSED" and state["failure_count"] >= failure_threshold:
+                        state["state"] = "OPEN"
+                        if self.event_bus:
+                            await self.event_bus.emit(Event(
+                                name="circuit_breaker.opened",
+                                payload={"function": func_key, "failure_count": state["failure_count"]}
+                            ))
+                    
+                    raise
+            finally:
+                global_tracer.end_span(span)
+        
         return AroundAdvice(advice)