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

symai/extended/document.py

@@ -1,30 +1,38 @@
-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,
-            *,
-            index_name: str = Indexer.DEFAULT,
-            top_k: int = 5,
-            max_depth: int = 1,
-            formatter: Callable = ParagraphFormatter(),
-            overwrite: bool = False,
-            with_metadata: bool = False,
-            raw_result: Optional[bool] = False,
-            new_dim: Optional[int] = None,
-            **kwargs
-        ):
+        self,
+        source: str | None = None,
+        *,
+        index_name: str = Indexer.DEFAULT,
+        top_k: int = 5,
+        max_depth: int = 1,
+        formatter: Callable = _DEFAULT_PARAGRAPH_FORMATTER,
+        overwrite: bool = False,
+        with_metadata: bool = False,
+        raw_result: bool | None = False,
+        new_dim: int | None = None,
+        **kwargs,
+    ):
         super().__init__(**kwargs)
-        self.indexer = Indexer(index_name=index_name, top_k=top_k, formatter=formatter, auto_add=False, new_dim=new_dim)
-        self.reader  = FileReader(with_metadata=with_metadata)
+        self.indexer = Indexer(
+            index_name=index_name, top_k=top_k, formatter=formatter, auto_add=False, new_dim=new_dim
+        )
+        self.reader = FileReader(with_metadata=with_metadata)
         self.new_dim = new_dim
 
         if overwrite:
@@ -33,34 +41,43 @@ class DocumentRetriever(Expression):
         # we insert the text into the index if (1) index does not exist and (2) there's a specific source
         if source is not None and not self.indexer.exists():
             self.indexer.register()
-            text = self.parse_source(source, with_metadata=with_metadata, max_depth=max_depth, **kwargs)
+            text = self.parse_source(
+                source, with_metadata=with_metadata, max_depth=max_depth, **kwargs
+            )
             self.index = self.indexer(data=text, raw_result=raw_result, **kwargs)
         else:
             # we don't insert the text at initialization since the index already exists and there's no specific source
             self.index = self.indexer(raw_result=raw_result, **kwargs)
 
     def forward(
-            self,
-            query: Symbol,
-            raw_result: Optional[bool] = False,
-        ) -> Symbol:
+        self,
+        query: Symbol,
+        raw_result: bool | None = False,
+    ) -> Symbol:
         return self.index(
-                query,
-                raw_result=raw_result,
-                )
+            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)
         #  - a file path (e.g. a new file that the user wants to insert)
         #  - a directory path (e.g. a new directory that the user wants to insert)
-        text = self.parse_source(source, with_metadata=kwargs.get('with_metadata', False), max_depth=kwargs.get('max_depth', 1), **kwargs)
-        #NOTE: Do we need `new_dim` here?
+        text = self.parse_source(
+            source,
+            with_metadata=kwargs.get("with_metadata", False),
+            max_depth=kwargs.get("max_depth", 1),
+            **kwargs,
+        )
+        # NOTE: Do we need `new_dim` here?
         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 +86,7 @@ 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,48 @@ 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 +71,32 @@ 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"\n# ----[FILE_END]{file_path}\n"
+                    file_content = (
+                        f"# ----[FILE_START]<PART1/1>{file_path_escaped}[FILE_CONTENT]:\n"
+                        + file_content
+                        + f"\n# ----[FILE_END]{file_path_escaped}\n"
+                    )
 
                     # Merge the file contents
                     merged_file += file_content
@@ -63,4 +106,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,51 +29,66 @@ 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.formatter = formatter
+        self.n_workers = n_workers
         self.sym_return_type = Graph
-        self.verbose         = verbose
+        self.verbose = verbose
 
-    def process_symbol(self, s, *args, **kwargs):
-        res = ''
+    def process_symbol(self, s, *_args, **kwargs):
+        res = ""
 
-        @core.few_shot(prompt="Extract relationships between entities:\n",
-                  examples=Prompt([
-                        '$> John has a dog. =>John, dog, 1 EOF',
-                        '$> Karl has two sons. =>Karl, sons, 2 EOF',
-                        '$> Similarly, the term general linguistics is used to distinguish core linguistics from other types of study =>general linguistics, core linguistics, 1 EOF',
-                        '$> X has Y and Z has Y =>X, Y, 1\nZ, Y, 1 EOF',
-                  ]),
-                  pre_processors=[GraphPreProcessor()],
-                  post_processors=[StripPostProcessor()],
-                  stop=['EOF'], **kwargs)
+        @core.few_shot(
+            prompt="Extract relationships between entities:\n",
+            examples=Prompt(
+                [
+                    "$> John has a dog. =>John, dog, 1 EOF",
+                    "$> Karl has two sons. =>Karl, sons, 2 EOF",
+                    "$> Similarly, the term general linguistics is used to distinguish core linguistics from other types of study =>general linguistics, core linguistics, 1 EOF",
+                    "$> X has Y and Z has Y =>X, Y, 1\nZ, Y, 1 EOF",
+                ]
+            ),
+            pre_processors=[GraphPreProcessor()],
+            post_processors=[StripPostProcessor()],
+            stop=["EOF"],
+            **kwargs,
+        )
         def _func(_, text) -> str:
             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(',')
+            lines = rec.split("\n")
+            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'
+                        if (
+                            len(csv) == 3
+                            and csv[0].strip() != ""
+                            and csv[1].strip() != ""
+                            and int(csv[2].strip()) > 0
+                        ):
+                            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:
-        res = 'source,target,value\n'
+    def forward(self, sym: Symbol, **_kwargs) -> Symbol:
+        res = "source,target,value\n"
         sym_list = self.formatter(sym).value
         if self.n_workers == 1:
             for s in sym_list:
@@ -83,3 +101,4 @@ class Graph(Expression):
         return res
 
 
+_DEFAULT_SENTENCE_FORMATTER = SentenceFormatter()

symai/extended/html_style_template.py

@@ -61,13 +61,15 @@ class HtmlStyleTemplate(Expression):
         super().__init__(**kwargs)
         self.html_template_seq = Template()
         self.html_template_seq.template_ = HEADER_STYLE_DESCRIPTION
-        self.html_stream = Stream(
-            self.html_template_seq
+        self.html_stream = Stream(self.html_template_seq)
+        self.style_template = Style(
+            description=HTML_STREAM_STYLE_DESCRIPTION,
+            libraries=[
+                "https://cdn.jsdelivr.net/npm/bootstrap@5.2.3/dist/css/bootstrap.min.css",
+                "https://cdn.jsdelivr.net/npm/bootstrap@5.2.3/dist/js/bootstrap.bundle.min.js",
+                "https://ajax.googleapis.com/ajax/libs/jquery/3.6.1/jquery.min.js",
+            ],
         )
-        self.style_template = Style(description=HTML_STREAM_STYLE_DESCRIPTION,
-                                       libraries=['https://cdn.jsdelivr.net/npm/bootstrap@5.2.3/dist/css/bootstrap.min.css',
-                                                  'https://cdn.jsdelivr.net/npm/bootstrap@5.2.3/dist/js/bootstrap.bundle.min.js',
-                                                  'https://ajax.googleapis.com/ajax/libs/jquery/3.6.1/jquery.min.js'])
 
     def forward(self, sym: Symbol, **kwargs) -> Symbol:
         """The `render` method takes a `Symbol` as an argument and returns a `Symbol` containing the rendered news.
@@ -76,13 +78,15 @@ 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
+        style_data = [
+            str(
+                self.style_template(
+                    html, template=HTML_TEMPLATE_STYLE, placeholder="{{placeholder}}", **kwargs
+                )
+            )
+            for html in html_data
+        ]
+        return Symbol("\n".join(style_data))

symai/extended/interfaces/blip_2.py

@@ -1,5 +1,3 @@
-from typing import List
-
 from ... import core
 from ...symbol import Expression
 
@@ -9,8 +7,9 @@ class blip_2(Expression):
         super().__init__(*args, **kwargs)
         self.name = self.__class__.__name__
 
-    def __call__(self, image: str = None, query: str = None, **kwargs) -> "blip_2":
+    def __call__(self, image: str | None = None, query: str | None = None, **kwargs) -> "blip_2":
         @core.caption(image=image, prompt=query, **kwargs)
         def _func(_) -> str:
             pass
+
         return self.sym_return_type(_func(self))

symai/extended/interfaces/clip.py

@@ -1,5 +1,3 @@
-from typing import List, Union
-
 import numpy as np
 
 from ... import core
@@ -11,8 +9,11 @@ class clip(Expression):
         super().__init__(*args, **kwargs)
         self.name = self.__class__.__name__
 
-    def __call__(self, image: str | bytes = None, text: List[str] = None, **kwargs) -> "clip":
+    def __call__(
+        self, image: str | bytes | None = None, text: list[str] | None = None, **kwargs
+    ) -> "clip":
         @core.text_vision(image=image, text=text, **kwargs)
         def _func(_) -> np.ndarray:
             pass
+
         return self.sym_return_type(_func(self))

symai/extended/interfaces/console.py

@@ -1,5 +1,6 @@
 from ... import core
 from ...symbol import Expression
+from ...utils import UserMessage
 
 
 class console(Expression):
@@ -8,8 +9,15 @@ class console(Expression):
         self.name = self.__class__.__name__
 
     def __call__(self, *args, **kwargs) -> "console":
-        kwargs['handler'] = lambda x: print(*x['args'])
+        def _handler(payload):
+            args_ = payload.get("args", ())
+            message = " ".join(str(arg) for arg in args_)
+            UserMessage(message)
+
+        kwargs["handler"] = _handler
+
         @core.output(**kwargs)
         def _func(_, *args):
             pass
+
         return self.sym_return_type(_func(self, *args))

symai/extended/interfaces/dall_e.py

@@ -1,6 +1,6 @@
 from ... import core
-from ...symbol import Expression, Symbol
 from ...backend.engines.drawing.engine_gpt_image import GPTImageResult
+from ...symbol import Expression, Symbol
 
 
 class dall_e(Expression):
@@ -8,9 +8,11 @@ class dall_e(Expression):
         super().__init__(*args, **kwargs)
         self.name = self.__class__.__name__
 
-    def __call__(self, sym: Symbol, operation: str = 'create', **kwargs) -> GPTImageResult:
+    def __call__(self, sym: Symbol, operation: str = "create", **kwargs) -> GPTImageResult:
         sym = self._to_symbol(sym)
+
         @core.draw(operation=operation, **kwargs)
         def _func(_) -> GPTImageResult:
             pass
+
         return _func(sym)

symai/extended/interfaces/file.py

@@ -9,7 +9,9 @@ class file(Expression):
 
     def __call__(self, path: Symbol, **kwargs) -> "file":
         path = self._to_symbol(path)
+
         @core.opening(path=path.value, **kwargs)
         def _func(_) -> str:
             pass
+
         return self.sym_return_type(_func(self))

symai/extended/interfaces/flux.py

@@ -1,6 +1,6 @@
 from ... import core
-from ...symbol import Expression, Symbol
 from ...backend.engines.drawing.engine_bfl import FluxResult
+from ...symbol import Expression
 
 
 class flux(Expression):
@@ -8,9 +8,11 @@ class flux(Expression):
         super().__init__(*args, **kwargs)
         self.name = self.__class__.__name__
 
-    def __call__(self, prompt: str, operation: str = 'create', **kwargs) -> FluxResult:
+    def __call__(self, prompt: str, operation: str = "create", **kwargs) -> FluxResult:
         prompt = self._to_symbol(prompt)
+
         @core.draw(operation=operation, **kwargs)
         def _func(_) -> FluxResult:
             pass
+
         return _func(prompt)

symai/extended/interfaces/gpt_image.py

@@ -1,6 +1,6 @@
 from ... import core
 from ...backend.engines.drawing.engine_gpt_image import GPTImageResult
-from ...symbol import Expression, Symbol
+from ...symbol import Expression
 
 
 class gpt_image(Expression):
@@ -8,9 +8,18 @@ class gpt_image(Expression):
         super().__init__(*args, **kwargs)
         self.name = self.__class__.__name__
 
-    def __call__(self, prompt: str | None = None, operation: str = 'create', engine: str | None = None, model: str | None = None, **kwargs) -> GPTImageResult:
-            prompt = self._to_symbol(prompt)
-            @core.draw(engine=engine or "drawing", operation=operation, model=model, **kwargs)
-            def _func(_) -> GPTImageResult:
-                pass
-            return _func(prompt)
+    def __call__(
+        self,
+        prompt: str | None = None,
+        operation: str = "create",
+        engine: str | None = None,
+        model: str | None = None,
+        **kwargs,
+    ) -> GPTImageResult:
+        prompt = self._to_symbol(prompt)
+
+        @core.draw(engine=engine or "drawing", operation=operation, model=model, **kwargs)
+        def _func(_) -> GPTImageResult:
+            pass
+
+        return _func(prompt)

symai/extended/interfaces/input.py

@@ -2,7 +2,7 @@ from ... import core
 from ...symbol import Expression
 
 
-class input(Expression):
+class input(Expression):  # noqa
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.name = self.__class__.__name__
@@ -11,4 +11,5 @@ class input(Expression):
         @core.userinput(**kwargs)
         def _func(_, message) -> str:
             pass
+
         return self.sym_return_type(_func(self, message))

symai/extended/interfaces/llava.py

@@ -1,5 +1,3 @@
-from typing import List
-
 from ... import core
 from ...symbol import Expression
 
@@ -13,4 +11,5 @@ class llava(Expression):
         @core.caption(image=image, prompt=query, **kwargs)
         def _func(_) -> str:
             pass
+
         return self.sym_return_type(_func(self))

symai/extended/interfaces/{naive_webscraping.py → naive_scrape.py}

@@ -1,17 +1,18 @@
 from ... import core
-from ...backend.engines.webscraping.engine_requests import RequestsResult
+from ...backend.engines.scrape.engine_requests import RequestsResult
 from ...symbol import Expression
 
 
-class naive_webscraping(Expression):
+class naive_scrape(Expression):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.name = self.__class__.__name__
 
     def __call__(self, url: str, **kwargs) -> RequestsResult:
         @core.scrape(url=url, **kwargs)
-        def _func(_, *args, **inner_kwargs) -> RequestsResult:
+        def _func(_, *_args, **_inner_kwargs) -> RequestsResult:
             # The fallback path may inject debugging kwargs like `error`/`stack_trace`;
             # accept and ignore them so EngineRepository can surface structured failures.
             return None
+
         return _func(self)

symai/extended/interfaces/naive_vectordb.py

@@ -1,12 +1,10 @@
-from ... import core
-from ...backend.engines.index.engine_vectordb import (VectorDBIndexEngine,
-                                                      VectorDBResult)
+from ...backend.engines.index.engine_vectordb import VectorDBIndexEngine, VectorDBResult
 from ...symbol import Expression
-from ...utils import CustomUserWarning
+from ...utils import UserMessage
 
 
 class naive_vectordb(Expression):
-    def __init__(self, index_name = VectorDBIndexEngine._default_index_name, *args, **kwargs):
+    def __init__(self, index_name=VectorDBIndexEngine._default_index_name, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.index_name = index_name
         self.name = self.__class__.__name__
@@ -17,7 +15,7 @@ class naive_vectordb(Expression):
         operation: str = "search",
         index_name: str | None = None,
         storage_file: str | None = None,
-        **kwargs
+        **kwargs,
     ) -> VectorDBResult:
         index = self.index_name if index_name is None else index_name
         if operation == "search":
@@ -26,10 +24,11 @@ class naive_vectordb(Expression):
             if isinstance(query, list):
                 for q in query:
                     self.add(doc=[q], index_name=index, **kwargs)
-                return
+                return None
             self.add(doc=[query], index_name=index, **kwargs)
-            return
+            return None
         if operation == "config":
             self.config(path=query, index_name=index, storage_file=storage_file, **kwargs)
-            return
-        CustomUserWarning(f"Operation not supported: {operation}", raise_with=NotImplementedError)
+            return None
+        UserMessage(f"Operation not supported: {operation}", raise_with=NotImplementedError)
+        return None