symbolicai 0.21.0__py3-none-any.whl → 1.1.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
 
@@ -25,21 +26,23 @@ class GPTImageResult(Result):
     Exposes .value as the raw response and ._value as the
     first URL or decoded b64 image string.
     """
+
     def __init__(self, value, **kwargs):
         super().__init__(value, **kwargs)
         imgs = []
         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,28 +50,21 @@ 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
         # pick up a separate config slot if you like, or fall back
-        openai.api_key = (
-            self.config.get("DRAWING_ENGINE_API_KEY")
-            if api_key is None
-            else api_key
-        )
-        self.model = (
-            self.config.get("DRAWING_ENGINE_MODEL")
-            if model is None
-            else model
-        )
+        openai.api_key = self.config.get("DRAWING_ENGINE_API_KEY") if api_key is None else api_key
+        self.model = self.config.get("DRAWING_ENGINE_MODEL") if model is None else model
         self.name = self.__class__.__name__
         # quiet OpenAI's internal logger
         log = logging.getLogger("openai")
@@ -83,7 +79,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 +101,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
 
@@ -17,58 +15,66 @@ logging.getLogger("urllib").setLevel(logging.ERROR)
 logging.getLogger("httpx").setLevel(logging.ERROR)
 logging.getLogger("httpcore").setLevel(logging.ERROR)
 
+
 class LlamaCppEmbeddingEngine(Engine):
-    _retry_params = {
-        'tries': 5,
-        'delay': 2,
-        'max_delay': 60,
-        'backoff': 2,
-        'jitter': (1, 5),
-        'graceful': True
+    _retry_params: ClassVar[dict[str, Any]] = {
+        "tries": 5,
+        "delay": 2,
+        "max_delay": 60,
+        "backoff": 2,
+        "jitter": (1, 5),
+        "graceful": True,
     }
-    _timeout_params = {
-        'read': None,
-        'connect': None,
+    _timeout_params: ClassVar[dict[str, Any]] = {
+        "read": None,
+        "connect": None,
     }
 
-    def __init__(
-            self,
-            retry_params: dict = _retry_params,
-            timeout_params: dict = _timeout_params
-        ):
+    def __init__(self, retry_params: dict = _retry_params, timeout_params: dict = _timeout_params):
         super().__init__()
         self.config = SYMAI_CONFIG
-        if self.id() != 'embedding':
+        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)
+        if not SYMSERVER_CONFIG.get("online"):
+            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.server_endpoint = (
+            f"http://{SYMSERVER_CONFIG.get('--host')}:{SYMSERVER_CONFIG.get('--port')}"
+        )
         self.timeout_params = self._validate_timeout_params(timeout_params)
         self.retry_params = self._validate_retry_params(retry_params)
         self.name = self.__class__.__name__
 
     def id(self) -> str:
-        if self.config.get('EMBEDDING_ENGINE_MODEL') and self.config.get('EMBEDDING_ENGINE_MODEL').startswith('llama'):
-            return 'embedding'
+        if self.config.get("EMBEDDING_ENGINE_MODEL") and self.config.get(
+            "EMBEDDING_ENGINE_MODEL"
+        ).startswith("llama"):
+            return "embedding"
         return super().id()  # default to unregistered
 
     def command(self, *args, **kwargs):
         super().command(*args, **kwargs)
-        if 'EMBEDDING_ENGINE_MODEL' in kwargs:
-            self.model = kwargs['EMBEDDING_ENGINE_MODEL']
+        if "EMBEDDING_ENGINE_MODEL" in kwargs:
+            self.model = kwargs["EMBEDDING_ENGINE_MODEL"]
 
     def _validate_timeout_params(self, timeout_params):
         if not isinstance(timeout_params, dict):
-            raise ValueError("timeout_params must be a dictionary")
-        assert all(key in timeout_params for key in ['read', 'connect']), "Available keys: ['read', 'connect']"
+            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")
-        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']"
+            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
 
     @staticmethod
@@ -77,7 +83,9 @@ 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()
@@ -86,20 +94,24 @@ class LlamaCppEmbeddingEngine(Engine):
 
     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():
             timeout = aiohttp.ClientTimeout(
-                sock_connect=self.timeout_params['connect'],
-                sock_read=self.timeout_params['read']
+                sock_connect=self.timeout_params["connect"], sock_read=self.timeout_params["read"]
             )
-            async with aiohttp.ClientSession(timeout=timeout) as session:
-                async with session.post(
+            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:
-                        raise ValueError(f"Request failed with status code: {res.status}")
-                    return await res.json()
+                    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,11 +120,11 @@ 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
+        embd_normalize = kwargs.get("embd_normalize", -1)  # -1 = no normalization
 
-        new_dim = kwargs.get('new_dim')
+        new_dim = kwargs.get("new_dim")
         if new_dim:
-            raise NotImplementedError("new_dim is not yet supported")
+            UserMessage("new_dim is not yet supported", raise_with=NotImplementedError)
 
         nest_asyncio.apply()
         loop = self._get_event_loop()
@@ -120,16 +132,15 @@ class LlamaCppEmbeddingEngine(Engine):
         try:
             res = loop.run_until_complete(self._arequest(inp, embd_normalize))
         except Exception as e:
-            raise ValueError(f"Request failed with error: {str(e)}")
+            UserMessage(f"Request failed with error: {e!s}", raise_with=ValueError)
 
-        if res is not None:
-            output = [r["embedding"] for r in res] # B x 1 x D
-        else:
-            output = None
-        metadata = {'raw_output': res}
+        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
 
     def prepare(self, argument):
-        assert not argument.prop.processed_input, "LlamaCppEmbeddingEngine does not support processed_input."
+        assert not argument.prop.processed_input, (
+            "LlamaCppEmbeddingEngine does not support processed_input."
+        )
         argument.prop.prepared_input = argument.prop.entries

symai/backend/engines/embedding/engine_openai.py

@@ -1,5 +1,4 @@
 import logging
-from typing import Optional
 
 import numpy as np
 import openai
@@ -16,30 +15,32 @@ 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 = logging.getLogger("openai")
         logger.setLevel(logging.WARNING)
         self.config = SYMAI_CONFIG
-        if self.id() != 'embedding':
-            return # do not initialize if not embedding; avoids conflict with llama.cpp check in EngineRepository.register_from_package
-        openai.api_key = self.config['EMBEDDING_ENGINE_API_KEY'] if api_key is None else api_key
-        self.model = self.config['EMBEDDING_ENGINE_MODEL'] if model is None else model
+        if self.id() != "embedding":
+            return  # do not initialize if not embedding; avoids conflict with llama.cpp check in EngineRepository.register_from_package
+        openai.api_key = self.config["EMBEDDING_ENGINE_API_KEY"] if api_key is None else api_key
+        self.model = self.config["EMBEDDING_ENGINE_MODEL"] if model is None else model
         self.max_tokens = self.api_max_context_tokens()
         self.embedding_dim = self.api_embedding_dims()
         self.name = self.__class__.__name__
 
     def id(self) -> str:
-        if self.config.get('EMBEDDING_ENGINE_API_KEY') and self.config['EMBEDDING_ENGINE_MODEL'].startswith('text-embedding'):
-            return 'embedding'
-        return super().id() # default to unregistered
+        if self.config.get("EMBEDDING_ENGINE_API_KEY") and self.config[
+            "EMBEDDING_ENGINE_MODEL"
+        ].startswith("text-embedding"):
+            return "embedding"
+        return super().id()  # default to unregistered
 
     def command(self, *args, **kwargs):
         super().command(*args, **kwargs)
-        if 'EMBEDDING_ENGINE_API_KEY' in kwargs:
-            openai.api_key = kwargs['EMBEDDING_ENGINE_API_KEY']
-        if 'EMBEDDING_ENGINE_MODEL' in kwargs:
-            self.model = kwargs['EMBEDDING_ENGINE_MODEL']
+        if "EMBEDDING_ENGINE_API_KEY" in kwargs:
+            openai.api_key = kwargs["EMBEDDING_ENGINE_API_KEY"]
+        if "EMBEDDING_ENGINE_MODEL" in kwargs:
+            self.model = kwargs["EMBEDDING_ENGINE_MODEL"]
 
     def forward(self, argument):
         prepared_input = argument.prop.prepared_input
@@ -47,8 +48,8 @@ class EmbeddingEngine(Engine, OpenAIMixin):
         kwargs = argument.kwargs
 
         inp = prepared_input if isinstance(prepared_input, list) else [prepared_input]
-        except_remedy = kwargs.get('except_remedy')
-        new_dim = kwargs.get('new_dim')
+        except_remedy = kwargs.get("except_remedy")
+        new_dim = kwargs.get("new_dim")
 
         try:
             res = openai.embeddings.create(model=self.model, input=inp)
@@ -59,7 +60,9 @@ class EmbeddingEngine(Engine, OpenAIMixin):
             res = except_remedy(e, inp, callback, self, *args, **kwargs)
 
         if new_dim:
-            mn = min(new_dim, self.embedding_dim) #@NOTE: new_dim should be less than or equal to the original embedding dim
+            mn = min(
+                new_dim, self.embedding_dim
+            )  # @NOTE: new_dim should be less than or equal to the original embedding dim
             output = [self._normalize_l2(r.embedding[:mn]) for r in res.data]
         else:
             output = [r.embedding for r in res.data]
@@ -69,7 +72,9 @@ class EmbeddingEngine(Engine, OpenAIMixin):
         return [output], metadata
 
     def prepare(self, argument):
-        assert not argument.prop.processed_input, "EmbeddingEngine does not support processed_input."
+        assert not argument.prop.processed_input, (
+            "EmbeddingEngine does not support processed_input."
+        )
         argument.prop.prepared_input = argument.prop.entries
 
     def _normalize_l2(self, x):
@@ -79,6 +84,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,19 +1,20 @@
+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
-        del stack[-1]                          # remove call of full_stack, the printed exception
-                                               # will contain the caught exception caller instead
-    trc = 'Traceback (most recent call last):\n'
-    stackstr = trc + ''.join(traceback.format_list(stack))
+    if exc is not None:  # i.e. an exception is present
+        del stack[-1]  # remove call of full_stack, the printed exception
+        # will contain the caught exception caller instead
+    trc = "Traceback (most recent call last):\n"
+    stackstr = trc + "".join(traceback.format_list(stack))
     if exc is not None:
-         stackstr += '  ' + traceback.format_exc().lstrip(trc)
+        stackstr += "  " + traceback.format_exc().lstrip(trc)
     return stackstr
 
 
@@ -63,14 +64,14 @@ class PythonEngine(Engine):
         self.name = self.__class__.__name__
 
     def id(self) -> str:
-        return 'execute'
+        return "execute"
 
     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,))
 
@@ -78,18 +79,18 @@ class PythonEngine(Engine):
         err = None
         try:
             exec(str(code), globals_, locals_)
-            rsp = {'globals': globals_, 'locals': locals_}
-            if 'res' in locals_:
-                rsp['locals_res'] = locals_['res']
-            if 'res' in globals_:
-                rsp['globals_res'] = globals_['res']
+            rsp = {"globals": globals_, "locals": locals_}
+            if "res" in locals_:
+                rsp["locals_res"] = locals_["res"]
+            if "res" in globals_:
+                rsp["globals_res"] = globals_["res"]
             rsp = Result(rsp)
         except Exception as e:
             err = e
             raise e
 
         metadata = {}
-        metadata['error']  = None if not err else full_stack()
+        metadata["error"] = None if not err else full_stack()
 
         return [rsp], metadata