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

symai/imports.py

@@ -16,14 +16,16 @@ from .utils import UserMessage
 logging.getLogger("subprocess").setLevel(logging.ERROR)
 
 
-__root_dir__  = HOME_PATH / 'packages'
-BASE_PACKAGE_MODULE = '' # use relative path
+__root_dir__ = HOME_PATH / "packages"
+BASE_PACKAGE_MODULE = ""  # use relative path
 BASE_PACKAGE_PATH = __root_dir__
 sys.path.append(str(__root_dir__))
 
 
 class Import(Expression):
-    def __init__(self, module: str, local_path: str | None = None, submodules: bool = False, *args, **kwargs):
+    def __init__(
+        self, module: str, local_path: str | None = None, submodules: bool = False, *args, **kwargs
+    ):
         super(self).__init__(*args, **kwargs)
         self.module = module
         self.local_path = local_path
@@ -34,8 +36,8 @@ class Import(Expression):
         # Check if module is a local path or a GitHub repo reference
         module_path = Path(module)
         if module_path.exists() and module_path.is_dir():
-            return (module_path / 'package.json').exists()
-        return (BASE_PACKAGE_PATH / module / 'package.json').exists()
+            return (module_path / "package.json").exists()
+        return (BASE_PACKAGE_PATH / module / "package.json").exists()
 
     @staticmethod
     def get_from_local(module, local_path):
@@ -60,25 +62,29 @@ class Import(Expression):
             logger.info(f"Copied local package from {local_path} to {module_path}")
 
             # Install dependencies
-            package_json = module_path / 'package.json'
+            package_json = module_path / "package.json"
             if package_json.exists():
                 with package_json.open() as f:
                     pkg = json.load(f)
-                    for dependency in pkg.get('dependencies', []):
+                    for dependency in pkg.get("dependencies", []):
                         # Update git_url for the dependency
-                        git_url_dependency = f'git@github.com:{dependency}.git'
+                        git_url_dependency = f"git@github.com:{dependency}.git"
                         dependency_path = BASE_PACKAGE_PATH / dependency
                         if not dependency_path.exists():
-                            subprocess.check_call(['git', 'clone', git_url_dependency, str(dependency_path)])
+                            subprocess.check_call(
+                                ["git", "clone", git_url_dependency, str(dependency_path)]
+                            )
 
                 # Install requirements
-                requirements_file = module_path / 'requirements.txt'
+                requirements_file = module_path / "requirements.txt"
                 if requirements_file.exists():
                     with requirements_file.open() as f:
                         for dependency in f.readlines():
                             dependency_name = dependency.strip()
                             if dependency_name:
-                                subprocess.check_call([sys.executable, '-m', 'pip', 'install', dependency_name])
+                                subprocess.check_call(
+                                    [sys.executable, "-m", "pip", "install", dependency_name]
+                                )
         except Exception as e:
             logger.error(f"Error installing from local path: {e}")
             raise
@@ -89,30 +95,32 @@ class Import(Expression):
         BASE_PACKAGE_PATH.mkdir(parents=True, exist_ok=True)
 
         # Clone repository
-        git_url = f'git@github.com:{module}.git'
-        clone_cmd = ['git', 'clone']
+        git_url = f"git@github.com:{module}.git"
+        clone_cmd = ["git", "clone"]
         if submodules:
-            clone_cmd.extend(['--recurse-submodules'])
+            clone_cmd.extend(["--recurse-submodules"])
         clone_cmd.extend([git_url, str(BASE_PACKAGE_PATH / module)])
         subprocess.check_call(clone_cmd)
 
         # Install dependencies
-        package_json = BASE_PACKAGE_PATH / module / 'package.json'
+        package_json = BASE_PACKAGE_PATH / module / "package.json"
         with package_json.open() as f:
             pkg = json.load(f)
-            for dependency in pkg['dependencies']:
+            for dependency in pkg["dependencies"]:
                 # Update git_url for the dependency
-                git_url_dependency = f'git@github.com:{dependency}.git'
+                git_url_dependency = f"git@github.com:{dependency}.git"
                 dependency_path = BASE_PACKAGE_PATH / dependency
                 if not dependency_path.exists():
-                    subprocess.check_call(['git', 'clone', git_url_dependency, str(dependency_path)])
+                    subprocess.check_call(
+                        ["git", "clone", git_url_dependency, str(dependency_path)]
+                    )
 
         # Install requirements
-        requirements_file = BASE_PACKAGE_PATH / module / 'requirements.txt'
+        requirements_file = BASE_PACKAGE_PATH / module / "requirements.txt"
         if requirements_file.exists():
             with requirements_file.open() as f:
                 for dependency in f.readlines():
-                    subprocess.check_call(['pip', 'install', dependency])
+                    subprocess.check_call(["pip", "install", dependency])
 
     @staticmethod
     def load_module_class(module):
@@ -123,9 +131,9 @@ class Import(Expression):
 
         package_path = module_path_obj if is_local_path else BASE_PACKAGE_PATH / module
 
-        with (package_path / 'package.json').open() as f:
+        with (package_path / "package.json").open() as f:
             pkg = json.load(f)
-            for expr in pkg['expressions']:
+            for expr in pkg["expressions"]:
                 if is_local_path:
                     # For local modules, we need to add the path to sys.path
                     parent_dir = package_path.parent
@@ -135,11 +143,15 @@ class Import(Expression):
                     module_name = package_path.name
                     relative_module_path = f"{module_name}.{expr['module'].replace('/', '.')}"
                 else:
-                    module_parts = module.split('/')
-                    relative_module_path = '.'.join([*module_parts, expr['module'].replace('/', '.')])
+                    module_parts = module.split("/")
+                    relative_module_path = ".".join(
+                        [*module_parts, expr["module"].replace("/", ".")]
+                    )
 
                 try:
-                    module_class = getattr(importlib.import_module(relative_module_path), expr['type'])
+                    module_class = getattr(
+                        importlib.import_module(relative_module_path), expr["type"]
+                    )
                     module_classes.append(module_class)
                 except (ImportError, ModuleNotFoundError) as e:
                     logger.error(f"Error importing module {relative_module_path}: {e}")
@@ -158,7 +170,9 @@ class Import(Expression):
         raise Exception(msg)
 
     @staticmethod
-    def load_expression(module, expressions: list[str] | tuple[str] | str) -> list[Expression] | Expression:
+    def load_expression(
+        module, expressions: list[str] | tuple[str] | str
+    ) -> list[Expression] | Expression:
         expression_list, return_single = Import._normalize_expressions(expressions)
         expected_count = len(expression_list)
         expression_targets = set(expression_list)
@@ -175,23 +189,23 @@ class Import(Expression):
                 sys.path.append(str(parent_dir))
             module_name = package_path.name
         else:
-            module_parts = module.split('/')
+            module_parts = module.split("/")
 
-        with (package_path / 'package.json').open() as f:
+        with (package_path / "package.json").open() as f:
             pkg = json.load(f)
-            for expr in pkg['expressions']:
+            for expr in pkg["expressions"]:
                 relative_module_path = (
                     f"{module_name}.{expr['module'].replace('/', '.')}"
                     if is_local_path
-                    else '.'.join([*module_parts, expr['module'].replace('/', '.')])
+                    else ".".join([*module_parts, expr["module"].replace("/", ".")])
                 )
 
-                if expr['type'] not in expression_targets:
+                if expr["type"] not in expression_targets:
                     continue
 
                 try:
                     module_obj = importlib.import_module(relative_module_path)
-                    module_class = getattr(module_obj, expr['type'])
+                    module_class = getattr(module_obj, expr["type"])
                 except (ImportError, ModuleNotFoundError) as e:
                     logger.error(f"Error importing module {relative_module_path}: {e}")
                     raise
@@ -203,11 +217,21 @@ class Import(Expression):
         assert len(module_classes) > 0, f"Expression '{expressions}' not found in module '{module}'"
         module_classes_names = [str(class_.__name__) for class_ in module_classes]
         missing_expressions = [expr for expr in expression_list if expr not in module_classes_names]
-        assert len(module_classes) == expected_count, f"Not all expressions found in module '{module}'. Could not load {missing_expressions}"
+        assert len(module_classes) == expected_count, (
+            f"Not all expressions found in module '{module}'. Could not load {missing_expressions}"
+        )
         return module_classes
 
-    def __new__(cls, module, auto_clone: bool = True, verbose: bool = False, local_path: str | None = None,
-                submodules: bool = False, *args, **kwargs):
+    def __new__(
+        cls,
+        module,
+        auto_clone: bool = True,
+        verbose: bool = False,
+        local_path: str | None = None,
+        submodules: bool = False,
+        *args,
+        **kwargs,
+    ):
         """
         Import a module from GitHub or local path.
 
@@ -226,12 +250,12 @@ class Import(Expression):
         if is_local_path:
             # If module is a local path
             package_path = module_path_obj
-            if not (package_path / 'package.json').exists():
+            if not (package_path / "package.json").exists():
                 msg = f"No package.json found in {module}"
                 UserMessage(msg)
                 raise ValueError(msg)
 
-            with (package_path / 'package.json').open() as f:
+            with (package_path / "package.json").open() as f:
                 pkg = json.load(f)
         else:
             # Module is a GitHub reference
@@ -241,17 +265,17 @@ class Import(Expression):
                 else:
                     Import.get_from_github(module, submodules)
 
-            with (BASE_PACKAGE_PATH / module / 'package.json').open() as f:
+            with (BASE_PACKAGE_PATH / module / "package.json").open() as f:
                 pkg = json.load(f)
-        if 'run' not in pkg:
+        if "run" not in pkg:
             msg = f"Module '{module}' has no 'run' expression defined."
             UserMessage(msg)
             raise Exception(msg)
-        expr = pkg['run']
-        module_rel = expr['module'].replace('/', '.')
-        module_parts = module.split('/')
-        relative_module_path = '.'.join([*module_parts, module_rel])
-        class_ = expr['type']
+        expr = pkg["run"]
+        module_rel = expr["module"].replace("/", ".")
+        module_parts = module.split("/")
+        relative_module_path = ".".join([*module_parts, module_rel])
+        class_ = expr["type"]
         if verbose:
             logger.info(f"Loading module '{relative_module_path}.{expr['type']}'")
         module_class = getattr(importlib.import_module(relative_module_path), class_)
@@ -273,7 +297,9 @@ class Import(Expression):
         """
         # Determine if module is a local path
         local_path_obj = Path(local_path) if local_path is not None else None
-        is_local_path = local_path_obj is not None and local_path_obj.exists() and local_path_obj.is_dir()
+        is_local_path = (
+            local_path_obj is not None and local_path_obj.exists() and local_path_obj.is_dir()
+        )
 
         if not Import.exists(module):
             if is_local_path:
@@ -294,10 +320,12 @@ class Import(Expression):
         if is_local_path:
             # For local path, remove directly
             if module_path_obj.exists():
+
                 def del_rw(_action, name, _exc):
                     path_obj = Path(name)
                     path_obj.chmod(stat.S_IWRITE)
                     path_obj.unlink()
+
                 shutil.rmtree(module_path_obj, onerror=del_rw)
                 logger.success(f"Removed local module at '{module}'")
             else:
@@ -306,15 +334,17 @@ class Import(Expression):
             # For GitHub modules, remove from packages directory
             module_path = BASE_PACKAGE_PATH / module
             if module_path.exists():
+
                 def del_rw(_action, name, _exc):
                     path_obj = Path(name)
                     path_obj.chmod(stat.S_IWRITE)
                     path_obj.unlink()
+
                 shutil.rmtree(module_path, onerror=del_rw)
                 logger.success(f"Removed module '{module}'")
 
                 # Check if folder is empty and remove it
-                parent_path = BASE_PACKAGE_PATH / module.split('/')[0]
+                parent_path = BASE_PACKAGE_PATH / module.split("/")[0]
                 if parent_path.exists() and not any(parent_path.iterdir()):
                     parent_path.rmdir()
                     logger.info(f"Removed empty parent folder '{parent_path}'")
@@ -329,7 +359,9 @@ class Import(Expression):
 
         sub_dirs = []
         for base_dir in base_dirs:
-            sub_dirs.extend([f'{base_dir.name}/{entry.name}' for entry in base_dir.iterdir() if entry.is_dir()])
+            sub_dirs.extend(
+                [f"{base_dir.name}/{entry.name}" for entry in base_dir.iterdir() if entry.is_dir()]
+            )
 
         return sub_dirs
 
@@ -347,16 +379,18 @@ class Import(Expression):
             is_local_path = module_path_obj.exists() and module_path_obj.is_dir()
 
             # Use the appropriate path based on whether it's local or not
-            module_path = module_path_obj if is_local_path else BASE_PACKAGE_PATH / module.replace(".", "/")
+            module_path = (
+                module_path_obj if is_local_path else BASE_PACKAGE_PATH / module.replace(".", "/")
+            )
 
             # Construct the git pull command based on whether submodules should be included
-            pull_cmd = ['git', '-C', str(module_path)]
+            pull_cmd = ["git", "-C", str(module_path)]
             if submodules:
-                pull_cmd.extend(['pull', '--recurse-submodules'])
+                pull_cmd.extend(["pull", "--recurse-submodules"])
                 subprocess.check_call(pull_cmd)
                 logger.success(f"Module '{module}' and its submodules updated.")
             else:
-                pull_cmd.extend(['pull'])
+                pull_cmd.extend(["pull"])
                 subprocess.check_call(pull_cmd)
                 logger.success(f"Module '{module}' updated.")
         else:

symai/interfaces.py

@@ -94,7 +94,7 @@ def cfg_to_interface():
     _add_tts_interface(mapping)
 
     mapping["indexing"] = Interface("naive_vectordb")
-    mapping["scraper"] = Interface("naive_webscraping")
+    mapping["scraper"] = Interface("naive_scrape")
     mapping["stt"] = Interface("whisper")
     mapping["file"] = Interface("file")
 

symai/memory.py

@@ -1,4 +1,3 @@
-
 from . import core_ext
 from .components import Function
 from .symbol import Expression, Symbol
@@ -25,52 +24,56 @@ class SlidingWindowListMemory(Memory):
     def __init__(self, window_size: int = 10, max_size: int = 1000, **kwargs):
         super().__init__(**kwargs)
         self._memory: list[str] = []
-        self._window_size: int  = window_size
-        self._max_size: int     = max_size
+        self._window_size: int = window_size
+        self._max_size: int = max_size
 
     def store(self, query: str, *_args, **_kwargs):
         self._memory.append(query)
         if len(self._memory) > self._max_size:
-            self._memory = self._memory[-self._max_size:]
+            self._memory = self._memory[-self._max_size :]
 
     def forget(self, query: Symbol, *_args, **_kwargs):
         self._memory.remove(query)
 
     def recall(self, *_args, **_kwargs):
-        return self._memory[-self._window_size:]
+        return self._memory[-self._window_size :]
 
 
 class SlidingWindowStringConcatMemory(Memory):
     def __init__(self, *_args, **kwargs):
         super().__init__(**kwargs)
-        self._memory: str       = ''
-        self.marker: str        = '[--++=|=++--]'
+        self._memory: str = ""
+        self.marker: str = "[--++=|=++--]"
 
-    @core_ext.bind(engine='neurosymbolic', property='max_context_tokens')
-    def max_tokens(self): pass
+    @core_ext.bind(engine="neurosymbolic", property="max_context_tokens")
+    def max_tokens(self):
+        pass
 
     def __getstate__(self):
         state = super().__getstate__().copy()
         # Exclude the max_tokens property from being serialized
-        state.pop('_max_tokens', None)
+        state.pop("_max_tokens", None)
         return state
 
     def __setstate__(self, state):
         self.__dict__.update(state)
+
         # Initialize _max_tokens as None, it should be set again after deserialization
-        @core_ext.bind(engine='neurosymbolic', property='max_context_tokens')
-        def _max_tokens(self): pass
+        @core_ext.bind(engine="neurosymbolic", property="max_context_tokens")
+        def _max_tokens(self):
+            pass
+
         self.max_tokens = _max_tokens
 
     def history(self):
         return [hist for hist in self._memory.split(self.marker) if hist]
 
     def drop(self):
-        self._memory = ''
+        self._memory = ""
 
     def store(self, query: str):
         # append to string to memory
-        self._memory += f'{query!s}{self.marker}'
+        self._memory += f"{query!s}{self.marker}"
 
     def forget(self, query: Symbol, *_args, **_kwargs):
         # remove substring from memory
@@ -78,29 +81,33 @@ class SlidingWindowStringConcatMemory(Memory):
         self._memory = str(sym - query)
 
     def recall(self, query: str, *args, **kwargs) -> Symbol:
-        hist    = self.history()
-        memory  = ''
+        hist = self.history()
+        memory = ""
         if len(hist) > 0:
-            memory  = '[MEMORY]\n'
-            val     = '\n'.join(hist)
+            memory = "[MEMORY]\n"
+            val = "\n".join(hist)
             memory += val
         that = self
+
         class Recall(Function):
             @property
             def static_context(self):
                 return that.static_context
+
         func = Recall(memory)
         return func(query, *args, **kwargs)
 
 
 class VectorDatabaseMemory(Memory):
-    def __init__(self, enabled: bool = True, top_k: int = 3, index_name: str = 'defaultindex', **kwargs):
+    def __init__(
+        self, enabled: bool = True, top_k: int = 3, index_name: str = "defaultindex", **kwargs
+    ):
         super().__init__(**kwargs)
         self.enabled: bool = enabled
-        self.top_k: int    = top_k
-        self.index_name    = index_name
+        self.top_k: int = top_k
+        self.index_name = index_name
 
-    def store(self, query: str , *_args, **_kwargs):
+    def store(self, query: str, *_args, **_kwargs):
         if not self.enabled:
             return
 
@@ -110,6 +117,8 @@ class VectorDatabaseMemory(Memory):
         if not self.enabled:
             return None
 
-        res = self.get(Symbol(query).embed().value, index_top_k=self.top_k, index_name=self.index_name).ast()
+        res = self.get(
+            Symbol(query).embed().value, index_top_k=self.top_k, index_name=self.index_name
+        ).ast()
 
-        return [v['metadata']['text'] for v in res['matches']]
+        return [v["metadata"]["text"] for v in res["matches"]]

symai/menu/screen.py

@@ -6,42 +6,51 @@ from ..misc.console import ConsoleStyle
 
 
 def show_splash_screen(print: callable = print_formatted_text):
-    print('\n\n')
-    print('- '*42)
-    print('=='*41 + '=')
-    print(r'''
+    print("\n\n")
+    print("- " * 42)
+    print("==" * 41 + "=")
+    print(
+        r"""
       ____|        |                      _)  |              \    _ _|
       __|  \ \  /  __|   _ \  __ \    __|  |  __|  |   |    _ \     |
       |     `  <   |     __/  |   | \__ \  |  |    |   |   ___ \    |
      _____| _/\_\ \__| \___| _|  _| ____/ _| \__| \__, | _/    _\ ___|
                                                   ____/
-    ''', escape=True)
-    print('- '*42)
+    """,
+        escape=True,
+    )
+    print("- " * 42)
 
 
 def show_info_message(print: callable = print_formatted_text):
-    print('Welcome to SymbolicAI!' + '\n')
-    print('SymbolicAI is an open-source Python project for building AI-powered applications\nand assistants.')
-    print('We utilize the power of large language models and the latest research in AI.' + '\n')
-    print('SymbolicAI is backed by ExtensityAI. We are committed to open research,\nthe democratization of AI tools and much more ...' + '\n')
+    print("Welcome to SymbolicAI!" + "\n")
+    print(
+        "SymbolicAI is an open-source Python project for building AI-powered applications\nand assistants."
+    )
+    print("We utilize the power of large language models and the latest research in AI." + "\n")
+    print(
+        "SymbolicAI is backed by ExtensityAI. We are committed to open research,\nthe democratization of AI tools and much more ..."
+        "\n"
+    )
 
-    print('... and we also like peanut butter and jelly sandwiches, and cookies.' + '\n\n')
-    print('If you like what we are doing please help us achieve our mission!')
-    print('More information is available at https://www.extensity.ai' + '\n')
+    print("... and we also like peanut butter and jelly sandwiches, and cookies." + "\n\n")
+    print("If you like what we are doing please help us achieve our mission!")
+    print("More information is available at https://www.extensity.ai" + "\n")
 
 
 def show_separator(print: callable = print_formatted_text):
-    print('- '*42 + '\n')
+    print("- " * 42 + "\n")
 
 
 def show_intro_menu():
-    if os.environ.get('SYMAI_WARNINGS', '1') == '1':
-        with ConsoleStyle('extensity') as console:
+    if os.environ.get("SYMAI_WARNINGS", "1") == "1":
+        with ConsoleStyle("extensity") as console:
             show_splash_screen(print=console.print)
-        with ConsoleStyle('text') as console:
+        with ConsoleStyle("text") as console:
             show_info_message(print=console.print)
-        with ConsoleStyle('extensity') as console:
+        with ConsoleStyle("extensity") as console:
             show_separator(print=console.print)
 
-if __name__ == '__main__':
+
+if __name__ == "__main__":
     show_intro_menu()

symai/misc/console.py

@@ -1,7 +1,7 @@
 import logging
 import re
 
-#@TODO: refactor to use rich instead of prompt_toolkit
+# @TODO: refactor to use rich instead of prompt_toolkit
 from html import escape as escape_html
 from typing import ClassVar
 
@@ -14,28 +14,28 @@ from pygments.lexers.python import PythonLexer
 from pygments.lexers.shell import BashLexer
 
 logger = logging.getLogger(__name__)
-print = print_formatted_text # noqa
+print = print_formatted_text  # noqa
 
 
 class ConsoleStyle:
     style_types: ClassVar[dict[str, str]] = {
-        'alert':     'orange',
-        'error':     'ansired',
-        'warn':      'ansiyellow',
-        'info':      'ansiblue',
-        'success':   'ansigreen',
-        'extensity': '#009499',
-        'text':      'ansigray',
-        'debug':     'gray',
-        'custom':    'custom',
-        'code':      'code',
-        'default':   '',
+        "alert": "orange",
+        "error": "ansired",
+        "warn": "ansiyellow",
+        "info": "ansiblue",
+        "success": "ansigreen",
+        "extensity": "#009499",
+        "text": "ansigray",
+        "debug": "gray",
+        "custom": "custom",
+        "code": "code",
+        "default": "",
     }
 
-    def __init__(self, style_type = '', color = '', logging: bool = False):
+    def __init__(self, style_type="", color="", logging: bool = False):
         self.style_type = style_type
-        self.color      = color
-        self.logging    = logging
+        self.color = color
+        self.logging = logging
 
     def __call__(self, message):
         self.print(message)
@@ -52,43 +52,43 @@ class ConsoleStyle:
             logger.debug(message)
         # Prepare safe content for HTML printing without mutating the original
         content_for_html = escape_html(message) if escape else message
-        style = self.style_types.get(self.style_type, self.style_types['default'])
+        style = self.style_types.get(self.style_type, self.style_types["default"])
 
-        if style == self.style_types['code']:
+        if style == self.style_types["code"]:
             self._print_code_message(message)
             return
-        if style == self.style_types['default']:
+        if style == self.style_types["default"]:
             print(message)
             return
-        if style == self.style_types['custom']:
+        if style == self.style_types["custom"]:
             self._print_html(self.color, content_for_html)
             return
         self._print_html(style, content_for_html)
 
     def _print_code_message(self, message: str) -> None:
-        segments = re.split(r'(```)', message)
+        segments = re.split(r"(```)", message)
         is_code_segment = False
         for segment in segments:
-            if segment == '```':
+            if segment == "```":
                 is_code_segment = not is_code_segment
                 continue
             if is_code_segment:
                 self._print_code_segment(segment)
                 continue
-            print(segment, end='\n')
+            print(segment, end="\n")
 
     def _print_code_segment(self, segment: str) -> None:
         lexer = self._select_lexer(segment)
         tokens = list(pygments.lex("```" + segment + "```", lexer))
-        print(PygmentsTokens(tokens), end='')
+        print(PygmentsTokens(tokens), end="")
 
     def _select_lexer(self, segment: str):
         lowered_segment = segment.lower()
-        if 'python' in lowered_segment:
+        if "python" in lowered_segment:
             return PythonLexer()
-        if 'javascript' in lowered_segment or 'typescript' in lowered_segment:
+        if "javascript" in lowered_segment or "typescript" in lowered_segment:
             return JavascriptLexer()
-        if 'c++' in lowered_segment:
+        if "c++" in lowered_segment:
             return CppLexer()
         return BashLexer()