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

symai/extended/arxiv_pdf_parser.py

@@ -1,13 +1,14 @@
-import os
 import re
 import shutil
-import requests
-
 from concurrent.futures import ThreadPoolExecutor, as_completed
+from pathlib import Path
+
+import requests
 
+from ..backend.settings import HOME_PATH
 from ..symbol import Expression, Symbol
+from ..utils import UserMessage
 from .file_merger import FileMerger
-from ..backend.settings import HOME_PATH
 
 
 class ArxivPdfParser(Expression):
@@ -21,11 +22,11 @@ class ArxivPdfParser(Expression):
         urls = re.findall(self.url_pattern, str(data))
 
         # Convert all urls to pdf urls
-        pdf_urls = [f"https://arxiv.org/pdf/" + (f"{url.split('/')[-1]}.pdf" if 'pdf' not in url else {url.split('/')[-1]}) for url in urls]
+        pdf_urls = ["https://arxiv.org/pdf/" + (f"{url.split('/')[-1]}.pdf" if 'pdf' not in url else {url.split('/')[-1]}) for url in urls]
 
         # Create temporary folder in the home directory
-        output_path = os.path.join(HOME_PATH, "temp/downloads")
-        os.makedirs(output_path, exist_ok=True)
+        output_path = HOME_PATH / "temp" / "downloads"
+        output_path.mkdir(parents=True, exist_ok=True)
 
         pdf_files = []
         with ThreadPoolExecutor() as executor:
@@ -36,13 +37,13 @@ class ArxivPdfParser(Expression):
                 try:
                     pdf_files.append(future.result())
                 except Exception as exc:
-                    print('%r generated an exception: %s' % (url, exc))
+                    UserMessage(f"{url!r} generated an exception: {exc}")
 
         if len(pdf_files) == 0:
             return None
 
         # Merge all pdfs into one file
-        merged_file = self.merger(output_path, **kwargs)
+        merged_file = self.merger(str(output_path), **kwargs)
 
         # Return the merged file as a Symbol
         return_file = self._to_symbol(merged_file)
@@ -55,7 +56,7 @@ class ArxivPdfParser(Expression):
     def download_pdf(self, url, output_path):
         # Download pdfs
         response = requests.get(url)
-        file = os.path.join(output_path, f'{url.split("/")[-1]}')
-        with open(file, 'wb') as f:
+        file_path = Path(output_path) / f'{url.split("/")[-1]}'
+        with file_path.open('wb') as f:
             f.write(response.content)
-        return file
+        return str(file_path)

symai/extended/bibtex_parser.py

@@ -1,8 +1,7 @@
 from .. import core
+from ..post_processors import CodeExtractPostProcessor
 from ..pre_processors import PreProcessor
 from ..symbol import Expression, Symbol
-from ..post_processors import CodeExtractPostProcessor
-
 
 BIB_DESCRIPTION = """[Description]
 You take in a text with references to papers and return a list of biblatex entries.
@@ -69,7 +68,7 @@ Multimodal Few-Shot Learning with Frozen Language Models Maria Tsimpoukelli
 
 class BibTexPreProcessor(PreProcessor):
     def __call__(self, argument):
-        return '>>>\n{}\n\n<<<\n'.format(str(argument.args[0]))
+        return f'>>>\n{argument.args[0]!s}\n\n<<<\n'
 
 
 class BibTexParser(Expression):

symai/extended/conversation.py

@@ -1,21 +1,23 @@
-import os
 import pickle
+from collections.abc import Callable
 from datetime import datetime
 from pathlib import Path
-from typing import Any, Callable, List, Optional
+from typing import Any
 
-from ..components import FileReader, Indexer
+from ..components import FileReader
 from ..formatter import TextContainerFormatter
 from ..interfaces import Interface
 from ..memory import SlidingWindowStringConcatMemory
 from ..symbol import Symbol
-from ..utils import CustomUserWarning, deprecated
+from ..utils import UserMessage, deprecated
 from .document import DocumentRetriever
 from .seo_query_optimizer import SEOQueryOptimizer
 
+_DEFAULT_TEXT_CONTAINER_FORMATTER = TextContainerFormatter(text_split=4)
+
 
 class CodeFormatter:
-    def __call__(self, value: str, *args: Any, **kwds: Any) -> Any:
+    def __call__(self, value: str, *_args: Any, **_kwds: Any) -> Any:
         # extract code from chat conversations or ```<language>\n{code}\n``` blocks
         return Symbol(value).extract('Only extract code without ``` block markers or chat conversations')
 
@@ -23,10 +25,10 @@ class CodeFormatter:
 class Conversation(SlidingWindowStringConcatMemory):
     def __init__(
             self,
-            init: Optional[str] = None,
-            file_link: Optional[List[str]] = None,
-            url_link: Optional[List[str]] = None,
-            index_name: Optional[str] = None,
+            init: str | None = None,
+            file_link: list[str] | None = None,
+            url_link: list[str] | None = None,
+            index_name: str | None = None,
             auto_print: bool = True,
             truncation_percentage: float = 0.8,
             truncation_type: str = 'head',
@@ -61,7 +63,7 @@ class Conversation(SlidingWindowStringConcatMemory):
         self.indexer = None
         self.index = None
         if index_name is not None:
-            CustomUserWarning("Index not supported for conversation class.", raise_with=NotImplementedError)
+            UserMessage("Index not supported for conversation class.", raise_with=NotImplementedError)
 
     def __getstate__(self):
         state = super().__getstate__().copy()
@@ -76,41 +78,42 @@ class Conversation(SlidingWindowStringConcatMemory):
         self.seo_opt = SEOQueryOptimizer()
         self.reader = FileReader()
         if self.index_name is not None:
-            CustomUserWarning("Index not supported for conversation class.", raise_with=NotImplementedError)
+            UserMessage("Index not supported for conversation class.", raise_with=NotImplementedError)
 
-    def store_system_message(self, message: str, *args, **kwargs):
-        val = f"[SYSTEM_INSTRUCTION::]: <<<\n{str(message)}\n>>>\n"
+    def store_system_message(self, message: str, *_args, **_kwargs):
+        val = f"[SYSTEM_INSTRUCTION::]: <<<\n{message!s}\n>>>\n"
         self.store(val)
 
-    def store_file(self, file_path: str, *args, **kwargs):
+    def store_file(self, file_path: str, *_args, **_kwargs):
         content = self.reader(file_path)
-        val = f"[DATA::{file_path}]: <<<\n{str(content)}\n>>>\n"
+        val = f"[DATA::{file_path}]: <<<\n{content!s}\n>>>\n"
         self.store(val)
 
-    def store_url(self, url: str, *args, **kwargs):
+    def store_url(self, url: str, *_args, **_kwargs):
         content = self.scraper(url)
-        val = f"[DATA::{url}]: <<<\n{str(content)}\n>>>\n"
+        val = f"[DATA::{url}]: <<<\n{content!s}\n>>>\n"
         self.store(val)
 
     @staticmethod
     def save_conversation_state(conversation: "Conversation", file_path: str) -> None:
         # Check if path exists and create it if it doesn't
-        dir_path = os.path.dirname(file_path)
-        os.makedirs(dir_path, exist_ok=True)
+        path_obj = Path(file_path)
+        path_obj.parent.mkdir(parents=True, exist_ok=True)
         # Save the conversation object as a pickle file
-        with open(file_path, 'wb') as handle:
+        with path_obj.open('wb') as handle:
             pickle.dump(conversation, handle, protocol=pickle.HIGHEST_PROTOCOL)
 
     def load_conversation_state(self, path: str) -> "Conversation":
         # Check if the file exists and it's not empty
-        if os.path.exists(path):
-            if os.path.getsize(path) <= 0:
-                raise Exception("File is empty.")
+        path_obj = Path(path)
+        if path_obj.exists():
+            if path_obj.stat().st_size <= 0:
+                UserMessage("File is empty.", raise_with=Exception)
             # Load the conversation object from a pickle file
-            with open(path, 'rb') as handle:
+            with path_obj.open('rb') as handle:
                 conversation_state = pickle.load(handle)
         else:
-            raise Exception("File does not exist or is empty.")
+            UserMessage("File does not exist or is empty.", raise_with=Exception)
 
         # Create a new instance of the `Conversation` class and restore
         # the state from the saved conversation
@@ -127,10 +130,10 @@ class Conversation(SlidingWindowStringConcatMemory):
         self.seo_opt = SEOQueryOptimizer()
         self.reader = FileReader()
         if self.index_name is not None:
-            CustomUserWarning("Index not supported for conversation class.", raise_with=NotImplementedError)
+            UserMessage("Index not supported for conversation class.", raise_with=NotImplementedError)
         return self
 
-    def commit(self, target_file: str = None, formatter: Optional[Callable] = None):
+    def commit(self, target_file: str | None = None, formatter: Callable | None = None):
         if target_file and isinstance(target_file, str):
             file_link = target_file
         else:
@@ -141,7 +144,7 @@ class Conversation(SlidingWindowStringConcatMemory):
                 file_link = file_link[0]
             else:
                 file_link = None # cannot commit to multiple files
-                raise Exception('Cannot commit to multiple files.')
+                UserMessage('Cannot commit to multiple files.', raise_with=Exception)
         if file_link:
             # if file extension is .py, then format code
             format_ = formatter
@@ -150,10 +153,10 @@ class Conversation(SlidingWindowStringConcatMemory):
             if formatter:
                 val = formatter(val)
             # if file does not exist, create it
-            with open(file_link, 'w') as file:
+            with Path(file_link).open('w') as file:
                 file.write(str(val))
         else:
-            raise Exception('File link is not set or a set of files.')
+            UserMessage('File link is not set or a set of files.', raise_with=Exception)
 
     def save(self, path: str, replace: bool = False) -> Symbol:
         return Symbol(self._memory).save(path, replace=replace)
@@ -161,64 +164,78 @@ class Conversation(SlidingWindowStringConcatMemory):
     def build_tag(self, tag: str, query: str) -> str:
         # get timestamp in string format
         timestamp = datetime.now().strftime("%d/%m/%Y %H:%M:%S:%f")
-        return str(f"[{tag}{timestamp}]: <<<\n{str(query)}\n>>>\n")
+        return str(f"[{tag}{timestamp}]: <<<\n{query!s}\n>>>\n")
 
     def forward(self, query: str, *args, **kwargs):
-        # dynamic takes precedence over static
-        dynamic_truncation_percentage = kwargs.get('truncation_percentage', self.truncation_percentage)
-        dynamic_truncation_type = kwargs.get('truncation_type', self.truncation_type)
-        kwargs = {**kwargs, 'truncation_percentage': dynamic_truncation_percentage, 'truncation_type': dynamic_truncation_type}
-
+        kwargs = self._apply_truncation_overrides(kwargs)
         query = self._to_symbol(query)
-        memory = None
-
-        if self.index is not None:
-            memory_split = self._memory.split(self.marker)
-            memory_shards = []
-            for ms in memory_split:
-                if ms.strip() == '':
-                    continue
-                memory_shards.append(ms)
-
-            length_memory_shards = len(memory_shards)
-            if length_memory_shards <= 3:
-                memory_shards = memory_shards
-            elif length_memory_shards <= 5:
-                memory_shards = memory_shards[:2] + memory_shards[-(length_memory_shards-2):]
-            else:
-                memory_shards = memory_shards[:2] + memory_shards[-3:]
+        memory = self._retrieve_index_memory(query, args, kwargs)
+        payload = self._build_payload(kwargs, memory)
+        res = self.recall(query, *args, payload=payload, **kwargs)
+
+        # if user is requesting to preview the response, then return only the preview result
+        if kwargs.get('preview'):
+            if self.auto_print:
+                UserMessage(str(res), style="text")
+            return res
+
+        ### --- asses memory update --- ###
+
+        self._append_interaction_to_memory(query, res)
+
+        # WARN: DO NOT PROCESS THE RES BY REMOVING `<<<` AND `>>>` TAGS
+
+        if self.auto_print:
+            UserMessage(str(res), style="text")
+        return res
 
-            search_query = query | '\n' | '\n'.join(memory_shards)
-            if kwargs.get('use_seo_opt'):
-                search_query = self.seo_opt(f'[Query]:' | search_query)
-            memory = self.index(search_query, *args, **kwargs)
+    def _apply_truncation_overrides(self, kwargs: dict[str, Any]) -> dict[str, Any]:
+        dynamic_truncation_percentage = kwargs.get('truncation_percentage', self.truncation_percentage)
+        dynamic_truncation_type = kwargs.get('truncation_type', self.truncation_type)
+        return {
+            **kwargs,
+            'truncation_percentage': dynamic_truncation_percentage,
+            'truncation_type': dynamic_truncation_type,
+        }
+
+    def _retrieve_index_memory(self, query: Symbol, args: tuple[Any, ...], kwargs: dict[str, Any]):
+        if self.index is None:
+            return None
+
+        memory_split = self._memory.split(self.marker)
+        memory_shards = []
+        for shard in memory_split:
+            if shard.strip() == '':
+                continue
+            memory_shards.append(shard)
+
+        length_memory_shards = len(memory_shards)
+        if length_memory_shards > 5:
+            memory_shards = memory_shards[:2] + memory_shards[-3:]
+        elif length_memory_shards > 3:
+            retained = memory_shards[-(length_memory_shards - 2):]
+            memory_shards = memory_shards[:2] + retained
+
+        search_query = query | '\n' | '\n'.join(memory_shards)
+        if kwargs.get('use_seo_opt'):
+            search_query = self.seo_opt('[Query]:' | search_query)
+        memory = self.index(search_query, *args, **kwargs)
 
-            if 'raw_result' in kwargs:
-                print(memory)
+        if 'raw_result' in kwargs:
+            UserMessage(str(memory), style="text")
+        return memory
 
+    def _build_payload(self, kwargs: dict[str, Any], memory) -> str:
         payload = ''
-        # if payload is set, then add it to the memory
         if 'payload' in kwargs:
-            payload  = f"[Conversation Payload]:\n{kwargs.pop('payload')}\n"
+            payload = f"[Conversation Payload]:\n{kwargs.pop('payload')}\n"
 
         index_memory = ''
-        # if index is set, then add it to the memory
         if memory:
             index_memory = f'[Index Retrieval]:\n{str(memory)[:1500]}\n'
+        return f'{index_memory}{payload}'
 
-        payload = f'{index_memory}{payload}'
-        # perform a recall function using the query
-        res = self.recall(query, *args, payload=payload, **kwargs)
-
-        # if user is requesting to preview the response, then return only the preview result
-        if 'preview' in kwargs and kwargs['preview']:
-            if self.auto_print:
-                print(res)
-            return res
-
-        ### --- asses memory update --- ###
-
-        # append the bot prompt to the memory
+    def _append_interaction_to_memory(self, query: Symbol, res: Symbol) -> None:
         prompt = self.build_tag(self.user_tag, query)
         self.store(prompt)
 
@@ -226,12 +243,6 @@ class Conversation(SlidingWindowStringConcatMemory):
         val = self.build_tag(self.bot_tag, res)
         self.store(val)
 
-        # WARN: DO NOT PROCESS THE RES BY REMOVING `<<<` AND `>>>` TAGS
-
-        if self.auto_print:
-            print(res)
-        return res
-
 
 RETRIEVAL_CONTEXT = """[Description]
 This is a conversation between a retrieval augmented indexing program and a user. The system combines document retrieval with conversational AI to provide context-aware responses. It can:
@@ -269,23 +280,23 @@ Responses should be:
 class RetrievalAugmentedConversation(Conversation):
     def __init__(
             self,
-            folder_path: Optional[str] = None,
+            folder_path: str | None = None,
             *,
-            index_name: Optional[str] = None,
-            max_depth: Optional[int] = 0,
+            index_name: str | None = None,
+            max_depth: int | None = 0,
             auto_print: bool = True,
             top_k: int = 5,
-            formatter: Callable = TextContainerFormatter(text_split=4),
+            formatter: Callable = _DEFAULT_TEXT_CONTAINER_FORMATTER,
             overwrite: bool = False,
             truncation_percentage: float = 0.8,
             truncation_type: str = 'head',
             with_metadata: bool = False,
-            raw_result: Optional[bool] = False,
-            new_dim: Optional[int] = None,
+            raw_result: bool | None = False,
+            new_dim: int | None = None,
             **kwargs
         ):
 
-        super().__init__(auto_print=auto_print, truncation_percentage=truncation_percentage, truncation_type=truncation_type, with_metadata=with_metadata, *kwargs)
+        super().__init__(auto_print=auto_print, truncation_percentage=truncation_percentage, truncation_type=truncation_type, with_metadata=with_metadata, **kwargs)
 
         self.retriever = DocumentRetriever(
             source=folder_path,
@@ -323,7 +334,7 @@ class RetrievalAugmentedConversation(Conversation):
         memory = self.index(query, *args, **kwargs)
 
         if 'raw_result' in kwargs:
-            print(memory)
+            UserMessage(str(memory), style="text")
             return memory
 
         prompt = self.build_tag(self.user_tag, query)
@@ -338,5 +349,5 @@ class RetrievalAugmentedConversation(Conversation):
         self.store(val)
 
         if self.auto_print:
-            print(res)
+            UserMessage(str(res), style="text")
         return res

symai/extended/document.py

@@ -1,25 +1,31 @@
-import os
+from collections.abc import Callable
 from pathlib import Path
-from typing import Callable, List, Optional, Union
+from typing import TYPE_CHECKING, Union
 
 from ..components import FileReader, Indexer
 from ..formatter import ParagraphFormatter
 from ..symbol import Expression, Symbol
+from ..utils import UserMessage
+
+if TYPE_CHECKING:
+    from ..backend.engines.files.engine_io import TextContainer
+
+_DEFAULT_PARAGRAPH_FORMATTER = ParagraphFormatter()
 
 
 class DocumentRetriever(Expression):
     def __init__(
             self,
-            source: Optional[str] = None,
+            source: str | None = None,
             *,
             index_name: str = Indexer.DEFAULT,
             top_k: int = 5,
             max_depth: int = 1,
-            formatter: Callable = ParagraphFormatter(),
+            formatter: Callable = _DEFAULT_PARAGRAPH_FORMATTER,
             overwrite: bool = False,
             with_metadata: bool = False,
-            raw_result: Optional[bool] = False,
-            new_dim: Optional[int] = None,
+            raw_result: bool | None = False,
+            new_dim: int | None = None,
             **kwargs
         ):
         super().__init__(**kwargs)
@@ -42,14 +48,14 @@ class DocumentRetriever(Expression):
     def forward(
             self,
             query: Symbol,
-            raw_result: Optional[bool] = False,
+            raw_result: bool | None = False,
         ) -> Symbol:
         return self.index(
                 query,
                 raw_result=raw_result,
                 )
 
-    def insert(self, source: Union[str, Path], **kwargs):
+    def insert(self, source: str | Path, **kwargs):
         # dynamically insert data into the index given a session
         # the data can be:
         #  - a string (e.g. something that the user wants to insert)
@@ -60,7 +66,7 @@ class DocumentRetriever(Expression):
         self.add(text, index_name=self.indexer.index_name, **kwargs)
         self.config(None, save=True, index_name=self.indexer.index_name, **kwargs)
 
-    def parse_source(self, source: str, with_metadata: bool, max_depth: int, **kwargs) -> List[Union[str, 'TextContainer']]:
+    def parse_source(self, source: str, with_metadata: bool, max_depth: int, **kwargs) -> list[Union[str, 'TextContainer']]:
         maybe_path = Path(source)
         if isinstance(source, str) and not (maybe_path.is_file() or maybe_path.is_dir()):
             return Symbol(source).zip(new_dim=self.new_dim)
@@ -69,4 +75,5 @@ class DocumentRetriever(Expression):
             return self.reader(files, with_metadata=with_metadata, **kwargs)
         if maybe_path.is_file():
             return self.reader(source, with_metadata=with_metadata, **kwargs)
-        raise ValueError(f"Invalid source: {source}; must be a file, directory, or string")
+        UserMessage(f"Invalid source: {source}; must be a file, directory, or string", raise_with=ValueError)
+        return []

symai/extended/file_merger.py

@@ -1,10 +1,10 @@
 import os
+from pathlib import Path
 
 from tqdm import tqdm
-from typing import List
 
-from ..symbol import Expression, Symbol
 from ..components import FileReader
+from ..symbol import Expression, Symbol
 
 
 class FileMerger(Expression):
@@ -12,8 +12,12 @@ class FileMerger(Expression):
     Class to merge contents of multiple files into one, specified by their file endings and root path.
     Files specified in the exclude list will not be included.
     """
-    def __init__(self, file_endings: List[str] = ['.py', '.md', '.txt', '.sh', '.pdf', '.json', '.yaml', '.java', '.cpp', '.hpp', '.c', '.h', '.js', '.css', '.html', '.xml', '.csv', '.tsv', '.yml', '.rst', '.ipynb', '.tex', '.bib'],
-                       file_excludes: List[str] = ['__init__.py', '__pycache__', 'LICENSE', 'requirements.txt', 'environment.yaml', '.git'], **kwargs):
+    def __init__(self, file_endings: list[str] | None = None,
+                       file_excludes: list[str] | None = None, **kwargs):
+        if file_excludes is None:
+            file_excludes = ['__init__.py', '__pycache__', 'LICENSE', 'requirements.txt', 'environment.yaml', '.git']
+        if file_endings is None:
+            file_endings = ['.py', '.md', '.txt', '.sh', '.pdf', '.json', '.yaml', '.java', '.cpp', '.hpp', '.c', '.h', '.js', '.css', '.html', '.xml', '.csv', '.tsv', '.yml', '.rst', '.ipynb', '.tex', '.bib']
         super().__init__(**kwargs)
         self.file_endings = file_endings
         self.file_excludes = file_excludes
@@ -31,29 +35,30 @@ class FileMerger(Expression):
 
         # Implement recursive file search
         # use tqdm for progress bar and description
-        tqdm_desc = f"Reading file: ..."
+        tqdm_desc = "Reading file: ..."
         # use os.walk to recursively search for files in the root path
         progress = tqdm(os.walk(root_path), desc=tqdm_desc)
 
-        for root, dirs, files in progress:
+        for root, _dirs, files in progress:
             for file in files:
-                file_path = os.path.join(root, file)
+                file_path = Path(root) / file
+                file_path_str = file_path.as_posix()
                 # Exclude files with the specified names in the path
-                if any(exclude in file_path for exclude in self.file_excludes):
+                if any(exclude in file_path_str for exclude in self.file_excludes):
                     continue
 
                 # Look only for files with the specified endings
                 if file.endswith(tuple(self.file_endings)):
                     # Read in the file using the FileReader
-                    file_content = self.reader(file_path, **kwargs).value
+                    file_content = self.reader(file_path_str, **kwargs).value
 
                     # escape file name spaces
-                    file_path = file_path.replace(" ", "\\ ")
+                    file_path_escaped = file_path_str.replace(" ", "\\ ")
 
                     # Append start and end markers for each file
-                    file_content = f"# ----[FILE_START]<PART1/1>{file_path}[FILE_CONTENT]:\n" + \
+                    file_content = f"# ----[FILE_START]<PART1/1>{file_path_escaped}[FILE_CONTENT]:\n" + \
                                    file_content + \
-                                   f"\n# ----[FILE_END]{file_path}\n"
+                                   f"\n# ----[FILE_END]{file_path_escaped}\n"
 
                     # Merge the file contents
                     merged_file += file_content
@@ -63,4 +68,4 @@ class FileMerger(Expression):
                     progress.set_description(tqdm_desc)
 
         # Return the merged file as a Symbol
-        return self._to_symbol(merged_file)
+        return self._to_symbol(merged_file)

symai/extended/graph.py

@@ -1,5 +1,5 @@
+from collections.abc import Callable
 from multiprocessing import Pool
-from typing import Callable
 
 from .. import core
 from ..formatter import SentenceFormatter
@@ -7,6 +7,9 @@ from ..post_processors import StripPostProcessor
 from ..pre_processors import PreProcessor
 from ..prompts import Prompt
 from ..symbol import Expression, Symbol
+from ..utils import UserMessage
+
+_DEFAULT_SENTENCE_FORMATTER = SentenceFormatter()
 
 GRAPH_DESCRIPTION = """[Description]
 Build source-target relationship pairs for named entities based for the [DATA] section. The [DATA] section contains one sentence.
@@ -18,7 +21,7 @@ If more than one entity pair is extracted from the same sentence, then the CSV f
 
 class GraphPreProcessor(PreProcessor):
     def __call__(self, argument):
-        return '$> {} =>'.format(str(argument.args[0]))
+        return f'$> {argument.args[0]!s} =>'
 
 
 class Graph(Expression):
@@ -26,14 +29,14 @@ class Graph(Expression):
     def static_context(self) -> str:
         return GRAPH_DESCRIPTION
 
-    def __init__(self, formatter: Callable = SentenceFormatter(), n_workers: int = 1, verbose: bool = False, **kwargs):
+    def __init__(self, formatter: Callable = _DEFAULT_SENTENCE_FORMATTER, n_workers: int = 1, verbose: bool = False, **kwargs):
         super().__init__(**kwargs)
         self.formatter       = formatter
         self.n_workers       = n_workers
         self.sym_return_type = Graph
         self.verbose         = verbose
 
-    def process_symbol(self, s, *args, **kwargs):
+    def process_symbol(self, s, *_args, **kwargs):
         res = ''
 
         @core.few_shot(prompt="Extract relationships between entities:\n",
@@ -50,26 +53,28 @@ class Graph(Expression):
             pass
 
         if len(str(s)) > 0:
-            if self.verbose: print(s)
+            if self.verbose:
+                UserMessage(str(s))
             r = _func(self, s)
             rec = str(r)
             lines = rec.split('\n')
-            for l in lines:
-                l = l.strip()
-                if len(l) > 0:
-                    csv = l.split(',')
+            for line in lines:
+                stripped_line = line.strip()
+                if len(stripped_line) > 0:
+                    csv = stripped_line.split(',')
                     try:
                         if len(csv) == 3 and \
                             csv[0].strip() != '' and \
                                 csv[1].strip() != '' and \
                                     int(csv[2].strip()) > 0:
-                            res += l + '\n'
+                            res += stripped_line + '\n'
                     except Exception as e:
-                        if self.verbose: print(e)
+                        if self.verbose:
+                            UserMessage(str(e))
                         pass
         return res
 
-    def forward(self, sym: Symbol, **kwargs) -> Symbol:
+    def forward(self, sym: Symbol, **_kwargs) -> Symbol:
         res = 'source,target,value\n'
         sym_list = self.formatter(sym).value
         if self.n_workers == 1:
@@ -82,4 +87,4 @@ class Graph(Expression):
             res += r
         return res
 
-
+_DEFAULT_SENTENCE_FORMATTER = SentenceFormatter()

symai/extended/html_style_template.py

@@ -76,13 +76,11 @@ class HtmlStyleTemplate(Expression):
         These strings are combined into a single `Symbol` object which is then clustered.
         Finally, the `render` method applies the `html_template` to the clustered `Symbol` and returns the result.
         """
-        if type(sym) != Symbol:
+        if not isinstance(sym, Symbol):
             sym = Symbol(sym)
         html_data = list(self.html_stream(sym, **kwargs))
         style_data = [str(self.style_template(html,
                                               template=HTML_TEMPLATE_STYLE,
                                               placeholder='{{placeholder}}',
                                               **kwargs)) for html in html_data]
-        res = '\n'.join(style_data)
-        res = Symbol(res)
-        return res
+        return Symbol('\n'.join(style_data))