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

symai/backend/engines/files/engine_io.py

@@ -13,22 +13,23 @@ from ...base import Engine
 # Initialize Tika lazily to avoid spawning JVMs prematurely for all workers
 _TIKA_STATE = {"initialized": False}
 
+
 def _ensure_tika_vm():
     if not _TIKA_STATE["initialized"]:
         with contextlib.suppress(Exception):
             tika.initVM()
-        logging.getLogger('tika').setLevel(logging.CRITICAL)
+        logging.getLogger("tika").setLevel(logging.CRITICAL)
         _TIKA_STATE["initialized"] = True
 
 
 def _int_or_none(value):
-    return int(value) if value != '' else None
+    return int(value) if value != "" else None
 
 
 def _parse_slice_token(token):
-    if ':' not in token:
+    if ":" not in token:
         return int(token)
-    parts = token.split(':')
+    parts = token.split(":")
     if len(parts) == 2:
         start, end = parts
         return slice(_int_or_none(start), _int_or_none(end), None)
@@ -39,13 +40,13 @@ def _parse_slice_token(token):
 
 
 def _parse_slice_spec(file_path):
-    if '[' not in file_path or ']' not in 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]
+    path_part, remainder = file_path.split("[", 1)
+    slice_section = remainder.split("]", 1)[0]
     slices = []
-    for token in slice_section.split(','):
-        if token == '':
+    for token in slice_section.split(","):
+        if token == "":
             continue
         parsed = _parse_slice_token(token)
         if parsed is not None:
@@ -75,13 +76,13 @@ 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)
-        file_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
@@ -90,25 +91,25 @@ class FileEngine(Engine):
         path_obj = Path(file_path)
 
         # check if file exists
-        assert path_obj.exists(), f'File does not exist: {file_path}'
+        assert path_obj.exists(), f"File does not exist: {file_path}"
 
         # verify if file is empty
         if path_obj.stat().st_size <= 0:
-            return ''
+            return ""
 
         # For common plain-text extensions, avoid Tika overhead
         ext = path_obj.suffix.lower()
-        if ext in {'.txt', '.md', '.py', '.json', '.yaml', '.yml', '.csv', '.tsv', '.log'}:
+        if ext in {".txt", ".md", ".py", ".json", ".yaml", ".yml", ".csv", ".tsv", ".log"}:
             try:
-                with path_obj.open(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')
+                lines = content.split("\n")
                 lines = _apply_slices(lines, slices_)
-                content = '\n'.join(lines)
-                content = content.encode('utf8', 'ignore').decode('utf8', 'ignore')
+                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
@@ -116,25 +117,26 @@ class FileEngine(Engine):
 
         _ensure_tika_vm()
         file_ = unpack.from_file(str(path_obj))
-        content = file_['content'] if 'content' in file_ else str(file_)
+        content = file_["content"] if "content" in file_ else str(file_)
 
         if content is None:
             return None
-        content = content.split('\n')
+        content = content.split("\n")
 
         content = _apply_slices(content, slices_)
-        content = '\n'.join(content)
-        content = content.encode('utf8', 'ignore').decode('utf8', 'ignore')
+        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
-                UserMessage(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
@@ -143,55 +145,55 @@ class FileEngine(Engine):
     def fix_pdf(self, file_path: str):
         # opens the file for reading
         path_obj = Path(file_path)
-        with path_obj.open('rb') as p:
-            txt = (p.readlines())
+        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 = Path(f'{file_path}_fixed.pdf')
-        with new_file_path.open('wb') as f:
+        new_file_path = Path(f"{file_path}_fixed.pdf")
+        with new_file_path.open("wb") as f:
             f.writelines(txtx)
 
         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)
-        file_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(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 "slice" in kwargs:
+                page_range = kwargs["slice"]
                 if isinstance(page_range, (tuple, list)):
                     page_range = slice(*page_range)
 
-            rsp = ''
+            rsp = ""
             try:
-                with Path(path).open('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:
-                UserMessage(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)
@@ -200,11 +202,11 @@ class FileEngine(Engine):
             try:
                 rsp = self._read_slice_file(path, argument)
             except Exception as e:
-                UserMessage(f'Error reading empty file: {e} | {path}')
+                UserMessage(f"Error reading empty file: {e} | {path}")
                 raise e
 
         if rsp is None:
-            UserMessage(f'Error reading file - empty result: {path}', raise_with=Exception)
+            UserMessage(f"Error reading file - empty result: {path}", raise_with=Exception)
 
         metadata = {}
 
@@ -213,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,4 +1,3 @@
-
 import requests
 import torch
 
@@ -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:
-            UserMessage('Blip2 is not installed. Please install it with `pip install symbolicai[blip2]`', raise_with=ImportError)
+            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.get('except_remedy')
+        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

@@ -13,36 +13,36 @@ from ...base import Engine
 from ...settings import SYMAI_CONFIG
 
 
-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()
+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 Path(image['content']).open('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.get('except_remedy')
+        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,14 +97,16 @@ class LLaMACppClientEngine(Engine):
         except Exception as e:
             if except_remedy is None:
                 raise e
+
             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
 
@@ -110,7 +114,10 @@ class LLaMACppClientEngine(Engine):
         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)
+            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
 
@@ -141,16 +148,16 @@ class LLaMACppClientEngine(Engine):
         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')
+        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:
+                if "SYSTEM_INSTRUCTION" in part:
                     system += f"{part}\n"
                     consumed += 1
                 else:
                     break
-            suffix = '\n>>>\n'.join(parts[consumed:])
+            suffix = "\n>>>\n".join(parts[consumed:])
         return system, suffix
 
     def _append_template_suffix(self, user: str, argument) -> str:
@@ -164,7 +171,7 @@ class LLaMACppClientEngine(Engine):
             return
 
         system: str = ""
-        system = f'{system}\n' if system and len(system) > 0 else ''
+        system = f"{system}\n" if system and len(system) > 0 else ""
         system = self._append_context_sections(system, argument)
 
         user = self._build_user_instruction(argument)
@@ -173,9 +180,9 @@ class LLaMACppClientEngine(Engine):
         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},
         ]