symbolicai 0.20.2__py3-none-any.whl → 1.0.0__py3-none-any.whl

symai/backend/engines/lean/engine_lean4.py

@@ -1,11 +1,15 @@
-import os
 import subprocess
+import tempfile
+from pathlib import Path
+from typing import Any
+
 import docker
 import paramiko
-import tempfile
-from typing import Any, List, Tuple, Optional, Dict
-from ...base import Engine
+
 from ....symbol import Result
+from ....utils import UserMessage
+from ...base import Engine
+
 
 class LeanResult(Result):
     """
@@ -14,7 +18,7 @@ class LeanResult(Result):
     Attributes:
         _value (Dict[str, str]): A dictionary containing the output of the Lean execution.
     """
-    def __init__(self, value: Dict[str, str]) -> None:
+    def __init__(self, value: dict[str, str]) -> None:
         """
         Initializes a new LeanResult instance.
 
@@ -57,7 +61,7 @@ class LeanEngine(Engine):
         self.ssh_host: str = ssh_host
         self.ssh_port: int = ssh_port
         self.ssh_user: str = ssh_user
-        self.ssh_key_path: str = os.path.expanduser(ssh_key_path)
+        self.ssh_key_path: Path = Path(ssh_key_path).expanduser()
         self.docker_client: docker.DockerClient = docker.from_env()
         self.container: docker.models.containers.Container = self._ensure_container()
         self.name = self.__class__.__name__
@@ -85,7 +89,7 @@ class LeanEngine(Engine):
             existing_container: docker.models.containers.Container = self.docker_client.containers.get(container_name)
             existing_container.remove(force=True)
         except docker.errors.NotFound:
-            print(f"No existing container named '{container_name}' found. Proceeding to create a new one.")
+            UserMessage(f"No existing container named '{container_name}' found. Proceeding to create a new one.")
 
         dockerfile: str = """
         FROM buildpack-deps:buster
@@ -110,11 +114,11 @@ class LeanEngine(Engine):
         """
         with tempfile.NamedTemporaryFile("w", delete=False) as temp_dockerfile:
             temp_dockerfile.write(dockerfile)
-            dockerfile_path: str = temp_dockerfile.name
+            dockerfile_path = Path(temp_dockerfile.name)
 
         image: docker.models.images.Image
-        image, _ = self.docker_client.images.build(path=os.path.dirname(dockerfile_path), dockerfile=dockerfile_path, tag="lean4-container-image")
-        os.remove(dockerfile_path)
+        image, _ = self.docker_client.images.build(path=str(dockerfile_path.parent), dockerfile=str(dockerfile_path), tag="lean4-container-image")
+        dockerfile_path.unlink()
 
         container: docker.models.containers.Container = self.docker_client.containers.run(
             image.id,
@@ -129,15 +133,16 @@ class LeanEngine(Engine):
         Sets up SSH access to the Docker container, including generating an SSH key pair if necessary,
         and configuring the container to accept SSH connections using the generated key.
         """
-        if not os.path.exists(self.ssh_key_path):
-            subprocess.run(['ssh-keygen', '-t', 'rsa', '-b', '2048', '-f', self.ssh_key_path, '-N', ''], check=True)
+        if not self.ssh_key_path.exists():
+            subprocess.run(['ssh-keygen', '-t', 'rsa', '-b', '2048', '-f', str(self.ssh_key_path), '-N', ''], check=True)
 
         subprocess.run(['docker', 'exec', self.container.id, 'mkdir', '-p', '/root/.ssh'], check=True)
-        subprocess.run(['docker', 'cp', f'{self.ssh_key_path}.pub', f'{self.container.id}:/root/.ssh/authorized_keys'], check=True)
+        public_key_path = self.ssh_key_path.parent / f'{self.ssh_key_path.name}.pub'
+        subprocess.run(['docker', 'cp', str(public_key_path), f'{self.container.id}:/root/.ssh/authorized_keys'], check=True)
         subprocess.run(['docker', 'exec', self.container.id, 'chmod', '600', '/root/.ssh/authorized_keys'], check=True)
         subprocess.run(['docker', 'exec', self.container.id, 'chown', 'root:root', '/root/.ssh/authorized_keys'], check=True)
 
-    def forward(self, argument: Any) -> Tuple[List[LeanResult], dict]:
+    def forward(self, argument: Any) -> tuple[list[LeanResult], dict]:
         """
         Executes Lean code provided as a string or as an object property.
 
@@ -149,14 +154,14 @@ class LeanEngine(Engine):
         """
         code: str = argument if isinstance(argument, str) else argument.prop.prepared_input
 
-        rsp: Optional[LeanResult] = None
-        err: Optional[str] = None
-        tmpfile_path: Optional[str] = None
-        metadata: Dict[str, Any] = {}
+        rsp: LeanResult | None = None
+        err: str | None = None
+        tmpfile_path: Path | None = None
+        metadata: dict[str, Any] = {}
         try:
             with tempfile.NamedTemporaryFile(delete=False, suffix=".lean") as tmpfile:
                 tmpfile.write(code.encode())
-                tmpfile_path = tmpfile.name
+                tmpfile_path = Path(tmpfile.name)
 
             output, exec_metadata = self._execute_lean(tmpfile_path)
             metadata.update(exec_metadata)
@@ -168,17 +173,17 @@ class LeanEngine(Engine):
         except Exception as e:
             err = str(e)
             metadata.update({'status': 'error', 'message': err})
-            print(f"Error during Lean execution: {err}")
+            UserMessage(f"Error during Lean execution: {err}")
         finally:
-            if tmpfile_path and os.path.exists(tmpfile_path):
-                os.remove(tmpfile_path)
+            if tmpfile_path and tmpfile_path.exists():
+                tmpfile_path.unlink()
             if self.container:
-                print(f"Killing Docker container '{self.container.id}'...")
+                UserMessage(f"Killing Docker container '{self.container.id}'...")
                 self.container.remove(force=True)
 
         return [rsp] if rsp else [], metadata
 
-    def _execute_lean(self, filepath: str) -> Tuple[str, dict]:
+    def _execute_lean(self, filepath: str) -> tuple[str, dict]:
         """
         Executes a Lean script within the Docker container via SSH.
 
@@ -191,23 +196,23 @@ class LeanEngine(Engine):
         try:
             ssh = paramiko.SSHClient()
             ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
-            ssh.connect(self.ssh_host, port=self.ssh_port, username=self.ssh_user, key_filename=self.ssh_key_path)
+            ssh.connect(self.ssh_host, port=self.ssh_port, username=self.ssh_user, key_filename=str(self.ssh_key_path))
 
             elan_path: str = "/usr/local/elan/bin/elan"
             lean_path: str = "/usr/local/elan/bin/lean"
 
-            stdin, stdout, stderr = ssh.exec_command(f"{elan_path} default stable && {lean_path} --version")
+            _stdin, stdout, stderr = ssh.exec_command(f"{elan_path} default stable && {lean_path} --version")
             output: str = stdout.read().decode()
             error: str = stderr.read().decode()
-            print("SSH Command Output:", output)
-            print("SSH Command Error:", error)
+            UserMessage(f"SSH Command Output: {output}")
+            UserMessage(f"SSH Command Error: {error}")
 
             sftp = ssh.open_sftp()
-            remote_path: str = f"/root/{os.path.basename(filepath)}"
+            remote_path: str = f"/root/{Path(filepath).name}"
             sftp.put(filepath, remote_path)
             sftp.close()
 
-            stdin, stdout, stderr = ssh.exec_command(f"{lean_path} {remote_path}")
+            _stdin, stdout, stderr = ssh.exec_command(f"{lean_path} {remote_path}")
             output = stdout.read().decode()
             error = stderr.read().decode()
 
@@ -216,13 +221,12 @@ class LeanEngine(Engine):
 
             if "error" in output.lower() or "error" in error.lower():
                 return output, {'status': 'failure'}
-            elif not output and not error:
+            if not output and not error:
                 return "Lean program halted successfully with no output.", {'status': 'success'}
-            else:
-                return output, {'status': 'success'}
+            return output, {'status': 'success'}
 
         except Exception as e:
-            raise RuntimeError(f"SSH command execution failed: {str(e)}")
+            UserMessage(f"SSH command execution failed: {e!s}", raise_with=RuntimeError)
 
     def prepare(self, argument: Any) -> None:
         """

symai/backend/engines/neurosymbolic/__init__.py

@@ -1,8 +1,15 @@
-from ...mixin import (ANTHROPIC_CHAT_MODELS, ANTHROPIC_REASONING_MODELS,
-                      DEEPSEEK_CHAT_MODELS, DEEPSEEK_REASONING_MODELS,
-                      GOOGLE_CHAT_MODELS, GOOGLE_REASONING_MODELS,
-                      GROQ_CHAT_MODELS, GROQ_REASONING_MODELS,
-                      OPENAI_CHAT_MODELS, OPENAI_REASONING_MODELS)
+from ...mixin import (
+                      ANTHROPIC_CHAT_MODELS,
+                      ANTHROPIC_REASONING_MODELS,
+                      DEEPSEEK_CHAT_MODELS,
+                      DEEPSEEK_REASONING_MODELS,
+                      GOOGLE_CHAT_MODELS,
+                      GOOGLE_REASONING_MODELS,
+                      GROQ_CHAT_MODELS,
+                      GROQ_REASONING_MODELS,
+                      OPENAI_CHAT_MODELS,
+                      OPENAI_REASONING_MODELS,
+)
 from .engine_anthropic_claudeX_chat import ClaudeXChatEngine
 from .engine_anthropic_claudeX_reasoning import ClaudeXReasoningEngine
 from .engine_deepseekX_reasoning import DeepSeekXReasoningEngine
@@ -13,12 +20,33 @@ from .engine_openai_gptX_reasoning import GPTXReasoningEngine
 
 # create the mapping
 ENGINE_MAPPING = {
-    **{model_name: ClaudeXChatEngine for model_name in ANTHROPIC_CHAT_MODELS},
-    **{model_name: ClaudeXReasoningEngine for model_name in ANTHROPIC_REASONING_MODELS},
-    **{model_name: DeepSeekXReasoningEngine for model_name in DEEPSEEK_REASONING_MODELS},
-    **{model_name: GeminiXReasoningEngine for model_name in GOOGLE_REASONING_MODELS},
-    **{model_name: GPTXChatEngine for model_name in OPENAI_CHAT_MODELS},
-    **{model_name: GPTXReasoningEngine for model_name in OPENAI_REASONING_MODELS},
-    **{model_name: GroqEngine for model_name in GROQ_CHAT_MODELS},
-    **{model_name: GroqEngine for model_name in GROQ_REASONING_MODELS},
+    **dict.fromkeys(ANTHROPIC_CHAT_MODELS, ClaudeXChatEngine),
+    **dict.fromkeys(ANTHROPIC_REASONING_MODELS, ClaudeXReasoningEngine),
+    **dict.fromkeys(DEEPSEEK_REASONING_MODELS, DeepSeekXReasoningEngine),
+    **dict.fromkeys(GOOGLE_REASONING_MODELS, GeminiXReasoningEngine),
+    **dict.fromkeys(OPENAI_CHAT_MODELS, GPTXChatEngine),
+    **dict.fromkeys(OPENAI_REASONING_MODELS, GPTXReasoningEngine),
+    **dict.fromkeys(GROQ_CHAT_MODELS, GroqEngine),
+    **dict.fromkeys(GROQ_REASONING_MODELS, GroqEngine),
 }
+
+__all__ = [
+                      "ANTHROPIC_CHAT_MODELS",
+                      "ANTHROPIC_REASONING_MODELS",
+                      "DEEPSEEK_CHAT_MODELS",
+                      "DEEPSEEK_REASONING_MODELS",
+                      "ENGINE_MAPPING",
+                      "GOOGLE_CHAT_MODELS",
+                      "GOOGLE_REASONING_MODELS",
+                      "GROQ_CHAT_MODELS",
+                      "GROQ_REASONING_MODELS",
+                      "OPENAI_CHAT_MODELS",
+                      "OPENAI_REASONING_MODELS",
+                      "ClaudeXChatEngine",
+                      "ClaudeXReasoningEngine",
+                      "DeepSeekXReasoningEngine",
+                      "GPTXChatEngine",
+                      "GPTXReasoningEngine",
+                      "GeminiXReasoningEngine",
+                      "GroqEngine",
+]