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

symai/backend/base.py

@@ -7,48 +7,47 @@ from ..collect import CollectionRepository, rec_serialize
 from ..utils import UserMessage
 from .settings import HOME_PATH
 
-ENGINE_UNREGISTERED = '<UNREGISTERED/>'
+ENGINE_UNREGISTERED = "<UNREGISTERED/>"
 
 COLLECTION_LOGGING_ENGINES = {
-    'GPTXChatEngine',
-    'GPTXCompletionEngine',
-    'SerpApiEngine',
-    'WolframAlphaEngine',
-    'SeleniumEngine',
-    'OCREngine',
+    "GPTXChatEngine",
+    "GPTXCompletionEngine",
+    "SerpApiEngine",
+    "WolframAlphaEngine",
+    "SeleniumEngine",
+    "OCREngine",
 }
 
+
 class Engine(ABC):
     def __init__(self) -> None:
         super().__init__()
-        self.verbose    = False
-        self.logging    = False
-        self.log_level  = logging.DEBUG
+        self.verbose = False
+        self.logging = False
+        self.log_level = logging.DEBUG
         self.time_clock = False
         self.collection = CollectionRepository()
         self.collection.connect()
         # create formatter
-        __root_dir__  = HOME_PATH
+        __root_dir__ = HOME_PATH
         __root_dir__.mkdir(parents=True, exist_ok=True)
         __file_path__ = __root_dir__ / "engine.log"
-        logging.basicConfig(filename=__file_path__, filemode="a", format='%(asctime)s %(name)s %(levelname)s %(message)s')
-        self.logger     = logging.getLogger()
+        logging.basicConfig(
+            filename=__file_path__,
+            filemode="a",
+            format="%(asctime)s %(name)s %(levelname)s %(message)s",
+        )
+        self.logger = logging.getLogger()
         self.logger.setLevel(logging.DEBUG)
         # logging to console
-        stream          = logging.StreamHandler()
-        streamformat    = logging.Formatter("%(asctime)s %(message)s")
+        stream = logging.StreamHandler()
+        streamformat = logging.Formatter("%(asctime)s %(message)s")
         stream.setLevel(logging.INFO)
         stream.setFormatter(streamformat)
         self.logger.addHandler(stream)
 
     def __call__(self, argument: Any) -> tuple[list[str], dict]:
-        log = {
-            'Input': {
-                'self': self,
-                'args': argument.args,
-                **argument.kwargs
-            }
-        }
+        log = {"Input": {"self": self, "args": argument.args, **argument.kwargs}}
         start_time = time.time()
 
         self._trigger_input_handlers(argument)
@@ -56,12 +55,12 @@ class Engine(ABC):
         res, metadata = self.forward(argument)
 
         req_time = time.time() - start_time
-        metadata['time'] = req_time
+        metadata["time"] = req_time
         if self.time_clock:
             UserMessage(f"{argument.prop.func}: {req_time} sec")
-        log['Output'] = res
+        log["Output"] = res
         if self.verbose:
-            view   = {k: v for k, v in list(log['Input'].items()) if k != 'self'}
+            view = {k: v for k, v in list(log["Input"].items()) if k != "self"}
             input_ = f"{str(log['Input']['self'])[:50]}, {argument.prop.func!s}, {view!s}"
             UserMessage(f"{input_[:150]} {str(log['Output'])[:100]}")
         if self.logging:
@@ -74,9 +73,9 @@ class Engine(ABC):
         return res, metadata
 
     def _trigger_input_handlers(self, argument: Any) -> None:
-        instance_metadata = getattr(argument.prop.instance, '_metadata', None)
+        instance_metadata = getattr(argument.prop.instance, "_metadata", None)
         if instance_metadata is not None:
-            input_handler = getattr(instance_metadata, 'input_handler', None)
+            input_handler = getattr(instance_metadata, "input_handler", None)
             if input_handler is not None:
                 input_handler((argument.prop.processed_input, argument))
         argument_handler = argument.prop.input_handler
@@ -84,9 +83,9 @@ class Engine(ABC):
             argument_handler((argument.prop.processed_input, argument))
 
     def _trigger_output_handlers(self, argument: Any, result: Any, metadata: dict | None) -> None:
-        instance_metadata = getattr(argument.prop.instance, '_metadata', None)
+        instance_metadata = getattr(argument.prop.instance, "_metadata", None)
         if instance_metadata is not None:
-            output_handler = getattr(instance_metadata, 'output_handler', None)
+            output_handler = getattr(instance_metadata, "output_handler", None)
             if output_handler:
                 output_handler(result)
         argument_handler = argument.prop.output_handler
@@ -95,13 +94,13 @@ class Engine(ABC):
 
     def _record_collection_entry(self, argument: Any, metadata: dict, req_time: float) -> None:
         self.collection.add(
-            forward={'args': rec_serialize(argument.args), 'kwds': rec_serialize(argument.kwargs)},
+            forward={"args": rec_serialize(argument.args), "kwds": rec_serialize(argument.kwargs)},
             engine=str(self),
             metadata={
-                'time': req_time,
-                'data': rec_serialize(metadata),
-                'argument': rec_serialize(argument)
-            }
+                "time": req_time,
+                "data": rec_serialize(metadata),
+                "argument": rec_serialize(argument),
+            },
         )
 
     def id(self) -> str:
@@ -109,17 +108,18 @@ class Engine(ABC):
 
     def preview(self, argument):
         # Used here to avoid backend.base <-> symbol circular import.
-        from ..symbol import ( # noqa
+        from ..symbol import (  # noqa
             Symbol,
         )
+
         class Preview(Symbol):
             def __repr__(self) -> str:
-                '''
+                """
                 Get the representation of the Symbol object as a string.
 
                 Returns:
                     str: The representation of the Symbol object.
-                '''
+                """
                 return str(self.value.prop.prepared_input)
 
             def prepared_input(self):
@@ -136,29 +136,29 @@ class Engine(ABC):
         raise NotImplementedError
 
     def command(self, *_args, **kwargs):
-        if kwargs.get('verbose'):
-            self.verbose = kwargs['verbose']
-        if kwargs.get('logging'):
-            self.logging = kwargs['logging']
-        if kwargs.get('log_level'):
-            self.log_level = kwargs['log_level']
-        if kwargs.get('time_clock'):
-            self.time_clock = kwargs['time_clock']
+        if kwargs.get("verbose"):
+            self.verbose = kwargs["verbose"]
+        if kwargs.get("logging"):
+            self.logging = kwargs["logging"]
+        if kwargs.get("log_level"):
+            self.log_level = kwargs["log_level"]
+        if kwargs.get("time_clock"):
+            self.time_clock = kwargs["time_clock"]
 
     def __str__(self) -> str:
         return self.__class__.__name__
 
     def __repr__(self) -> str:
-        '''
+        """
         Get the representation of the Symbol object as a string.
 
         Returns:
             str: The representation of the Symbol object.
-        '''
+        """
         # class with full path
-        class_ = self.__class__.__module__ + '.' + self.__class__.__name__
-        hex_   = hex(id(self))
-        return f'<class {class_} at {hex_}>'
+        class_ = self.__class__.__module__ + "." + self.__class__.__name__
+        hex_ = hex(id(self))
+        return f"<class {class_} at {hex_}>"
 
 
 class BatchEngine(Engine):
@@ -196,7 +196,7 @@ class BatchEngine(Engine):
         return_list = []
         for arg, result, metadata in zip(arguments, results, metadata_list, strict=False):
             if metadata is not None:
-                metadata['time'] = total_time / len(arguments)
+                metadata["time"] = total_time / len(arguments)
 
             self._trigger_output_handlers(arg, result, metadata)
             return_list.append((result, metadata))

symai/backend/engines/drawing/engine_bfl.py

@@ -22,7 +22,7 @@ class FluxResult(Result):
         # unpack the result
         with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as tmp_file:
             path = tmp_file.name
-        url = value.get('result').get('sample')
+        url = value.get("result").get("sample")
         request = requests.get(url, allow_redirects=True)
         request.raise_for_status()
         with Path(path).open("wb") as f:
@@ -34,57 +34,57 @@ class DrawingEngine(Engine):
     def __init__(self, api_key: str | None = None, model: str | None = None):
         super().__init__()
         self.config = SYMAI_CONFIG
-        self.api_key = self.config['DRAWING_ENGINE_API_KEY'] if api_key is None else api_key
-        self.model = self.config['DRAWING_ENGINE_MODEL'] if model is None else model
+        self.api_key = self.config["DRAWING_ENGINE_API_KEY"] if api_key is None else api_key
+        self.model = self.config["DRAWING_ENGINE_MODEL"] if model is None else model
         self.name = self.__class__.__name__
 
     def id(self) -> str:
-        if  self.config['DRAWING_ENGINE_API_KEY'] and self.config['DRAWING_ENGINE_MODEL'].startswith("flux"):
-            return 'drawing'
-        return super().id() # default to unregistered
+        if self.config["DRAWING_ENGINE_API_KEY"] and self.config["DRAWING_ENGINE_MODEL"].startswith(
+            "flux"
+        ):
+            return "drawing"
+        return super().id()  # default to unregistered
 
     def command(self, *args, **kwargs):
         super().command(*args, **kwargs)
-        if 'DRAWING_ENGINE_API_KEY' in kwargs:
-            self.api_key = kwargs['DRAWING_ENGINE_API_KEY']
-        if 'DRAWING_ENGINE_MODEL' in kwargs:
-            self.model = kwargs['DRAWING_ENGINE_MODEL']
+        if "DRAWING_ENGINE_API_KEY" in kwargs:
+            self.api_key = kwargs["DRAWING_ENGINE_API_KEY"]
+        if "DRAWING_ENGINE_MODEL" in kwargs:
+            self.model = kwargs["DRAWING_ENGINE_MODEL"]
 
     def forward(self, argument):
         prompt = argument.prop.prepared_input
         kwargs = argument.kwargs
-        width = kwargs.get('width', 1024)
-        height = kwargs.get('height', 768)
-        steps = kwargs.get('steps', 40)
-        seed = kwargs.get('seed', None)
-        guidance = kwargs.get('guidance', None)
-        safety_tolerance = kwargs.get('safety_tolerance', 2)
-        except_remedy = kwargs.get('except_remedy', None)
+        width = kwargs.get("width", 1024)
+        height = kwargs.get("height", 768)
+        steps = kwargs.get("steps", 40)
+        seed = kwargs.get("seed", None)
+        guidance = kwargs.get("guidance", None)
+        safety_tolerance = kwargs.get("safety_tolerance", 2)
+        except_remedy = kwargs.get("except_remedy", None)
 
         headers = {
-            'accept': 'application/json',
-            'x-key': self.api_key,
-            'Content-Type': 'application/json',
+            "accept": "application/json",
+            "x-key": self.api_key,
+            "Content-Type": "application/json",
         }
 
         payload = {
-            'prompt': prompt,
-            'width': width,
-            'height': height,
-            'num_inference_steps': steps,
-            'guidance_scale': guidance,
-            'seed': seed,
-            'safety_tolerance': safety_tolerance,
+            "prompt": prompt,
+            "width": width,
+            "height": height,
+            "num_inference_steps": steps,
+            "guidance_scale": guidance,
+            "seed": seed,
+            "safety_tolerance": safety_tolerance,
         }
         # drop any None values so Flux API won't return 500
         payload = {k: v for k, v in payload.items() if v is not None}
 
-        if kwargs.get('operation') == 'create':
+        if kwargs.get("operation") == "create":
             try:
                 response = requests.post(
-                    f'https://api.us1.bfl.ai/v1/{self.model}',
-                    headers=headers,
-                    json=payload
+                    f"https://api.us1.bfl.ai/v1/{self.model}", headers=headers, json=payload
                 )
                 # fail early on HTTP errors
                 response.raise_for_status()
@@ -100,9 +100,9 @@ class DrawingEngine(Engine):
                     time.sleep(5)
 
                     result = requests.get(
-                        'https://api.us1.bfl.ai/v1/get_result',
+                        "https://api.us1.bfl.ai/v1/get_result",
                         headers=headers,
-                        params={'id': request_id}
+                        params={"id": request_id},
                     )
 
                     result.raise_for_status()

symai/backend/engines/drawing/engine_gpt_image.py

@@ -26,6 +26,7 @@ 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 = []
@@ -53,6 +54,7 @@ class GPTImageEngine(Engine):
     supporting gpt-image-1, dall-e-2, dall-e-3,
     with all the extra parameters (background, moderation, etc).
     """
+
     def __init__(
         self,
         api_key: str | None = None,
@@ -61,16 +63,8 @@ class GPTImageEngine(Engine):
         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")

symai/backend/engines/embedding/engine_llama_cpp.py

@@ -15,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: ClassVar[dict[str, Any]] = {
-        'tries': 5,
-        'delay': 2,
-        'max_delay': 60,
-        'backoff': 2,
-        'jitter': (1, 5),
-        'graceful': True
+        "tries": 5,
+        "delay": 2,
+        "max_delay": 60,
+        "backoff": 2,
+        "jitter": (1, 5),
+        "graceful": True,
     }
     _timeout_params: ClassVar[dict[str, Any]] = {
-        'read': None,
-        'connect': None,
+        "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'):
-            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)
+        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):
             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']"
+        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):
             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']"
+        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
@@ -86,18 +94,23 @@ 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, session.post(
-                f"{self.server_endpoint}/v1/embeddings",
-                json={"content": text, "embd_normalize": embd_normalize}
-            ) as res:
+            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)
+                    UserMessage(
+                        f"Request failed with status code: {res.status}", raise_with=ValueError
+                    )
                 return await res.json()
 
         return await _make_request()
@@ -107,9 +120,9 @@ 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:
             UserMessage("new_dim is not yet supported", raise_with=NotImplementedError)
 
@@ -122,10 +135,12 @@ class LlamaCppEmbeddingEngine(Engine):
             UserMessage(f"Request failed with error: {e!s}", raise_with=ValueError)
 
         output = [r["embedding"] for r in res] if res is not None else None  # B x 1 x D
-        metadata = {'raw_output': res}
+        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

@@ -17,28 +17,30 @@ logging.getLogger("httpcore").setLevel(logging.ERROR)
 class EmbeddingEngine(Engine, OpenAIMixin):
     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
@@ -46,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)
@@ -58,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]
@@ -68,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):

symai/backend/engines/execute/engine_python.py

@@ -8,13 +8,13 @@ from ...base import Engine
 def full_stack():
     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
 
 
@@ -64,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.get('globals', {})
-        locals_ = kwargs.get('locals', {})
-        input_handler = kwargs.get('input_handler')
+        globals_ = kwargs.get("globals", {})
+        locals_ = kwargs.get("locals", {})
+        input_handler = kwargs.get("input_handler")
         if input_handler:
             input_handler((code,))
 
@@ -79,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