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

symai/backend/engines/files/engine_io.py

@@ -1,5 +1,5 @@
+import contextlib
 import logging
-import os
 from dataclasses import dataclass
 from pathlib import Path
 
@@ -7,21 +7,60 @@ import pypdf
 import tika
 from tika import unpack
 
+from ....utils import UserMessage
 from ...base import Engine
 
 # Initialize Tika lazily to avoid spawning JVMs prematurely for all workers
-_TIKA_INITIALIZED = False
+_TIKA_STATE = {"initialized": False}
+
 
 def _ensure_tika_vm():
-    global _TIKA_INITIALIZED
-    if not _TIKA_INITIALIZED:
-        try:
+    if not _TIKA_STATE["initialized"]:
+        with contextlib.suppress(Exception):
             tika.initVM()
-        except Exception:
-            # If initVM fails, we still attempt unpack.from_file which may auto-init
-            pass
-        logging.getLogger('tika').setLevel(logging.CRITICAL)
-        _TIKA_INITIALIZED = True
+        logging.getLogger("tika").setLevel(logging.CRITICAL)
+        _TIKA_STATE["initialized"] = True
+
+
+def _int_or_none(value):
+    return int(value) if value != "" else None
+
+
+def _parse_slice_token(token):
+    if ":" not in token:
+        return int(token)
+    parts = token.split(":")
+    if len(parts) == 2:
+        start, end = parts
+        return slice(_int_or_none(start), _int_or_none(end), None)
+    if len(parts) == 3:
+        start, end, step = parts
+        return slice(_int_or_none(start), _int_or_none(end), _int_or_none(step))
+    return None
+
+
+def _parse_slice_spec(file_path):
+    if "[" not in file_path or "]" not in file_path:
+        return file_path, None
+    path_part, remainder = file_path.split("[", 1)
+    slice_section = remainder.split("]", 1)[0]
+    slices = []
+    for token in slice_section.split(","):
+        if token == "":
+            continue
+        parsed = _parse_slice_token(token)
+        if parsed is not None:
+            slices.append(parsed)
+    return path_part, slices or None
+
+
+def _apply_slices(lines, slices_):
+    if slices_ is None:
+        return lines
+    new_content = []
+    for slice_item in slices_:
+        new_content.extend(lines[slice_item])
+    return new_content
 
 
 @dataclass
@@ -37,97 +76,67 @@ class FileEngine(Engine):
         self.name = self.__class__.__name__
 
     def id(self) -> str:
-        return 'files'
+        return "files"
 
     def _read_slice_file(self, file_path, argument):
         # check if file is empty
-        with_metadata = argument.kwargs.get('with_metadata', False)
-        id            = Path(argument.prop.prepared_input).stem.replace(' ', '_')
-        if file_path is None or file_path.strip() == '':
+        with_metadata = argument.kwargs.get("with_metadata", False)
+        file_id = Path(argument.prop.prepared_input).stem.replace(" ", "_")
+        if file_path is None or file_path.strip() == "":
             return None
 
         # check if file slice is used
-        slices_ = None
-        if '[' in file_path and ']' in file_path:
-            file_parts = file_path.split('[')
-            file_path = file_parts[0]
-            # remove string up to '[' and after ']'
-            slices_s = file_parts[1].split(']')[0].split(',')
-            slices_ = []
-            for s in slices_s:
-                if s == '':
-                    continue
-                elif ':' in s:
-                    s_split = s.split(':')
-                    if len(s_split) == 2:
-                        start_slice = int(s_split[0]) if s_split[0] != '' else None
-                        end_slice = int(s_split[1]) if s_split[1] != '' else None
-                        slices_.append(slice(start_slice, end_slice, None))
-                    elif len(s_split) == 3:
-                        start_slice = int(s_split[0]) if s_split[0] != '' else None
-                        end_slice = int(s_split[1]) if s_split[1] != '' else None
-                        step_slice = int(s_split[2]) if s_split[2] != '' else None
-                        slices_.append(slice(start_slice, end_slice, step_slice))
-                else:
-                    slices_.append(int(s))
+        file_path, slices_ = _parse_slice_spec(file_path)
+
+        path_obj = Path(file_path)
 
         # check if file exists
-        assert os.path.exists(file_path), f'File does not exist: {file_path}'
+        assert path_obj.exists(), f"File does not exist: {file_path}"
 
         # verify if file is empty
-        if os.path.getsize(file_path) <= 0:
-            return ''
+        if path_obj.stat().st_size <= 0:
+            return ""
 
         # For common plain-text extensions, avoid Tika overhead
-        ext = Path(file_path).suffix.lower()
-        if ext in {'.txt', '.md', '.py', '.json', '.yaml', '.yml', '.csv', '.tsv', '.log'}:
+        ext = path_obj.suffix.lower()
+        if ext in {".txt", ".md", ".py", ".json", ".yaml", ".yml", ".csv", ".tsv", ".log"}:
             try:
-                with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
+                with path_obj.open(encoding="utf-8", errors="ignore") as f:
                     content = f.read()
                 if content is None:
                     return None
                 # Apply slicing by lines, mirroring the Tika branch
-                lines = content.split('\n')
-                if slices_ is not None:
-                    new_content = []
-                    for s in slices_:
-                        new_content.extend(lines[s])
-                    lines = new_content
-                content = '\n'.join(lines)
-                content = content.encode('utf8', 'ignore').decode('utf8', 'ignore')
-                return content if not with_metadata else [TextContainer(id, None, content)]
+                lines = content.split("\n")
+                lines = _apply_slices(lines, slices_)
+                content = "\n".join(lines)
+                content = content.encode("utf8", "ignore").decode("utf8", "ignore")
+                return content if not with_metadata else [TextContainer(file_id, None, content)]
             except Exception:
                 # Fallback to Tika if plain read fails
                 pass
 
         _ensure_tika_vm()
-        file_ = unpack.from_file(str(file_path))
-        if 'content' in file_:
-            content = file_['content']
-        else:
-            content = str(file_)
+        file_ = unpack.from_file(str(path_obj))
+        content = file_["content"] if "content" in file_ else str(file_)
 
         if content is None:
             return None
-        content = content.split('\n')
-
-        if slices_ is not None:
-            new_content = []
-            for s in slices_:
-                new_content.extend(content[s])
-            content = new_content
-        content = '\n'.join(content)
-        content = content.encode('utf8', 'ignore').decode('utf8', 'ignore')
-        return content if not with_metadata else [TextContainer(id, None, content)]
+        content = content.split("\n")
 
+        content = _apply_slices(content, slices_)
+        content = "\n".join(content)
+        content = content.encode("utf8", "ignore").decode("utf8", "ignore")
+        return content if not with_metadata else [TextContainer(file_id, None, content)]
 
     def reset_eof_of_pdf_return_stream(self, pdf_stream_in: list):
         actual_line = len(pdf_stream_in)  # Predefined value in case EOF not found
         # find the line position of the EOF
         for i, x in enumerate(pdf_stream_in[::-1]):
-            if b'%%EOF' in x:
-                actual_line = len(pdf_stream_in)-i
-                print(f'EOF found at line position {-i} = actual {actual_line}, with value {x}')
+            if b"%%EOF" in x:
+                actual_line = len(pdf_stream_in) - i
+                UserMessage(
+                    f"EOF found at line position {-i} = actual {actual_line}, with value {x}"
+                )
                 break
 
         # return the list up to that point
@@ -135,56 +144,56 @@ class FileEngine(Engine):
 
     def fix_pdf(self, file_path: str):
         # opens the file for reading
-        with open(file_path, 'rb') as p:
-            txt = (p.readlines())
+        path_obj = Path(file_path)
+        with path_obj.open("rb") as p:
+            txt = p.readlines()
 
         # get the new list terminating correctly
         txtx = self.reset_eof_of_pdf_return_stream(txt)
 
         # write to new pdf
-        new_file_path = f'{file_path}_fixed.pdf'
-        with open(new_file_path, 'wb') as f:
+        new_file_path = Path(f"{file_path}_fixed.pdf")
+        with new_file_path.open("wb") as f:
             f.writelines(txtx)
 
-        fixed_pdf = pypdf.PdfReader(new_file_path)
-        return fixed_pdf
+        return pypdf.PdfReader(str(new_file_path))
 
     def read_text(self, pdf_reader, page_range, argument):
         txt = []
-        n_pages  = len(pdf_reader.pages)
-        with_metadata = argument.kwargs.get('with_metadata', False)
-        id       = Path(argument.prop.prepared_input).stem.replace(' ', '_')
+        n_pages = len(pdf_reader.pages)
+        with_metadata = argument.kwargs.get("with_metadata", False)
+        file_id = Path(argument.prop.prepared_input).stem.replace(" ", "_")
         for i in range(n_pages)[slice(0, n_pages) if page_range is None else page_range]:
             page = pdf_reader.pages[i]
             extracted = page.extract_text()
-            extracted = extracted.encode('utf8', 'ignore').decode('utf8', 'ignore')
+            extracted = extracted.encode("utf8", "ignore").decode("utf8", "ignore")
             if with_metadata:
-                txt.append(TextContainer(id, str(i), extracted))
+                txt.append(TextContainer(file_id, str(i), extracted))
             else:
                 txt.append(extracted)
 
-        return '\n'.join(txt) if not with_metadata else txt
+        return "\n".join(txt) if not with_metadata else txt
 
     def forward(self, argument):
-        kwargs        = argument.kwargs
-        path          = argument.prop.prepared_input
+        kwargs = argument.kwargs
+        path = argument.prop.prepared_input
 
-        if '.pdf' in path:
+        if ".pdf" in path:
             page_range = None
-            if 'slice' in kwargs:
-                page_range = kwargs['slice']
-                if isinstance(page_range, tuple) or isinstance(page_range, list):
+            if "slice" in kwargs:
+                page_range = kwargs["slice"]
+                if isinstance(page_range, (tuple, list)):
                     page_range = slice(*page_range)
 
-            rsp = ''
+            rsp = ""
             try:
-                with open(str(path), 'rb') as f:
+                with Path(path).open("rb") as f:
                     # creating a pdf reader object
                     pdf_reader = pypdf.PdfReader(f)
                     rsp = self.read_text(pdf_reader, page_range, argument)
             except Exception as e:
-                print(f'Error reading PDF: {e} | {path}')
-                if 'fix_pdf' not in kwargs or not kwargs['fix_pdf']:
+                UserMessage(f"Error reading PDF: {e} | {path}")
+                if "fix_pdf" not in kwargs or not kwargs["fix_pdf"]:
                     raise e
                 fixed_pdf = self.fix_pdf(str(path))
                 pdf_reader_fixed = pypdf.PdfReader(fixed_pdf)
@@ -193,11 +202,11 @@ class FileEngine(Engine):
             try:
                 rsp = self._read_slice_file(path, argument)
             except Exception as e:
-                print(f'Error reading empty file: {e} | {path}')
+                UserMessage(f"Error reading empty file: {e} | {path}")
                 raise e
 
         if rsp is None:
-            raise Exception(f'Error reading file - empty result: {path}')
+            UserMessage(f"Error reading file - empty result: {path}", raise_with=Exception)
 
         metadata = {}
 
@@ -206,5 +215,5 @@ class FileEngine(Engine):
     def prepare(self, argument):
         assert not argument.prop.processed_input, "FileEngine does not support processed_input."
         path = argument.prop.path
-        path = path.replace('\\', '')
+        path = path.replace("\\", "")
         argument.prop.prepared_input = path

symai/backend/engines/imagecaptioning/engine_blip2.py

@@ -1,5 +1,3 @@
-from typing import List
-
 import requests
 import torch
 
@@ -10,6 +8,7 @@ except ImportError:
 
 from PIL import Image
 
+from ....utils import UserMessage
 from ...base import Engine
 from ...settings import SYMAI_CONFIG
 
@@ -18,7 +17,7 @@ class Blip2Engine(Engine):
     def __init__(self):
         super().__init__()
         self.config = SYMAI_CONFIG
-        ids = self.config['CAPTION_ENGINE_MODEL'].split('/')
+        ids = self.config["CAPTION_ENGINE_MODEL"].split("/")
         if len(ids) != 2:
             # return unregistered engine
             return
@@ -27,42 +26,47 @@ class Blip2Engine(Engine):
         self.model = None  # lazy loading
         self.vis_processors = None  # lazy loading
         self.txt_processors = None  # lazy loading
-        self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
         self.name = self.__class__.__name__
 
     def id(self) -> str:
-        if  self.config['CAPTION_ENGINE_MODEL'] and \
-            'blip2' in self.config['CAPTION_ENGINE_MODEL']:
-            return 'imagecaptioning'
-        return super().id() # default to unregistered
+        if self.config["CAPTION_ENGINE_MODEL"] and "blip2" in self.config["CAPTION_ENGINE_MODEL"]:
+            return "imagecaptioning"
+        return super().id()  # default to unregistered
 
     def command(self, *args, **kwargs):
         super().command(*args, **kwargs)
-        if 'CAPTION_ENGINE_MODEL' in kwargs:
-            self.model_id = kwargs['CAPTION_ENGINE_MODEL']
+        if "CAPTION_ENGINE_MODEL" in kwargs:
+            self.model_id = kwargs["CAPTION_ENGINE_MODEL"]
 
     def forward(self, argument):
         if load_model_and_preprocess is None:
-            raise ImportError('Blip2 is not installed. Please install it with `pip install symbolicai[blip2]`')
+            UserMessage(
+                "Blip2 is not installed. Please install it with `pip install symbolicai[blip2]`",
+                raise_with=ImportError,
+            )
         if self.model is None:
-            self.model, self.vis_processors, self.txt_processors  = load_model_and_preprocess(name       = self.name_id,
-                                                                                              model_type = self.model_id,
-                                                                                              is_eval    = True,
-                                                                                              device     = self.device)
+            self.model, self.vis_processors, self.txt_processors = load_model_and_preprocess(
+                name=self.name_id, model_type=self.model_id, is_eval=True, device=self.device
+            )
 
         image, prompt = argument.prop.prepared_input
-        kwargs        = argument.kwargs
-        except_remedy = kwargs['except_remedy'] if 'except_remedy' in kwargs else None
+        kwargs = argument.kwargs
+        except_remedy = kwargs.get("except_remedy")
 
-        if 'http' in image:
-            image = Image.open(requests.get(image, stream=True).raw).convert('RGB')
-        elif '/' in image or '\\' in image:
-            image = Image.open(image).convert('RGB')
+        if "http" in image:
+            image = Image.open(requests.get(image, stream=True).raw).convert("RGB")
+        elif "/" in image or "\\" in image:
+            image = Image.open(image).convert("RGB")
 
         try:
-            image   = self.vis_processors['eval'](image).unsqueeze(0).to(self.device)
-            prompt  = self.txt_processors['eval'](prompt)
-            res     = self.model.generate(samples={"image": image, "prompt": prompt}, use_nucleus_sampling=True, num_captions=3)
+            image = self.vis_processors["eval"](image).unsqueeze(0).to(self.device)
+            prompt = self.txt_processors["eval"](prompt)
+            res = self.model.generate(
+                samples={"image": image, "prompt": prompt},
+                use_nucleus_sampling=True,
+                num_captions=3,
+            )
         except Exception as e:
             if except_remedy is None:
                 raise e

symai/backend/engines/imagecaptioning/engine_llavacpp_client.py

@@ -1,48 +1,48 @@
-import logging
-import requests
-import json
 import io
+import json
+import logging
+from pathlib import Path
 
-from typing import List
-from requests_toolbelt.multipart.encoder import MultipartEncoder
+import requests
 from PIL.Image import Image
+from requests_toolbelt.multipart.encoder import MultipartEncoder
 
+from ....symbol import Result
+from ....utils import UserMessage
 from ...base import Engine
 from ...settings import SYMAI_CONFIG
-from ....symbol import Result
 
 
-def image_to_byte_array(image: Image, format='PNG') -> bytes:
-  # BytesIO is a file-like buffer stored in memory
-  imgByteArr = io.BytesIO()
-  # image.save expects a file-like as a argument
-  image.save(imgByteArr, format=format)
-  # Turn the BytesIO object back into a bytes object
-  imgByteArr = imgByteArr.getvalue()
-  return imgByteArr
+def image_to_byte_array(image: Image, format="PNG") -> bytes:
+    # BytesIO is a file-like buffer stored in memory
+    imgByteArr = io.BytesIO()
+    # image.save expects a file-like as a argument
+    image.save(imgByteArr, format=format)
+    # Turn the BytesIO object back into a bytes object
+    return imgByteArr.getvalue()
 
 
 class LLaMAResult(Result):
     def __init__(self, value=None, *args, **kwargs):
         super().__init__(value, *args, **kwargs)
         self._value = value
-        self.error  = None
-        self.raw    = value
+        self.error = None
+        self.raw = value
         self._perse_result()
 
     def _perse_result(self):
-        val        = json.loads(self.value)
+        val = json.loads(self.value)
         self.value = val
-        if 'error' in val:
-            self.error = val['error']
-        if 'content' in val:
-            self.value = val['content']
+        if "error" in val:
+            self.error = val["error"]
+        if "content" in val:
+            self.value = val["content"]
 
 
 class LLaMACppClientEngine(Engine):
-    def __init__(self, host: str = 'localhost', port: int = 8080, timeout: int = 240):
+    def __init__(self, host: str = "localhost", port: int = 8080, timeout: int = 240):
         super().__init__()
-        logger = logging.getLogger('nesy_client')
+        logger = logging.getLogger("nesy_client")
         logger.setLevel(logging.WARNING)
         self.config = SYMAI_CONFIG
         self.host = host
@@ -51,43 +51,45 @@ class LLaMACppClientEngine(Engine):
         self.name = self.__class__.__name__
 
     def id(self) -> str:
-        if  self.config['CAPTION_ENGINE_MODEL'] and \
-            'llavacpp' in self.config['CAPTION_ENGINE_MODEL']:
-            return 'imagecaptioning'
-        return super().id() # default to unregistered
+        if (
+            self.config["CAPTION_ENGINE_MODEL"]
+            and "llavacpp" in self.config["CAPTION_ENGINE_MODEL"]
+        ):
+            return "imagecaptioning"
+        return super().id()  # default to unregistered
 
     @property
     def max_tokens(self):
         return 4096
 
     def forward(self, argument):
-        prompts             = argument.prop.prepared_input
-        kwargs              = argument.kwargs
+        prompts = argument.prop.prepared_input
+        kwargs = argument.kwargs
         system, user, image = prompts
         # escape special characters
-        system              = system['content']
-        user                = user['content']
+        system = system["content"]
+        user = user["content"]
 
-        if isinstance(image['content'], Image):
+        if isinstance(image["content"], Image):
             # format image to bytes
-            format_ = argument.prop.image_format if argument.prop.image_format else 'PNG'
-            im_bytes = image_to_byte_array(image['content'], format=format_)
+            format_ = argument.prop.image_format if argument.prop.image_format else "PNG"
+            im_bytes = image_to_byte_array(image["content"], format=format_)
         else:
             # Convert image to bytes, open as binary
-            with open(image['content'], 'rb') as f:
+            with Path(image["content"]).open("rb") as f:
                 im_bytes = f.read()
         # Create multipart/form-data payload
-        payload      = MultipartEncoder(
+        payload = MultipartEncoder(
             fields={
-                'user_prompt': ('user_prompt', user, 'text/plain'),
-                'image_file': ('image_file', im_bytes, 'application/octet-stream'),
-                'system_prompt': ('system_prompt', system, 'text/plain')
+                "user_prompt": ("user_prompt", user, "text/plain"),
+                "image_file": ("image_file", im_bytes, "application/octet-stream"),
+                "system_prompt": ("system_prompt", system, "text/plain"),
             }
         )
         # Update the headers for multipart/form-data
-        headers       = {'Content-Type': payload.content_type}
-        api           = f'http://{self.host}:{self.port}/llava'
-        except_remedy = kwargs['except_remedy'] if 'except_remedy' in kwargs else None
+        headers = {"Content-Type": payload.content_type}
+        api = f"http://{self.host}:{self.port}/llava"
+        except_remedy = kwargs.get("except_remedy")
         try:
             # use http localhost 8000 to send a request to the server
             rsp = requests.post(api, data=payload, headers=headers, timeout=self.timeout)
@@ -95,27 +97,31 @@ class LLaMACppClientEngine(Engine):
         except Exception as e:
             if except_remedy is None:
                 raise e
-            callback = lambda: requests.post(api, data=payload, headers=headers, timeout=self.timeout)
+
+            def callback():
+                return requests.post(api, data=payload, headers=headers, timeout=self.timeout)
+
             res = except_remedy(self, e, callback, argument)
 
         metadata = {}
 
-        res    = LLaMAResult(res)
-        rsp    = [res]
+        res = LLaMAResult(res)
+        rsp = [res]
         output = rsp if isinstance(prompts, list) else rsp[0]
         return output, metadata
 
-    def prepare(self, argument):
-        if argument.prop.raw_input:
-            if not argument.prop.processed_input:
-                raise ValueError('Need to provide a prompt instruction to the engine if raw_input is enabled.')
-            argument.prop.prepared_input = argument.prop.processed_input
-            return
-
-        user:   str = ""
-        system: str = ""
-        system = f'{system}\n' if system and len(system) > 0 else ''
-
+    def _handle_raw_input(self, argument) -> bool:
+        if not argument.prop.raw_input:
+            return False
+        if not argument.prop.processed_input:
+            UserMessage(
+                "Need to provide a prompt instruction to the engine if raw_input is enabled.",
+                raise_with=ValueError,
+            )
+        argument.prop.prepared_input = argument.prop.processed_input
+        return True
+
+    def _append_context_sections(self, system: str, argument) -> str:
         ref = argument.prop.instance
         static_ctxt, dyn_ctxt = ref.global_context
         if len(static_ctxt) > 0:
@@ -126,40 +132,57 @@ class LLaMACppClientEngine(Engine):
 
         payload = argument.prop.payload
         if argument.prop.payload:
-            system += f"[ADDITIONAL CONTEXT]\n{str(payload)}\n\n"
+            system += f"[ADDITIONAL CONTEXT]\n{payload!s}\n\n"
 
-        examples: List[str] = argument.prop.examples
+        examples: list[str] = argument.prop.examples
         if examples and len(examples) > 0:
-            system += f"[EXAMPLES]\n{str(examples)}\n\n"
+            system += f"[EXAMPLES]\n{examples!s}\n\n"
 
+        return system
+
+    def _build_user_instruction(self, argument) -> str:
+        user = ""
         if argument.prop.prompt is not None and len(argument.prop.prompt) > 0:
             val = str(argument.prop.prompt)
-            # in this engine, instructions are considered as user prompts
             user += f"[INSTRUCTION]\n{val}"
-
-        suffix: str = str(argument.prop.processed_input)
-
-        if '[SYSTEM_INSTRUCTION::]: <<<' in suffix and argument.prop.parse_system_instructions:
-            parts = suffix.split('\n>>>\n')
-            # first parts are the system instructions
-            c = 0
-            for i, p in enumerate(parts):
-                if 'SYSTEM_INSTRUCTION' in p:
-                    system += f"{p}\n"
-                    c += 1
+        return user
+
+    def _extract_system_instructions(self, argument, system: str, suffix: str) -> tuple[str, str]:
+        if "[SYSTEM_INSTRUCTION::]: <<<" in suffix and argument.prop.parse_system_instructions:
+            parts = suffix.split("\n>>>\n")
+            consumed = 0
+            for part in parts:
+                if "SYSTEM_INSTRUCTION" in part:
+                    system += f"{part}\n"
+                    consumed += 1
                 else:
                     break
-            # last part is the user input
-            suffix = '\n>>>\n'.join(parts[c:])
-        user += f"{suffix}"
+            suffix = "\n>>>\n".join(parts[consumed:])
+        return system, suffix
 
+    def _append_template_suffix(self, user: str, argument) -> str:
         if argument.prop.template_suffix:
-            user += f"\n[[PLACEHOLDER]]\n{str(argument.prop.template_suffix)}\n\n"
-            user += f"Only generate content for the placeholder `[[PLACEHOLDER]]` following the instructions and context information. Do NOT write `[[PLACEHOLDER]]` or anything else in your output.\n\n"
+            user += f"\n[[PLACEHOLDER]]\n{argument.prop.template_suffix!s}\n\n"
+            user += "Only generate content for the placeholder `[[PLACEHOLDER]]` following the instructions and context information. Do NOT write `[[PLACEHOLDER]]` or anything else in your output.\n\n"
+        return user
+
+    def prepare(self, argument):
+        if self._handle_raw_input(argument):
+            return
+
+        system: str = ""
+        system = f"{system}\n" if system and len(system) > 0 else ""
+        system = self._append_context_sections(system, argument)
+
+        user = self._build_user_instruction(argument)
+        suffix: str = str(argument.prop.processed_input)
+        system, suffix = self._extract_system_instructions(argument, system, suffix)
+        user += f"{suffix}"
+        user = self._append_template_suffix(user, argument)
 
-        user_prompt = { "role": "user", "content": user }
+        user_prompt = {"role": "user", "content": user}
         argument.prop.prepared_input = [
-            { "role": "system", "content": system },
+            {"role": "system", "content": system},
             user_prompt,
-            { "role": "image", "content": argument.prop.image }
+            {"role": "image", "content": argument.prop.image},
         ]