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

symai/extended/interfaces/ocr.py

@@ -1,6 +1,6 @@
 from ... import core
-from ...symbol import Expression
 from ...backend.engines.ocr.engine_apilayer import ApiLayerResult
+from ...symbol import Expression
 
 
 class ocr(Expression):
@@ -9,9 +9,11 @@ class ocr(Expression):
         self.name = self.__class__.__name__
 
     def __call__(self, image_url: str, **kwargs) -> ApiLayerResult:
-        if not image_url.startswith('http'):
-            image_url = f'file://{image_url}'
+        if not image_url.startswith("http"):
+            image_url = f"file://{image_url}"
+
         @core.ocr(image=image_url, **kwargs)
         def _func(_) -> ApiLayerResult:
             pass
+
         return _func(self)

symai/extended/interfaces/openai_search.py

@@ -10,7 +10,9 @@ class openai_search(Expression):
 
     def __call__(self, query: Symbol, **kwargs) -> SearchResult:
         query = self._to_symbol(query)
+
         @core.search(query=query.value, **kwargs)
         def _func(_) -> SearchResult:
             pass
+
         return _func(self)

symai/extended/interfaces/parallel.py

@@ -0,0 +1,30 @@
+from ... import core
+from ...backend.engines.search.engine_parallel import ExtractResult, SearchResult
+from ...symbol import Expression, Symbol
+
+
+class parallel(Expression):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.name = self.__class__.__name__
+
+    def search(self, query: Symbol, **kwargs) -> SearchResult:
+        query = self._to_symbol(query)
+
+        @core.search(query=query.value, **kwargs)
+        def _func(_) -> SearchResult:
+            pass
+
+        return _func(self)
+
+    def scrape(self, url: str, **kwargs) -> ExtractResult:
+        symbol = self._to_symbol(url)
+        options = dict(kwargs)
+        options.pop("query", None)
+        options["url"] = symbol.value
+
+        @core.search(query="", **options)
+        def _func(_, *_args, **_inner_kwargs) -> ExtractResult:
+            return None
+
+        return _func(self)

symai/extended/interfaces/perplexity.py

@@ -10,7 +10,9 @@ class perplexity(Expression):
 
     def __call__(self, query: Symbol, **kwargs) -> SearchResult:
         query = self._to_symbol(query)
+
         @core.search(query=query.value, **kwargs)
         def _func(_) -> SearchResult:
             pass
+
         return _func(self)

symai/extended/interfaces/pinecone.py

@@ -1,21 +1,24 @@
-from ... import core
+from ...backend.engines.index.engine_pinecone import PineconeIndexEngine, PineconeResult
 from ...symbol import Expression
-from ...backend.engines.index.engine_pinecone import PineconeResult, PineconeIndexEngine
+from ...utils import UserMessage
 
 
 class pinecone(Expression):
-    def __init__(self, index_name = PineconeIndexEngine._default_index_name, *args, **kwargs):
+    def __init__(self, index_name=PineconeIndexEngine._default_index_name, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.index_name = index_name
         self.name = self.__class__.__name__
 
-    def __call__(self, stmt: str, operation: str = "search", index_name = None, **kwargs) -> PineconeResult:
-        stmt  = self._to_symbol(stmt)
+    def __call__(
+        self, stmt: str, operation: str = "search", index_name=None, **kwargs
+    ) -> PineconeResult:
+        stmt = self._to_symbol(stmt)
         index = self.index_name if index_name is None else index_name
-        if   operation == "search":
+        if operation == "search":
             return self.get(query=stmt.embedding, index_name=index, ori_query=stmt.value, **kwargs)
-        elif operation == "add":
+        if operation == "add":
             return self.add(doc=stmt.zip(), index_name=index, **kwargs)
-        elif operation == "config":
+        if operation == "config":
             return self.index(path=stmt.value, index_name=index, **kwargs)
-        raise NotImplementedError("Operation not supported")
+        UserMessage("Operation not supported", raise_with=NotImplementedError)
+        return None

symai/extended/interfaces/python.py

@@ -9,7 +9,9 @@ class python(Expression):
 
     def __call__(self, expr: str, **kwargs) -> Result:
         sym = self._to_symbol(expr)
+
         @core.execute(**kwargs)
         def _func(_) -> Result:
             pass
+
         return _func(sym)

symai/extended/interfaces/serpapi.py

@@ -1,6 +1,6 @@
 from ... import core
-from ...symbol import Expression, Symbol
 from ...backend.engines.search.engine_serpapi import SearchResult
+from ...symbol import Expression, Symbol
 
 
 class serpapi(Expression):
@@ -10,7 +10,9 @@ class serpapi(Expression):
 
     def __call__(self, query: Symbol, **kwargs) -> SearchResult:
         query = self._to_symbol(query)
+
         @core.search(query=query.value, **kwargs)
         def _func(_) -> SearchResult:
             pass
+
         return _func(self)

symai/extended/interfaces/terminal.py

@@ -1,7 +1,5 @@
-from typing import List
-
-from ...symbol import Expression
 from ...shellsv import process_command
+from ...symbol import Expression
 
 
 class terminal(Expression):
@@ -9,5 +7,5 @@ class terminal(Expression):
         super().__init__(*args, **kwargs)
         self.name = self.__class__.__name__
 
-    def __call__(self, command: str = None, **kwargs) -> "terminal":
+    def __call__(self, command: str | None = None, **kwargs) -> "terminal":
         return self.sym_return_type(process_command(command, **kwargs))

symai/extended/interfaces/tts.py

@@ -1,5 +1,5 @@
 from ... import core
-from ...symbol import Expression, Symbol, Result
+from ...symbol import Expression, Result, Symbol
 
 
 class tts(Expression):
@@ -7,8 +7,9 @@ class tts(Expression):
         super().__init__(*args, **kwargs)
         self.name = self.__class__.__name__
 
-    def __call__(self, prompt: Symbol, path: str, voice: str = 'nova', **kwargs) -> Result:
+    def __call__(self, prompt: Symbol, path: str, voice: str = "nova", **kwargs) -> Result:
         @core.text_to_speech(prompt=str(prompt), path=path, voice=voice, **kwargs)
         def _func(_) -> Result:
             pass
+
         return _func(self)

symai/extended/interfaces/whisper.py

@@ -1,6 +1,6 @@
 from ... import core
-from ...symbol import Expression
 from ...backend.engines.speech_to_text.engine_local_whisper import WhisperResult
+from ...symbol import Expression
 
 
 class whisper(Expression):
@@ -8,8 +8,9 @@ class whisper(Expression):
         super().__init__(*args, **kwargs)
         self.name = self.__class__.__name__
 
-    def __call__(self, audio_path: str, operation: str = 'decode', **kwargs) -> WhisperResult:
+    def __call__(self, audio_path: str, operation: str = "decode", **kwargs) -> WhisperResult:
         @core.speech_to_text(audio=audio_path, prompt=operation, **kwargs)
         def _func(_) -> WhisperResult:
             pass
+
         return _func(self)

symai/extended/interfaces/wolframalpha.py

@@ -1,6 +1,6 @@
 from ... import core
-from ...symbol import Expression
 from ...backend.engines.symbolic.engine_wolframalpha import WolframResult
+from ...symbol import Expression
 
 
 class wolframalpha(Expression):
@@ -12,4 +12,5 @@ class wolframalpha(Expression):
         @core.expression(**kwargs)
         def _func(_, expr: str) -> WolframResult:
             pass
+
         return _func(self, expr)

symai/extended/metrics/__init__.py

@@ -1 +1,11 @@
-from .similarity import *
+from . import similarity as _similarity
+
+__all__ = getattr(_similarity, "__all__", None)  # noqa
+if __all__ is None:
+    __all__ = [name for name in dir(_similarity) if not name.startswith("_")]
+
+for _name in __all__:
+    globals()[_name] = getattr(_similarity, _name)
+
+del _name
+del _similarity

symai/extended/metrics/similarity.py

@@ -1,3 +1,7 @@
+"""
+@TODO: This must go away. As soon as we have Qdrant, everything related to vectordb must be cleaned up.
+"""
+
 import random
 
 import numpy as np
@@ -11,8 +15,7 @@ def get_norm_vector(vector):
     """
     if len(vector.shape) == 1:
         return vector / np.linalg.norm(vector)
-    else:
-        return vector / np.linalg.norm(vector, axis=1)[:, np.newaxis]
+    return vector / np.linalg.norm(vector, axis=1)[:, np.newaxis]
 
 
 def dot_product(vectors, query_vector):
@@ -22,8 +25,7 @@ def dot_product(vectors, query_vector):
     :param query_vector: vector
     :return: dot product between the vector and the matrix of vectors
     """
-    similarities = np.dot(vectors, query_vector.T)
-    return similarities
+    return np.dot(vectors, query_vector.T)
 
 
 def cosine_similarity(vectors, query_vector):
@@ -35,8 +37,7 @@ def cosine_similarity(vectors, query_vector):
     """
     norm_vectors = get_norm_vector(vectors)
     norm_query_vector = get_norm_vector(query_vector)
-    similarities = np.dot(norm_vectors, norm_query_vector.T)
-    return similarities
+    return np.dot(norm_vectors, norm_query_vector.T)
 
 
 def euclidean_metric(vectors, query_vector, get_similarity_score=True):
@@ -49,7 +50,7 @@ def euclidean_metric(vectors, query_vector, get_similarity_score=True):
     """
     similarities = np.linalg.norm(vectors - query_vector, axis=1)
     if get_similarity_score:
-        similarities = 1 / (1 + similarities)
+        return 1 / (1 + similarities)
     return similarities
 
 
@@ -60,12 +61,12 @@ def derridaean_similarity(vectors, query_vector):
     :param query_vector: vector
     :return: derridaean similarity between the vector and the matrix of vectors
     """
+
     def random_change(value):
         return value + random.uniform(-0.2, 0.2)
 
     similarities = cosine_similarity(vectors, query_vector)
-    derrida_similarities = np.vectorize(random_change)(similarities)
-    return derrida_similarities
+    return np.vectorize(random_change)(similarities)
 
 
 def adams_similarity(vectors, query_vector):
@@ -75,12 +76,12 @@ def adams_similarity(vectors, query_vector):
     :param query_vector: vector
     :return: adams similarity between the vector and the matrix of vectors
     """
-    def adams_change(value):
+
+    def adams_change(_value):
         return 0.42
 
     similarities = cosine_similarity(vectors, query_vector)
-    adams_similarities = np.vectorize(adams_change)(similarities)
-    return adams_similarities
+    return np.vectorize(adams_change)(similarities)
 
 
 def ranking_algorithm_sort(vectors, query_vector, top_k=5, metric=cosine_similarity):
@@ -94,4 +95,4 @@ def ranking_algorithm_sort(vectors, query_vector, top_k=5, metric=cosine_similar
     """
     similarities = metric(vectors, query_vector)
     top_indices = np.argsort(similarities, axis=0)[-top_k:][::-1]
-    return top_indices.flatten(), similarities[top_indices].flatten()
+    return top_indices.flatten(), similarities[top_indices].flatten()

symai/extended/os_command.py

@@ -1,10 +1,9 @@
 import platform
 import subprocess
 
-from typing import Dict, List
-
 from ..post_processors import CodeExtractPostProcessor
 from ..symbol import Expression, Symbol
+from ..utils import UserMessage
 
 Context = """[DESCRIPTION]:
 Adapt the user query to an OS patform command (commands must be executable in terminal, shell, bash or powershell)!
@@ -62,41 +61,52 @@ Write an executable command that starts a process according to the user query, p
 
 
 class OSCommand(Expression):
-    def __init__(self, programs:        List[str],
-                       metadata:   Dict[str, str] = {},
-                       verbose:              bool = False,
-                       os_platform:           str = 'auto',
-                       **kwargs):
+    def __init__(
+        self,
+        programs: list[str],
+        metadata: dict[str, str] | None = None,
+        verbose: bool = False,
+        os_platform: str = "auto",
+        **kwargs,
+    ):
+        if metadata is None:
+            metadata = {}
         super().__init__(**kwargs)
-        self.verbose:            bool = verbose
-        self.os_platform:         str = os_platform
-        self.programs:      List[str] = programs
-        self.meta: Dict[str, str]     = metadata
+        self.verbose: bool = verbose
+        self.os_platform: str = os_platform
+        self.programs: list[str] = programs
+        self.meta: dict[str, str] = metadata
 
-        if self.os_platform == 'auto':
+        if self.os_platform == "auto":
             self.os_platform = platform.platform()
         if len(programs) == 0:
-            raise Exception('No programs specified!')
+            UserMessage("No programs specified!", raise_with=Exception)
 
-    def execute_os_command(self, *args, **kwargs):
+    def execute_os_command(self, *args, **_kwargs):
         command = args[0]
-        print(f'Executing {self.os_platform} command: {command}')
-        if 'linux' in self.os_platform.lower():
-            return [subprocess.run(["bash", "-c", str(command)])]
-        elif 'windows' in self.os_platform.lower():
-            return [subprocess.run(["powershell", "-Command", str(command)])]
-        elif 'mac' in self.os_platform.lower():
-            return [subprocess.run(["bash", "-c", str(command)])]
-        else:
-            raise Exception('Unsupported platform!')
+        UserMessage(f"Executing {self.os_platform} command: {command}")
+        if "linux" in self.os_platform.lower():
+            return [subprocess.run(["bash", "-c", str(command)], check=False)]
+        if "windows" in self.os_platform.lower():
+            return [subprocess.run(["powershell", "-Command", str(command)], check=False)]
+        if "mac" in self.os_platform.lower():
+            return [subprocess.run(["bash", "-c", str(command)], check=False)]
+        UserMessage("Unsupported platform!", raise_with=Exception)
+        return []
 
     def forward(self, sym: Symbol, **kwargs) -> Expression:
         sym = self._to_symbol(sym)
-        kwargs['verbose'] = self.verbose
+        kwargs["verbose"] = self.verbose
 
-        prompt = Context.format(programs=self.programs,
-                                platform=self.os_platform,
-                                query=sym,
-                                metadata=self.meta)
+        prompt = Context.format(
+            programs=self.programs, platform=self.os_platform, query=sym, metadata=self.meta
+        )
         command = sym.query(prompt, post_processors=[CodeExtractPostProcessor()], **kwargs)
-        return self.sym_return_type(self.output(expr=self.execute_os_command, raw_input=True, processed_input=command.value, **kwargs))
+        return self.sym_return_type(
+            self.output(
+                expr=self.execute_os_command,
+                raw_input=True,
+                processed_input=command.value,
+                **kwargs,
+            )
+        )

symai/extended/packages/__init__.py

@@ -1,3 +1,29 @@
-from .symdev import *
-from .sympkg import *
-from .symrun import *
+from . import symdev as _symdev
+from . import sympkg as _sympkg
+from . import symrun as _symrun
+
+__all__ = []
+_seen_names = set()
+
+
+def _export_module(module, seen_names: set[str] = _seen_names) -> None:
+    public_names = getattr(module, "__all__", None)
+    if public_names is None:
+        public_names = [name for name in dir(module) if not name.startswith("_")]
+    for name in public_names:
+        globals()[name] = getattr(module, name)
+        if name not in seen_names:
+            __all__.append(name)
+            seen_names.add(name)
+
+
+for _module in (_symdev, _sympkg, _symrun):
+    _export_module(_module)
+
+
+del _export_module
+del _module
+del _seen_names
+del _symdev
+del _sympkg
+del _symrun

symai/extended/packages/symdev.py

@@ -9,78 +9,86 @@ from loguru import logger
 from ... import config_manager
 
 
-class PackageInitializer():
+class PackageInitializer:
     def __init__(self):
-        self.package_dir = Path(config_manager.config_dir) / 'packages'
+        self.package_dir = Path(config_manager.config_dir) / "packages"
 
-        if not os.path.exists(self.package_dir):
-            os.makedirs(self.package_dir)
+        if not self.package_dir.exists():
+            self.package_dir.mkdir(parents=True)
 
         os.chdir(self.package_dir)
 
         parser = argparse.ArgumentParser(
-            description='''SymbolicAI package initializer.
-            Initialize a new GitHub package from the command line.''',
-            usage='''symdev <command> <username>/<package_name>
+            description="""SymbolicAI package initializer.
+            Initialize a new GitHub package from the command line.""",
+            usage="""symdev <command> <username>/<package_name>
             Available commands:
             c   Create a new package [default if no command is given]
-'''
+""",
         )
 
-        parser.add_argument('command', help='Subcommand to run')
+        parser.add_argument("command", help="Subcommand to run")
         args = parser.parse_args(sys.argv[1:2])
         if len(args.command) > 1 and not hasattr(self, args.command):
-            setattr(args, 'package', args.command)
+            args.package = args.command
             self.c(args)
         elif len(args.command) == 1 and not hasattr(self, args.command):
-            logger.error('Unrecognized command')
+            logger.error("Unrecognized command")
             parser.print_help()
             exit(1)
         else:
             getattr(self, args.command)()
 
-    def c(self, args = None):
+    def c(self, args=None):
         parser = argparse.ArgumentParser(
-            description='Create a new package',
-            usage='symdev c <username>/<package>'
+            description="Create a new package", usage="symdev c <username>/<package>"
+        )
+        parser.add_argument(
+            "package", help="Name of user based on GitHub username and package to install"
         )
-        parser.add_argument('package', help='Name of user based on GitHub username and package to install')
         if args is None:
             args = parser.parse_args(sys.argv[2:3])
-        vals = args.package.split('/')
+        vals = args.package.split("/")
         try:
             username = vals[0]
             package_name = vals[1]
-        except:
-            logger.error('Invalid package name: {git_username}/{package_name}')
+        except IndexError:
+            logger.error("Invalid package name: {git_username}/{package_name}")
             parser.print_help()
             exit(1)
 
-        package_path = os.path.join(self.package_dir, username, package_name)
-        if os.path.exists(package_path):
-            logger.info('Package already exists')
+        package_path = self.package_dir / username / package_name
+        if package_path.exists():
+            logger.info("Package already exists")
             exit(1)
 
-        logger.info('Creating package...')
-        os.makedirs(package_path)
-        os.makedirs(os.path.join(package_path, 'src'))
-
-        with open(os.path.join(package_path, '.gitignore'), 'w'): pass
-        with open(os.path.join(package_path, 'LICENSE'), 'w') as f:
-            f.write('MIT License')
-        with open(os.path.join(package_path, 'README.md'), 'w') as f:
-            f.write('# ' + package_name + '\n## <Project Description>')
-        with open(os.path.join(package_path, 'requirements.txt'), 'w'): pass
-        with open(os.path.join(package_path, 'package.json'), 'w') as f:
-            json.dump({
-                'version': '0.0.1',
-                'name': username+'/'+package_name,
-                'description': '<Project Description>',
-                'expressions': [{'module': 'src/func', 'type': 'MyExpression'}],
-                'run': {'module': 'src/func', 'type': 'MyExpression'},
-                'dependencies': []
-            }, f, indent=4)
-        with open(os.path.join(package_path, 'src', 'func.py'), 'w') as f:
+        logger.info("Creating package...")
+        package_path.mkdir(parents=True)
+        src_path = package_path / "src"
+        src_path.mkdir(parents=True)
+
+        with (package_path / ".gitignore").open("w"):
+            pass
+        with (package_path / "LICENSE").open("w") as f:
+            f.write("MIT License")
+        with (package_path / "README.md").open("w") as f:
+            f.write("# " + package_name + "\n## <Project Description>")
+        with (package_path / "requirements.txt").open("w"):
+            pass
+        with (package_path / "package.json").open("w") as f:
+            json.dump(
+                {
+                    "version": "0.0.1",
+                    "name": username + "/" + package_name,
+                    "description": "<Project Description>",
+                    "expressions": [{"module": "src/func", "type": "MyExpression"}],
+                    "run": {"module": "src/func", "type": "MyExpression"},
+                    "dependencies": [],
+                },
+                f,
+                indent=4,
+            )
+        with (src_path / "func.py").open("w") as f:
             f.write("""from symai import Expression, Function
 
 
@@ -99,12 +107,12 @@ class MyExpression(Expression):
         data = self._to_symbol(data)
         self.fn.format(template=template)
         return self.fn(data, *args, **kwargs)""")
-            logger.success('Package created successfully at: ' + package_path)
+            logger.success("Package created successfully at: " + str(package_path))
 
 
 def run() -> None:
     PackageInitializer()
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     run()