codegnipy 0.0.1__py3-none-any.whl

codegnipy/__init__.py

@@ -0,0 +1,190 @@
+# Codegnipy - AI 原生的 Python 语言扩展
+"""
+Codegnipy 让非确定性的 AI 能力成为 Python 的一等公民。
+
+核心特性:
+- `~"prompt"` 操作符：将自然语言提示直接嵌入代码
+- `@cognitive` 装饰器：让函数由 LLM 实现
+- 记忆存储：会话级别的记忆管理
+- 反思循环：LLM 自我检查与修正
+- 异步调度：高性能并发调用
+- 确定性保证：类型约束、幻觉检测
+- 流式响应：实时输出支持
+- 工具调用：Function Calling 支持
+- 多提供商：OpenAI、Anthropic 等
+- 混合执行模型：确定性逻辑与模糊意图的无缝协同
+"""
+
+__version__ = "0.0.1"
+
+from .runtime import cognitive_call, CognitiveContext
+from .decorator import cognitive
+from .memory import (
+    MemoryStore,
+    InMemoryStore,
+    FileStore,
+    Message,
+    MessageRole,
+    ContextCompressor
+)
+from .reflection import (
+    Reflector,
+    ReflectionResult,
+    ReflectionStatus,
+    with_reflection,
+    ReflectiveCognitiveCall
+)
+from .scheduler import (
+    CognitiveScheduler,
+    ScheduledTask,
+    TaskStatus,
+    Priority,
+    SchedulerConfig,
+    RetryPolicy,
+    async_cognitive_call,
+    batch_call,
+    run_async
+)
+from .determinism import (
+    TypeConstraint,
+    PrimitiveConstraint,
+    EnumConstraint,
+    SchemaConstraint,
+    ListConstraint,
+    ValidationStatus,
+    ValidationResult,
+    SimulationMode,
+    Simulator,
+    HallucinationDetector,
+    HallucinationCheck,
+    deterministic_call
+)
+from .streaming import (
+    StreamStatus,
+    StreamChunk,
+    StreamResult,
+    stream_call,
+    stream_call_async,
+    stream_iter,
+    stream_iter_async
+)
+from .tools import (
+    ToolType,
+    ToolParameter,
+    ToolDefinition,
+    ToolCall,
+    ToolResult,
+    ToolRegistry,
+    tool,
+    call_with_tools,
+    register_tool,
+    get_global_registry
+)
+from .providers import (
+    ProviderType,
+    ProviderConfig,
+    BaseProvider,
+    OpenAIProvider,
+    AnthropicProvider,
+    OllamaProvider,
+    TransformersProvider,
+    ProviderFactory,
+    create_provider
+)
+from .validation import (
+    ExternalValidationStatus,
+    Evidence,
+    ExternalValidationResult,
+    BaseValidator,
+    WebSearchValidator,
+    KnowledgeGraphValidator,
+    FactCheckValidator,
+    CompositeValidator,
+    create_default_validator,
+    verify_claim,
+    verify_claim_async
+)
+
+__all__ = [
+    # Core
+    "cognitive_call",
+    "CognitiveContext",
+    "cognitive",
+    # Memory
+    "MemoryStore",
+    "InMemoryStore",
+    "FileStore",
+    "Message",
+    "MessageRole",
+    "ContextCompressor",
+    # Reflection
+    "Reflector",
+    "ReflectionResult",
+    "ReflectionStatus",
+    "with_reflection",
+    "ReflectiveCognitiveCall",
+    # Scheduler
+    "CognitiveScheduler",
+    "ScheduledTask",
+    "TaskStatus",
+    "Priority",
+    "SchedulerConfig",
+    "RetryPolicy",
+    "async_cognitive_call",
+    "batch_call",
+    "run_async",
+    # Determinism
+    "TypeConstraint",
+    "PrimitiveConstraint",
+    "EnumConstraint",
+    "SchemaConstraint",
+    "ListConstraint",
+    "ValidationStatus",
+    "ValidationResult",
+    "SimulationMode",
+    "Simulator",
+    "HallucinationDetector",
+    "HallucinationCheck",
+    "deterministic_call",
+    # Streaming
+    "StreamStatus",
+    "StreamChunk",
+    "StreamResult",
+    "stream_call",
+    "stream_call_async",
+    "stream_iter",
+    "stream_iter_async",
+    # Tools
+    "ToolType",
+    "ToolParameter",
+    "ToolDefinition",
+    "ToolCall",
+    "ToolResult",
+    "ToolRegistry",
+    "tool",
+    "call_with_tools",
+    "register_tool",
+    "get_global_registry",
+    # Providers
+    "ProviderType",
+    "ProviderConfig",
+    "BaseProvider",
+    "OpenAIProvider",
+    "AnthropicProvider",
+    "OllamaProvider",
+    "TransformersProvider",
+    "ProviderFactory",
+    "create_provider",
+    # Validation
+    "ExternalValidationStatus",
+    "Evidence",
+    "ExternalValidationResult",
+    "BaseValidator",
+    "WebSearchValidator",
+    "KnowledgeGraphValidator",
+    "FactCheckValidator",
+    "CompositeValidator",
+    "create_default_validator",
+    "verify_claim",
+    "verify_claim_async",
+]

codegnipy/cli.py

@@ -0,0 +1,153 @@
+"""
+Codegnipy 命令行接口
+
+提供 `codegnipy run` 和 `codegnipy repl` 命令。
+"""
+
+import argparse
+import sys
+from pathlib import Path
+from typing import Optional
+
+from .transformer import transform_code
+from .runtime import CognitiveContext
+import codegnipy
+
+
+def create_parser() -> argparse.ArgumentParser:
+    """创建命令行解析器"""
+    parser = argparse.ArgumentParser(
+        prog="codegnipy",
+        description="Codegnipy - AI 原生的 Python 语言扩展"
+    )
+    
+    subparsers = parser.add_subparsers(dest="command", help="可用命令")
+    
+    # run 命令
+    run_parser = subparsers.add_parser("run", help="运行 .py 文件")
+    run_parser.add_argument("file", help="要运行的 Python 文件")
+    run_parser.add_argument(
+        "--model", "-m",
+        default="gpt-4o-mini",
+        help="使用的 LLM 模型"
+    )
+    run_parser.add_argument(
+        "--api-key", "-k",
+        help="API 密钥（也可通过环境变量 OPENAI_API_KEY 设置）"
+    )
+    
+    # repl 命令
+    repl_parser = subparsers.add_parser("repl", help="启动交互式 REPL")
+    repl_parser.add_argument(
+        "--model", "-m",
+        default="gpt-4o-mini",
+        help="使用的 LLM 模型"
+    )
+    
+    # version 命令
+    subparsers.add_parser("version", help="显示版本信息")
+    
+    return parser
+
+
+def run_file(filepath: str, model: str, api_key: Optional[str] = None):
+    """运行 Codegnipy 文件"""
+    path = Path(filepath)
+    
+    if not path.exists():
+        print(f"错误: 文件不存在: {filepath}", file=sys.stderr)
+        sys.exit(1)
+    
+    if not path.suffix == ".py":
+        print(f"警告: 文件扩展名不是 .py: {filepath}", file=sys.stderr)
+    
+    # 读取源代码
+    source = path.read_text(encoding="utf-8")
+    
+    # 创建上下文并执行
+    with CognitiveContext(api_key=api_key, model=model):
+        # 准备执行环境
+        globals_ = {
+            "__name__": "__main__",
+            "__file__": str(path.absolute()),
+            "codegnipy": codegnipy,
+            "__cognitive_context__": CognitiveContext.get_current()
+        }
+        
+        # 转换并编译
+        tree = transform_code(source, str(path))
+        code = compile(tree, str(path), "exec")
+        
+        # 执行
+        try:
+            exec(code, globals_)
+        except Exception as e:
+            print(f"错误: {e}", file=sys.stderr)
+            sys.exit(1)
+
+
+def start_repl(model: str):
+    """启动交互式 REPL"""
+    import code
+    
+    print("Codegnipy REPL")
+    print(f"模型: {model}")
+    print("输入 Python 代码，~\"prompt\" 语法将调用 LLM")
+    print("输入 exit() 或 Ctrl+D 退出\n")
+    
+    # 创建上下文
+    ctx = CognitiveContext(model=model)
+    ctx.__enter__()
+    
+    # 准备 REPL 环境
+    local_vars = {
+        "codegnipy": codegnipy,
+        "__cognitive_context__": ctx
+    }
+    
+    # 自定义编译函数
+    class CognitiveConsole(code.InteractiveConsole):
+        def runsource(self, source, filename="<input>", symbol="single"):
+            try:
+                # 尝试转换
+                tree = transform_code(source, filename)
+                code_obj = compile(tree, filename, symbol)
+            except (SyntaxError, OverflowError) as e:
+                self.showsyntaxerror(e)
+                return False
+            
+            # 执行
+            try:
+                exec(code_obj, self.locals)
+            except SystemExit:
+                raise
+            except Exception:
+                self.showtraceback()
+            
+            return False
+    
+    console = CognitiveConsole(local_vars)
+    console.interact(banner="", exitmsg="再见！")
+    
+    # 清理
+    ctx.__exit__(None, None, None)
+
+
+def main():
+    """主入口"""
+    parser = create_parser()
+    args = parser.parse_args()
+    
+    if args.command == "run":
+        run_file(args.file, args.model, args.api_key)
+    elif args.command == "repl":
+        start_repl(args.model)
+    elif args.command == "version":
+        print(f"Codegnipy v{codegnipy.__version__}")
+    else:
+        parser.print_help()
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

codegnipy/decorator.py

@@ -0,0 +1,151 @@
+"""
+@cognitive 装饰器模块
+
+让函数由 LLM 实现，而非手写逻辑。
+"""
+
+from functools import wraps
+from typing import Callable, get_type_hints, Any, Optional
+import inspect
+
+from .runtime import cognitive_call
+
+
+def cognitive(func: Optional[Callable] = None, *, model: Optional[str] = None) -> Callable:
+    """
+    Decorator: Mark a function as cognitive, implemented by LLM.
+
+    The function's docstring serves as prompt template,
+    and the signature is used for input validation and output parsing.
+
+    Args:
+        func: The function to decorate
+        model: Specify the model to use (optional)
+
+    Examples:
+        @cognitive
+        def summarize(text: str) -> str:
+            '''Summarize the key points of this text in no more than 3 sentences.'''
+            pass
+
+        @cognitive(model="gpt-4")
+        def translate(text: str, target_lang: str = "English") -> str:
+            '''Translate the text to {target_lang}.'''
+            pass
+    """
+    def decorator(fn: Callable) -> Callable:
+        # 获取函数信息
+        sig = inspect.signature(fn)
+        hints = get_type_hints(fn) if hasattr(fn, '__annotations__') else {}
+        docstring = fn.__doc__ or f"执行函数 {fn.__name__}"
+
+        @wraps(fn)
+        def wrapper(*args, **kwargs):
+            # 绑定参数
+            bound = sig.bind(*args, **kwargs)
+            bound.apply_defaults()
+
+            # 构建提示
+            prompt = _build_prompt(docstring, bound.arguments)
+
+            # 调用 LLM
+            result = cognitive_call(prompt, model=model)
+
+            # 类型转换（如果指定了返回类型）
+            return_type = hints.get('return')
+            if return_type and return_type is not str:
+                result = _convert_result(result, return_type)
+
+            return result
+
+        # 标记为认知函数
+        wrapper._is_cognitive = True  # type: ignore[attr-defined]
+        wrapper._original_func = fn  # type: ignore[attr-defined]
+
+        return wrapper
+    
+    # 支持 @cognitive 和 @cognitive(...) 两种用法
+    if func is not None:
+        return decorator(func)
+    return decorator
+
+
+def _build_prompt(docstring: str, arguments: dict) -> str:
+    """
+    根据文档字符串和参数构建提示。
+    
+    支持 {param} 占位符语法。
+    """
+    prompt = docstring
+    
+    # 替换占位符
+    for key, value in arguments.items():
+        placeholder = "{" + key + "}"
+        if placeholder in prompt:
+            prompt = prompt.replace(placeholder, str(value))
+    
+    # 如果没有占位符，将参数附加到提示后
+    if "{" not in docstring and arguments:
+        args_str = "\n".join(f"- {k}: {v}" for k, v in arguments.items())
+        prompt = f"{docstring}\n\n参数:\n{args_str}"
+    
+    return prompt
+
+
+def _convert_result(result: str, target_type: type) -> Any:
+    """
+    将 LLM 结果转换为目标类型。
+    
+    目前支持：
+    - str: 直接返回
+    - int/float: 尝试解析数字
+    - bool: 解析布尔值
+    - list: 尝试解析 JSON 数组
+    - dict: 尝试解析 JSON 对象
+    """
+    if target_type is str:
+        return result
+    
+    if target_type is int:
+        try:
+            return int(result.strip())
+        except ValueError:
+            # 尝试提取数字
+            import re
+            match = re.search(r'-?\d+', result)
+            if match:
+                return int(match.group())
+            raise ValueError(f"无法将结果转换为整数: {result}")
+    
+    if target_type is float:
+        try:
+            return float(result.strip())
+        except ValueError:
+            import re
+            match = re.search(r'-?\d+\.?\d*', result)
+            if match:
+                return float(match.group())
+            raise ValueError(f"无法将结果转换为浮点数: {result}")
+    
+    if target_type is bool:
+        lower = result.strip().lower()
+        if lower in ('true', 'yes', '是', '1', '真'):
+            return True
+        if lower in ('false', 'no', '否', '0', '假'):
+            return False
+        raise ValueError(f"无法将结果转换为布尔值: {result}")
+    
+    if target_type in (list, dict):
+        import json
+        try:
+            return json.loads(result)
+        except json.JSONDecodeError:
+            # 尝试提取 JSON
+            import re
+            json_match = re.search(r'[\[{].*[\]}]', result, re.DOTALL)
+            if json_match:
+                return json.loads(json_match.group())
+            raise ValueError(f"无法将结果解析为 JSON: {result}")
+    
+    # 未知类型，返回原字符串
+    return result