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

symai/memory.py

@@ -1,8 +1,6 @@
-from typing import List
-
 from . import core_ext
-from .symbol import Expression, Symbol
 from .components import Function
+from .symbol import Expression, Symbol
 
 
 class Memory(Expression):
@@ -25,90 +23,102 @@ class Memory(Expression):
 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._memory: list[str] = []
+        self._window_size: int = window_size
+        self._max_size: int = max_size
 
-    def store(self, query: str, *args, **kwargs):
+    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):
+    def forget(self, query: Symbol, *_args, **_kwargs):
         self._memory.remove(query)
 
-    def recall(self, *args, **kwargs):
-        return self._memory[-self._window_size:]
+    def recall(self, *_args, **_kwargs):
+        return self._memory[-self._window_size :]
 
 
 class SlidingWindowStringConcatMemory(Memory):
-    def __init__(self, *args, **kwargs):
+    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'{str(query)}{self.marker}'
+        self._memory += f"{query!s}{self.marker}"
 
-    def forget(self, query: Symbol, *args, **kwargs):
+    def forget(self, query: Symbol, *_args, **_kwargs):
         # remove substring from memory
         sym = Symbol(self._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):
-        if not self.enabled: return
+    def store(self, query: str, *_args, **_kwargs):
+        if not self.enabled:
+            return
 
         self.add(Symbol(query).zip(), index_name=self.index_name)
 
-    def recall(self, query: str, *args, **kwargs):
-        if not self.enabled: return
+    def recall(self, query: str, *_args, **_kwargs):
+        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,41 +1,41 @@
-import re
-import pygments
 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 pygments.lexers.python import PythonLexer
-from pygments.lexers.javascript import JavascriptLexer
+from typing import ClassVar
+
+import pygments
+from prompt_toolkit import HTML, print_formatted_text
+from prompt_toolkit.formatted_text import PygmentsTokens
 from pygments.lexers.c_cpp import CppLexer
+from pygments.lexers.javascript import JavascriptLexer
+from pygments.lexers.python import PythonLexer
 from pygments.lexers.shell import BashLexer
-from prompt_toolkit import print_formatted_text
-from prompt_toolkit import HTML
-from prompt_toolkit.formatted_text import PygmentsTokens
-
 
 logger = logging.getLogger(__name__)
-print = print_formatted_text
+print = print_formatted_text  # noqa
 
 
-class ConsoleStyle(object):
-    style_types = {
-        'alert':     'orange',
-        'error':     'ansired',
-        'warn':      'ansiyellow',
-        'info':      'ansiblue',
-        'success':   'ansigreen',
-        'extensity': '#009499',
-        'text':      'ansigray',
-        'debug':     'gray',
-        'custom':    'custom',
-        'code':      'code',
-        'default':   '',
+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": "",
     }
 
-    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,35 +52,45 @@ class ConsoleStyle(object):
             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']:
-            # Split the message using ``` as delimiter
-            segments = re.split(r'(```)', message)
-            is_code = False
-            for segment in segments:
-                if segment == '```':
-                    is_code = not is_code
-                    continue
-                if is_code:
-                    # Determine lexer
-                    if 'python' in segment.lower():
-                        lexer = PythonLexer()
-                    elif 'javascript' in segment.lower() or 'typescript' in segment.lower():
-                        lexer = JavascriptLexer()
-                    elif 'c++' in segment.lower():
-                        lexer = CppLexer()
-                    else:
-                        lexer = BashLexer()
-                    # Print highlighted code
-                    tokens = list(pygments.lex("```" + segment + "```", lexer))
-                    print(PygmentsTokens(tokens), end='')
-                else:
-                    # Print the segment normally
-                    print(segment, end='\n')
-        elif style == self.style_types['default']:
+        if style == self.style_types["code"]:
+            self._print_code_message(message)
+            return
+        if style == self.style_types["default"]:
             print(message)
-        elif style == self.style_types['custom']:
-            print(HTML(f'<style fg="{self.color}">{content_for_html}</style>'))
-        else:
-            print(HTML(f'<style fg="{style}">{content_for_html}</style>'))
+            return
+        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)
+        is_code_segment = False
+        for segment in segments:
+            if segment == "```":
+                is_code_segment = not is_code_segment
+                continue
+            if is_code_segment:
+                self._print_code_segment(segment)
+                continue
+            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="")
+
+    def _select_lexer(self, segment: str):
+        lowered_segment = segment.lower()
+        if "python" in lowered_segment:
+            return PythonLexer()
+        if "javascript" in lowered_segment or "typescript" in lowered_segment:
+            return JavascriptLexer()
+        if "c++" in lowered_segment:
+            return CppLexer()
+        return BashLexer()
+
+    def _print_html(self, color: str, content: str) -> None:
+        print(HTML(f'<style fg="{color}">{content}</style>'))

symai/misc/loader.py

@@ -1,12 +1,15 @@
 import sys
 from itertools import cycle
 from shutil import get_terminal_size
-from threading import Thread, Event
+from threading import Event, Thread
 from time import sleep
+
 from prompt_toolkit import print_formatted_text
+
 from .console import ConsoleStyle
 
-print = print_formatted_text
+print = print_formatted_text  # noqa
+
 
 class Loader:
     def __init__(self, desc="Loading...", end="\n", timeout=0.1):
@@ -29,7 +32,7 @@ class Loader:
         for c in cycle(self.steps):
             if self.done.is_set():
                 break
-            with ConsoleStyle('debug'):
+            with ConsoleStyle("debug"):
                 sys.stdout.write(f"\r{self.desc} {c}  ")
                 sys.stdout.flush()
                 sys.stdout.write(f"\r{self.end}")
@@ -44,7 +47,7 @@ class Loader:
         self.done.set()
         self._thread.join()
         cols = get_terminal_size((80, 20)).columns
-        with ConsoleStyle('debug'):
+        with ConsoleStyle("debug"):
             sys.stdout.write("\r" + " " * cols)
             sys.stdout.flush()
             sys.stdout.write(f"\r{self.end}")
@@ -56,4 +59,4 @@ class Loader:
         self.stop()
 
     def print(self, message):
-        print(message, style='ansigray')
+        print(message, style="ansigray")

symai/models/__init__.py

@@ -1,2 +1,18 @@
-from .base import Const, LengthConstraint, LLMDataModel, CustomConstraint, build_dynamic_llm_datamodel
+from .base import (
+    Const,
+    CustomConstraint,
+    LengthConstraint,
+    LLMDataModel,
+    build_dynamic_llm_datamodel,
+)
 from .errors import ExceptionWithUsage, TypeValidationError
+
+__all__ = [
+    "Const",
+    "CustomConstraint",
+    "ExceptionWithUsage",
+    "LLMDataModel",
+    "LengthConstraint",
+    "TypeValidationError",
+    "build_dynamic_llm_datamodel",
+]