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

symai/backend/engines/drawing/engine_gpt_image.py

@@ -1,13 +1,14 @@
 import base64
+import contextlib
 import logging
 import tempfile
 from pathlib import Path
-from typing import Optional
 
 import openai
 import requests
 
 from ....symbol import Result
+from ....utils import UserMessage
 from ...base import Engine
 from ...settings import SYMAI_CONFIG
 
@@ -31,15 +32,16 @@ class GPTImageResult(Result):
         for item in value.data:
             has_url = hasattr(item, "url")
             has_b64 = hasattr(item, "b64_json")
-            path = tempfile.NamedTemporaryFile(suffix=".png", delete=False).name
+            with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as tmp_file:
+                path = tmp_file.name
             if has_url and item.url is not None:
                 request = requests.get(item.url, allow_redirects=True)
                 request.raise_for_status()
-                with open(path, "wb") as f:
+                with Path(path).open("wb") as f:
                     f.write(request.content)
             elif has_b64 and item.b64_json is not None:
                 raw = base64.b64decode(item.b64_json)
-                with open(path, "wb") as f:
+                with Path(path).open("wb") as f:
                     f.write(raw)
             imgs.append(path)
         self._value = imgs
@@ -47,14 +49,14 @@ class GPTImageResult(Result):
 
 class GPTImageEngine(Engine):
     """
-    A drop‐in engine for OpenAI's unified Images API,
+    A drop-in engine for OpenAI's unified Images API,
     supporting gpt-image-1, dall-e-2, dall-e-3,
     with all the extra parameters (background, moderation, etc).
     """
     def __init__(
         self,
-        api_key: Optional[str] = None,
-        model: Optional[str] = None,
+        api_key: str | None = None,
+        model: str | None = None,
     ):
         super().__init__()
         self.config = SYMAI_CONFIG
@@ -83,7 +85,7 @@ class GPTImageEngine(Engine):
 
     def command(self, *args, **kwargs):
         """
-        Allow hot‐swapping API key or model at runtime.
+        Allow hot-swapping API key or model at runtime.
         """
         super().command(*args, **kwargs)
         if "DRAWING_ENGINE_API_KEY" in kwargs:
@@ -105,98 +107,117 @@ class GPTImageEngine(Engine):
         operation = kwargs.get("operation")
 
         if operation is None:
-            raise ValueError("Operation not specified!")
+            UserMessage("Operation not specified!", raise_with=ValueError)
 
         n = kwargs.get("n", 1)
 
-        if "size" in kwargs:
-            if isinstance(kwargs["size"], int):
-                s = kwargs["size"]
-                kwargs["size"] = f"{s}x{s}"
+        self._normalize_size(kwargs)
 
         except_remedy = kwargs.get("except_remedy", None)
 
         callback = None
         try:
-            if operation == "create":
-                create_kwargs = {
-                    "model": model,
-                    "prompt": prompt,
-                    "n": n,
-                    "size": kwargs.get("size"),
-                }
-
-                if model == "dall-e-3":
-                    create_kwargs["response_format"] = kwargs.get("response_format", "url")
-                    create_kwargs["quality"] = kwargs.get("quality", "standard")
-                    create_kwargs["style"] = kwargs.get("style", "vivid")
-
-                if model.startswith("gpt-image-"):
-                    create_kwargs["quality"] = kwargs.get("quality", "medium")
-                    create_kwargs["moderation"] = kwargs.get("moderation", "auto")
-                    create_kwargs["background"] = kwargs.get("background", "auto")
-                    create_kwargs["output_format"] = kwargs.get("output_compression", "png")
-                    if create_kwargs["output_format"] == "jpeg" or create_kwargs["output_format"] == "webp":
-                        create_kwargs["output_compression"] = kwargs.get("output_compression", "100")
-
-                callback = openai.images.generate
-                res = openai.images.generate(**create_kwargs)
-
-            elif operation == "variation":
-                assert "image_path" in kwargs, "image_path required for variation"
-                callback = openai.images.create_variation
-                with open(kwargs["image_path"], "rb") as img:
-                    res = openai.images.create_variation(
-                        model=model,
-                        image=img,
-                        n=n,
-                        size=kwargs.get("size"),
-                        response_format=kwargs.get("response_format", "url"),
-                    )
-
-            elif operation == "edit":
-                assert "image_path" in kwargs, "image_path required for edit"
-                # allow either a single path or a list of paths
-                img_paths = kwargs["image_path"]
-                if not isinstance(img_paths, (list, tuple)):
-                    img_paths = [img_paths]
-                # open all images
-                image_files = [open(p, "rb") for p in img_paths]
-                # optional mask (only for the first image)
-                mask_file = None
-                if "mask_path" in kwargs and kwargs["mask_path"] is not None:
-                    mask_file = open(kwargs["mask_path"], "rb")
-                # construct API args
-                edit_kwargs = {
-                    "model": model,
-                    "image": image_files if len(image_files) > 1 else image_files[0],
-                    "prompt": prompt,
-                    "n": n,
-                    "size": kwargs.get("size"),
-                }
-
-                if model.startswith("gpt-image-"):
-                    edit_kwargs["quality"] = kwargs.get("quality", "auto")
-
-                if mask_file:
-                    edit_kwargs["mask"] = mask_file
-                callback = openai.images.edit
-
-                res = openai.images.edit(**edit_kwargs)
-                # clean up file handles
-                for f in image_files:
-                    f.close()
-                if mask_file:
-                    mask_file.close()
-            else:
-                raise ValueError(f"Unknown image operation: {operation}")
-
+            callback = self._resolve_callback(operation)
+            callback, res = self._dispatch_operation(
+                operation=operation,
+                prompt=prompt,
+                model=model,
+                n=n,
+                kwargs=kwargs,
+            )
         except Exception as e:
             if except_remedy is None:
                 raise
             res = except_remedy(self, e, callback, argument)
 
-        # wrap it up
         metadata = {}
         result = GPTImageResult(res)
         return [result], metadata
+
+    def _normalize_size(self, kwargs):
+        if "size" in kwargs and isinstance(kwargs["size"], int):
+            s = kwargs["size"]
+            kwargs["size"] = f"{s}x{s}"
+
+    def _resolve_callback(self, operation):
+        if operation == "create":
+            return openai.images.generate
+        if operation == "variation":
+            return openai.images.create_variation
+        if operation == "edit":
+            return openai.images.edit
+        UserMessage(f"Unknown image operation: {operation}", raise_with=ValueError)
+        return openai.images.generate
+
+    def _dispatch_operation(self, operation, prompt, model, n, kwargs):
+        if operation == "create":
+            return self._execute_create(prompt, model, n, kwargs)
+        if operation == "variation":
+            return self._execute_variation(model, n, kwargs)
+        if operation == "edit":
+            return self._execute_edit(prompt, model, n, kwargs)
+        return UserMessage(f"Unknown image operation: {operation}", raise_with=ValueError)
+
+    def _execute_create(self, prompt, model, n, kwargs):
+        create_kwargs = {
+            "model": model,
+            "prompt": prompt,
+            "n": n,
+            "size": kwargs.get("size"),
+        }
+
+        if model == "dall-e-3":
+            create_kwargs["response_format"] = kwargs.get("response_format", "url")
+            create_kwargs["quality"] = kwargs.get("quality", "standard")
+            create_kwargs["style"] = kwargs.get("style", "vivid")
+
+        if model.startswith("gpt-image-"):
+            create_kwargs["quality"] = kwargs.get("quality", "medium")
+            create_kwargs["moderation"] = kwargs.get("moderation", "auto")
+            create_kwargs["background"] = kwargs.get("background", "auto")
+            create_kwargs["output_format"] = kwargs.get("output_compression", "png")
+            if create_kwargs["output_format"] == "jpeg" or create_kwargs["output_format"] == "webp":
+                create_kwargs["output_compression"] = kwargs.get("output_compression", "100")
+
+        callback = openai.images.generate
+        return callback, callback(**create_kwargs)
+
+    def _execute_variation(self, model, n, kwargs):
+        assert "image_path" in kwargs, "image_path required for variation"
+        callback = openai.images.create_variation
+        with Path(kwargs["image_path"]).open("rb") as img:
+            result = callback(
+                model=model,
+                image=img,
+                n=n,
+                size=kwargs.get("size"),
+                response_format=kwargs.get("response_format", "url"),
+            )
+        return callback, result
+
+    def _execute_edit(self, prompt, model, n, kwargs):
+        assert "image_path" in kwargs, "image_path required for edit"
+        img_paths = kwargs["image_path"]
+        if not isinstance(img_paths, (list, tuple)):
+            img_paths = [img_paths]
+        with contextlib.ExitStack() as stack:
+            image_files = [stack.enter_context(Path(p).open("rb")) for p in img_paths]
+            mask_file = None
+            if "mask_path" in kwargs and kwargs["mask_path"] is not None:
+                mask_file = stack.enter_context(Path(kwargs["mask_path"]).open("rb"))
+            edit_kwargs = {
+                "model": model,
+                "image": image_files if len(image_files) > 1 else image_files[0],
+                "prompt": prompt,
+                "n": n,
+                "size": kwargs.get("size"),
+            }
+
+            if model.startswith("gpt-image-"):
+                edit_kwargs["quality"] = kwargs.get("quality", "auto")
+
+            if mask_file:
+                edit_kwargs["mask"] = mask_file
+            callback = openai.images.edit
+            result = callback(**edit_kwargs)
+        return callback, result

symai/backend/engines/embedding/engine_llama_cpp.py

@@ -1,14 +1,12 @@
 import asyncio
 import logging
-from multiprocessing import Value
-from typing import Optional
+from typing import Any, ClassVar
 
 import aiohttp
 import nest_asyncio
-import numpy as np
 
 from ....core_ext import retry
-from ....utils import CustomUserWarning
+from ....utils import UserMessage
 from ...base import Engine
 from ...settings import SYMAI_CONFIG, SYMSERVER_CONFIG
 
@@ -18,7 +16,7 @@ logging.getLogger("httpx").setLevel(logging.ERROR)
 logging.getLogger("httpcore").setLevel(logging.ERROR)
 
 class LlamaCppEmbeddingEngine(Engine):
-    _retry_params = {
+    _retry_params: ClassVar[dict[str, Any]] = {
         'tries': 5,
         'delay': 2,
         'max_delay': 60,
@@ -26,7 +24,7 @@ class LlamaCppEmbeddingEngine(Engine):
         'jitter': (1, 5),
         'graceful': True
     }
-    _timeout_params = {
+    _timeout_params: ClassVar[dict[str, Any]] = {
         'read': None,
         'connect': None,
     }
@@ -41,7 +39,7 @@ class LlamaCppEmbeddingEngine(Engine):
         if self.id() != 'embedding':
             return
         if not SYMSERVER_CONFIG.get('online'):
-            CustomUserWarning('You are using the llama.cpp embedding engine, but the server endpoint is not started. Please start the server with `symserver [--args]`.', raise_with=ValueError)
+            UserMessage('You are using the llama.cpp embedding engine, but the server endpoint is not started. Please start the server with `symserver [--args]`.', raise_with=ValueError)
 
         self.server_endpoint = f"http://{SYMSERVER_CONFIG.get('--host')}:{SYMSERVER_CONFIG.get('--port')}"
         self.timeout_params = self._validate_timeout_params(timeout_params)
@@ -60,13 +58,13 @@ class LlamaCppEmbeddingEngine(Engine):
 
     def _validate_timeout_params(self, timeout_params):
         if not isinstance(timeout_params, dict):
-            raise ValueError("timeout_params must be a dictionary")
+            UserMessage("timeout_params must be a dictionary", raise_with=ValueError)
         assert all(key in timeout_params for key in ['read', 'connect']), "Available keys: ['read', 'connect']"
         return timeout_params
 
     def _validate_retry_params(self, retry_params):
         if not isinstance(retry_params, dict):
-            raise ValueError("retry_params must be a dictionary")
+            UserMessage("retry_params must be a dictionary", raise_with=ValueError)
         assert all(key in retry_params for key in ['tries', 'delay', 'max_delay', 'backoff', 'jitter', 'graceful']), \
             "Available keys: ['tries', 'delay', 'max_delay', 'backoff', 'jitter', 'graceful']"
         return retry_params
@@ -77,14 +75,16 @@ class LlamaCppEmbeddingEngine(Engine):
         try:
             current_loop = asyncio.get_event_loop()
             if current_loop.is_closed():
-                raise RuntimeError("Event loop is closed.")
+                msg = "Event loop is closed."
+                UserMessage(msg)
+                raise RuntimeError(msg)
             return current_loop
         except RuntimeError:
             new_loop = asyncio.new_event_loop()
             asyncio.set_event_loop(new_loop)
             return new_loop
 
-    async def _arequest(self, text: str) -> dict:
+    async def _arequest(self, text: str, embd_normalize: str) -> dict:
         """Makes an async HTTP request to the llama.cpp server."""
         @retry(**self.retry_params)
         async def _make_request():
@@ -92,14 +92,13 @@ class LlamaCppEmbeddingEngine(Engine):
                 sock_connect=self.timeout_params['connect'],
                 sock_read=self.timeout_params['read']
             )
-            async with aiohttp.ClientSession(timeout=timeout) as session:
-                async with session.post(
-                    f"{self.server_endpoint}/v1/embeddings",
-                    json={"input": text}
-                ) as res:
-                    if res.status != 200:
-                        raise ValueError(f"Request failed with status code: {res.status}")
-                    return await res.json()
+            async with aiohttp.ClientSession(timeout=timeout) as session, session.post(
+                f"{self.server_endpoint}/v1/embeddings",
+                json={"content": text, "embd_normalize": embd_normalize}
+            ) as res:
+                if res.status != 200:
+                    UserMessage(f"Request failed with status code: {res.status}", raise_with=ValueError)
+                return await res.json()
 
         return await _make_request()
 
@@ -108,23 +107,21 @@ class LlamaCppEmbeddingEngine(Engine):
         kwargs = argument.kwargs
 
         inp = prepared_input if isinstance(prepared_input, list) else [prepared_input]
+        embd_normalize = kwargs.get('embd_normalize', -1) # -1 = no normalization
+
         new_dim = kwargs.get('new_dim')
+        if new_dim:
+            UserMessage("new_dim is not yet supported", raise_with=NotImplementedError)
 
         nest_asyncio.apply()
         loop = self._get_event_loop()
 
         try:
-            res = loop.run_until_complete(self._arequest(inp))
+            res = loop.run_until_complete(self._arequest(inp, embd_normalize))
         except Exception as e:
-            raise ValueError(f"Request failed with error: {str(e)}")
-
-        if new_dim:
-            raise NotImplementedError("new_dim is not yet supported")
+            UserMessage(f"Request failed with error: {e!s}", raise_with=ValueError)
 
-        if res is not None:
-            output = [r["embedding"] for r in res["data"]]
-        else:
-            output = None
+        output = [r["embedding"] for r in res] if res is not None else None  # B x 1 x D
         metadata = {'raw_output': res}
 
         return [output], metadata

symai/backend/engines/embedding/engine_openai.py

@@ -1,5 +1,4 @@
 import logging
-from typing import Optional
 
 import numpy as np
 import openai
@@ -16,7 +15,7 @@ logging.getLogger("httpcore").setLevel(logging.ERROR)
 
 
 class EmbeddingEngine(Engine, OpenAIMixin):
-    def __init__(self, api_key: Optional[str] = None, model: Optional[str] = None):
+    def __init__(self, api_key: str | None = None, model: str | None = None):
         super().__init__()
         logger = logging.getLogger('openai')
         logger.setLevel(logging.WARNING)
@@ -79,6 +78,5 @@ class EmbeddingEngine(Engine, OpenAIMixin):
             if norm == 0:
                 return x.tolist()
             return (x / norm).tolist()
-        else:
-            norm = np.linalg.norm(x, 2, axis=1, keepdims=True)
-            return np.where(norm == 0, x, x / norm).tolist()
+        norm = np.linalg.norm(x, 2, axis=1, keepdims=True)
+        return np.where(norm == 0, x, x / norm).tolist()

symai/backend/engines/execute/engine_python.py

@@ -1,10 +1,11 @@
+import sys
+import traceback
+
 from ....symbol import Result
 from ...base import Engine
 
 
 def full_stack():
-    import sys
-    import traceback
     exc = sys.exc_info()[0]
     stack = traceback.extract_stack()[-10:-1]  # last one would be full_stack()
     if exc is not None:                        # i.e. an exception is present
@@ -68,9 +69,9 @@ class PythonEngine(Engine):
     def forward(self, argument):
         code = argument.prop.prepared_input
         kwargs = argument.kwargs
-        globals_ = kwargs['globals'] if 'globals' in kwargs else {}
-        locals_ = kwargs['locals']  if 'locals'  in kwargs else {}
-        input_handler = kwargs['input_handler'] if 'input_handler' in kwargs else None
+        globals_ = kwargs.get('globals', {})
+        locals_ = kwargs.get('locals', {})
+        input_handler = kwargs.get('input_handler')
         if input_handler:
             input_handler((code,))