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

symai/extended/packages/sympkg.py

@@ -8,22 +8,23 @@ from loguru import logger
 
 from ... import config_manager
 from ...imports import Import
+from ...utils import UserMessage
 
 
-class PackageHandler():
+class PackageHandler:
     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 manager.
+            description="""SymbolicAI package manager.
             Manage extensions from the command line.
-            You can (i) install, (r) remove, (l) list installed, (u) update a module or (U) update all modules.''',
-            usage='''sympkg <command> [<args>]
+            You can (i) install, (r) remove, (l) list installed, (u) update a module or (U) update all modules.""",
+            usage="""sympkg <command> [<args>]
 
             The most commonly used sympkg commands are:
             i   Install a new package (--local-path PATH, --submodules)
@@ -31,29 +32,33 @@ class PackageHandler():
             l   List all installed packages
             u   Update an installed package (--submodules)
             U   Update all installed packages (--submodules)
-            '''
+            """,
         )
 
-        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)
+        command_aliases = {"l": "list_packages"}
+        command = command_aliases.get(args.command, args.command)
+        if len(command) > 1 and not hasattr(self, command):
+            args.package = args.command
             self.i(args)
-        elif len(args.command) == 1 and not hasattr(self, args.command):
-            logger.error('Unrecognized command')
+        elif len(command) == 1 and not hasattr(self, command):
+            logger.error("Unrecognized command")
             parser.print_help()
             exit(1)
         else:
-            getattr(self, args.command)()
+            getattr(self, command)()
 
-    def i(self, args = None):
+    def i(self, args=None):
         parser = argparse.ArgumentParser(
-            description='Install a new package',
-            usage='sympkg i [package] [--local-path PATH] [--submodules]'
+            description="Install a new package",
+            usage="sympkg i [package] [--local-path PATH] [--submodules]",
+        )
+        parser.add_argument("package", help="Name of package to install")
+        parser.add_argument("--local-path", "-l", help="Local path to package directory")
+        parser.add_argument(
+            "--submodules", "-s", action="store_true", help="Initialize submodules for GitHub repos"
         )
-        parser.add_argument('package', help='Name of package to install')
-        parser.add_argument('--local-path', '-l', help='Local path to package directory')
-        parser.add_argument('--submodules', '-s', action='store_true', help='Initialize submodules for GitHub repos')
 
         if args is None:
             args = parser.parse_args(sys.argv[2:])
@@ -62,46 +67,47 @@ class PackageHandler():
 
     def r(self):
         parser = argparse.ArgumentParser(
-            description='Remove an installed package',
-            usage='sympkg r [package]'
+            description="Remove an installed package", usage="sympkg r [package]"
         )
-        parser.add_argument('package', help='Name of package to remove')
+        parser.add_argument("package", help="Name of package to remove")
         args = parser.parse_args(sys.argv[2:])
         Import.remove(args.package)
 
-    def l(self):
-        pprint.pprint(Import.list_installed())
+    def list_packages(self):
+        UserMessage(pprint.pformat(Import.list_installed()))
 
     def u(self):
         parser = argparse.ArgumentParser(
-            description='Update an installed package',
-            usage='sympkg u [package] [--submodules]'
+            description="Update an installed package", usage="sympkg u [package] [--submodules]"
+        )
+        parser.add_argument("package", help="Name of package to update")
+        parser.add_argument(
+            "--submodules", "-s", action="store_true", help="Update submodules as well"
         )
-        parser.add_argument('package', help='Name of package to update')
-        parser.add_argument('--submodules', '-s', action='store_true', help='Update submodules as well')
         args = parser.parse_args(sys.argv[2:])
         Import.update(args.package, args.submodules)
 
     def U(self):
         parser = argparse.ArgumentParser(
-            description='Update all installed packages',
-            usage='sympkg U [--submodules]'
+            description="Update all installed packages", usage="sympkg U [--submodules]"
+        )
+        parser.add_argument(
+            "--submodules", "-s", action="store_true", help="Update submodules as well"
         )
-        parser.add_argument('--submodules', '-s', action='store_true', help='Update submodules as well')
         args = parser.parse_args(sys.argv[2:])
 
         packages = Import.list_installed()
         for package in packages:
             try:
-                logger.info(f'[UPDATE]: Updating {package}...')
+                logger.info(f"[UPDATE]: Updating {package}...")
                 Import.update(package, args.submodules)
             except Exception as e:
-                logger.error(f'[SKIP]: Error updating {package}: {e}')
+                logger.error(f"[SKIP]: Error updating {package}: {e}")
 
 
 def run() -> None:
     PackageHandler()
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     run()

symai/extended/packages/symrun.py

@@ -3,7 +3,6 @@ import json
 import os
 import sys
 from pathlib import Path
-from typing import Optional
 
 from loguru import logger
 
@@ -13,33 +12,35 @@ from ...misc.console import ConsoleStyle
 from ...misc.loader import Loader
 
 
-class PackageRunner():
+class PackageRunner:
     def __init__(self):
-        self.package_dir = Path(config_manager.config_dir) / 'packages'
-        self.aliases_file = self.package_dir / 'aliases.json'
+        self.package_dir = Path(config_manager.config_dir) / "packages"
+        self.aliases_file = self.package_dir / "aliases.json"
 
-        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)
 
         try:
             parser = argparse.ArgumentParser(
-                description='''SymbolicAI package runner.
-                Run a package in command line.''',
-                usage='''symrun <alias> [<args>] | <command> <alias> [<package>]
+                description="""SymbolicAI package runner.
+                Run a package in command line.""",
+                usage="""symrun <alias> [<args>] | <command> <alias> [<package>]
                 The most commonly used symrun commands are:
                 <alias> [<args>]    Run an alias
                 c <alias> <package> Create a new alias
                 l                   List all aliases
                 r <alias>           Remove an alias
-'''
+""",
             )
 
-            parser.add_argument('command', help='Subcommand to run')
+            parser.add_argument("command", help="Subcommand to run")
             args = parser.parse_args(sys.argv[1:2])
-            getattr(self, args.command)()
-        except:
+            command_aliases = {"l": "list_aliases"}
+            command = command_aliases.get(args.command, args.command)
+            getattr(self, command)()
+        except Exception:
             if len(sys.argv) > 1:
                 self.run_alias()
             else:
@@ -47,68 +48,75 @@ class PackageRunner():
                 exit(1)
 
     def load_aliases(self):
-        if not os.path.exists(self.aliases_file):
+        if not self.aliases_file.exists():
             return {}
 
-        with open(self.aliases_file, 'r') as f:
+        with self.aliases_file.open() as f:
             return json.load(f)
 
     def save_aliases(self, aliases):
-        with open(self.aliases_file, 'w') as f:
+        with self.aliases_file.open("w") as f:
             json.dump(aliases, f)
 
-    def console(self, header: str, output: Optional[object] = None):
-        with ConsoleStyle('success'):
+    def console(self, header: str, output: object | None = None):
+        with ConsoleStyle("success"):
             logger.success(header)
         if output is not None:
-            with ConsoleStyle('info'):
+            with ConsoleStyle("info"):
                 logger.info(str(output))
 
     def run_alias(self):
         parser = argparse.ArgumentParser(
-            description='This command runs the alias from the aliases.json file. If the alias is not found, it will run the command as a package.',
-            usage='symrun <alias> [<args> | <kwargs>]*'
+            description="This command runs the alias from the aliases.json file. If the alias is not found, it will run the command as a package.",
+            usage="symrun <alias> [<args> | <kwargs>]*",
+        )
+        parser.add_argument("alias", help="Name of alias to run")
+        parser.add_argument("params", nargs=argparse.REMAINDER)
+        parser.add_argument(
+            "--submodules", "-s", action="store_true", help="Initialize submodules for GitHub repos"
         )
-        parser.add_argument('alias', help='Name of alias to run')
-        parser.add_argument('params', nargs=argparse.REMAINDER)
-        parser.add_argument('--submodules', '-s', action='store_true', help='Initialize submodules for GitHub repos')
         args = parser.parse_args(sys.argv[1:])
 
         aliases = self.load_aliases()
         # try running the alias or as package
         package = aliases.get(args.alias) or args.alias
 
-        arg_values = [arg for arg in args.params if '=' not in arg]
-        kwargs = {arg.split('=')[0]: arg.split('=')[1] for arg in args.params if '=' in arg}
+        arg_values = [arg for arg in args.params if "=" not in arg]
+        kwargs = {arg.split("=")[0]: arg.split("=")[1] for arg in args.params if "=" in arg}
 
         if package is None:
-            with ConsoleStyle('error'):
-                logger.error("Alias run of `{}` not found. Please check your command {}".format(args.alias, args))
+            with ConsoleStyle("error"):
+                logger.error(
+                    f"Alias run of `{args.alias}` not found. Please check your command {args}"
+                )
             parser.print_help()
-            return
+            return None
 
-        arg_values = [arg for arg in args.params if '=' not in arg]
-        kwargs = {arg.split('=')[0]: arg.split('=')[1] for arg in args.params if '=' in arg}
+        arg_values = [arg for arg in args.params if "=" not in arg]
+        kwargs = {arg.split("=")[0]: arg.split("=")[1] for arg in args.params if "=" in arg}
 
         try:
             # Add submodules to kwargs if specified
             if args.submodules:
-                kwargs['submodules'] = True
+                kwargs["submodules"] = True
 
             # Check if package is a local path
-            if os.path.exists(package) and os.path.isdir(package):
+            package_path = Path(package)
+            if package_path.exists() and package_path.is_dir():
                 # Local path - pass directly
                 expr = Import(package, **kwargs)
             else:
                 # GitHub reference
                 expr = Import(package, **kwargs)
         except Exception as e:
-            with ConsoleStyle('error'):
-                logger.error("Error: {} in package `{}`.\nPlease check your command {} or if package is available.".format(str(e), package, args))
+            with ConsoleStyle("error"):
+                logger.error(
+                    f"Error: {e!s} in package `{package}`.\nPlease check your command {args} or if package is available."
+                )
             parser.print_help()
-            return
+            return None
 
-        if '--disable-pbar' not in arg_values:
+        if "--disable-pbar" not in arg_values:
             with Loader(desc="Inference ...", end=""):
                 result = expr(*arg_values, **kwargs)
         else:
@@ -117,50 +125,55 @@ class PackageRunner():
         if result is not None:
             self.console(result)
         else:
-            self.console("Execution of {} => {} completed successfully.".format(args.alias, package))
+            self.console(f"Execution of {args.alias} => {package} completed successfully.")
 
         return result
 
     def c(self):
         parser = argparse.ArgumentParser(
-            description='This will create a new alias entry in the alias json file. Exsisting aliases will be overwritten.',
-            usage='symrun c <alias> <package>'
+            description="This will create a new alias entry in the alias json file. Exsisting aliases will be overwritten.",
+            usage="symrun c <alias> <package>",
+        )
+        parser.add_argument(
+            "alias", help="Name of user based on GitHub username and package to install"
+        )
+        parser.add_argument(
+            "package",
+            help="Name of the package: <user>/<package> where user is based on GitHub username and package to install",
         )
-        parser.add_argument('alias', help='Name of user based on GitHub username and package to install')
-        parser.add_argument('package', help='Name of the package: <user>/<package> where user is based on GitHub username and package to install')
         args = parser.parse_args(sys.argv[2:])
 
         aliases = self.load_aliases()
         aliases[args.alias] = args.package
         self.save_aliases(aliases)
-        self.console("Alias {} => {} created successfully.".format(args.alias, args.package))
+        self.console(f"Alias {args.alias} => {args.package} created successfully.")
 
-    def l(self):
+    def list_aliases(self):
         aliases = self.load_aliases()
         # format the aliases output as a table of key value pairs
         self.console("Aliases:\n------------------")
         for alias, package in aliases.items():
-            self.console(f'{alias} => {package}')
+            self.console(f"{alias} => {package}")
         self.console("------------------")
 
     def r(self):
         parser = argparse.ArgumentParser(
-            description='This will remove the alias name from the alias json file.',
-            usage='symrun r <alias>'
+            description="This will remove the alias name from the alias json file.",
+            usage="symrun r <alias>",
         )
-        parser.add_argument('alias', help='Name of alias to remove')
+        parser.add_argument("alias", help="Name of alias to remove")
         args = parser.parse_args(sys.argv[2:])
 
         aliases = self.load_aliases()
         if args.alias in aliases:
             del aliases[args.alias]
         self.save_aliases(aliases)
-        self.console("Alias {} removed successfully.".format(args.alias))
+        self.console(f"Alias {args.alias} removed successfully.")
 
 
 def run() -> None:
     PackageRunner()
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     run()

symai/extended/repo_cloner.py

@@ -1,9 +1,10 @@
 from pathlib import Path
-from typing import Optional
+
 from git import Repo
 
-from ..symbol import Expression
 from ..backend.settings import HOME_PATH
+from ..symbol import Expression
+from ..utils import UserMessage
 
 
 class RepositoryCloner(Expression):
@@ -16,9 +17,10 @@ class RepositoryCloner(Expression):
       repo_path (Optional[str]): The path where to clone the repository.
                                  By default it will be at '~/.symai/repos/'.
     """
-    def __init__(self, repo_path: Optional[str] = None, **kwargs):
+
+    def __init__(self, repo_path: str | None = None, **kwargs):
         super().__init__(**kwargs)
-        self.repo_dir = HOME_PATH / 'repos/' if repo_path is None else Path(repo_path)
+        self.repo_dir = HOME_PATH / "repos/" if repo_path is None else Path(repo_path)
         if not self.repo_dir.exists():
             self.repo_dir.mkdir(parents=True, exist_ok=True)
 
@@ -33,26 +35,26 @@ class RepositoryCloner(Expression):
         Returns:
           str: The root path of the cloned repository.
         """
-        repo_name = url.split('/')[-1].replace('.git', '')
+        repo_name = url.split("/")[-1].replace(".git", "")
         if (self.repo_dir / repo_name).is_dir():
-            print(f'Repository {repo_name} already exists. Checking for updates...')
+            UserMessage(f"Repository {repo_name} already exists. Checking for updates...")
             try:
                 repo = Repo(self.repo_dir / repo_name)
                 current = repo.head.commit
                 repo.remotes.origin.pull()
                 if current != repo.head.commit:
-                    print(f'Repository {repo_name} updated.')
+                    UserMessage(f"Repository {repo_name} updated.")
                 else:
-                    print(f'Repository {repo_name} is up-to-date.')
+                    UserMessage(f"Repository {repo_name} is up-to-date.")
             except Exception as e:
-                print(f'An error occurred: {e}')
+                UserMessage(f"An error occurred: {e}")
                 raise e
         else:
-            print(f'Cloning repository {repo_name}...')
+            UserMessage(f"Cloning repository {repo_name}...")
             try:
                 Repo.clone_from(url, self.repo_dir / repo_name)
-                print(f'Repository {repo_name} cloned successfully.')
+                UserMessage(f"Repository {repo_name} cloned successfully.")
             except Exception as e:
-                print(f'Failed to clone the repository. An error occurred: {e}')
+                UserMessage(f"Failed to clone the repository. An error occurred: {e}")
                 raise e
         return str(self.repo_dir / repo_name)

symai/extended/seo_query_optimizer.py

@@ -4,7 +4,6 @@ from ..pre_processors import PreProcessor
 from ..prompts import Prompt
 from ..symbol import Expression, Symbol
 
-
 SEO_OPTIMIZER_DESCRIPTION = """[Description]
 You are a SEO query optimizer. You are given a list of queries, phrases or sentences and you need to optimize them for search engines.
 Assume your search engines are based on vector databases and contain indices of GitHub repositories, papers and other resources.
@@ -17,7 +16,7 @@ The number of resulting queries should be between 1 and 8 statements separated b
 
 class SEOQueryOptimizerPreProcessor(PreProcessor):
     def __call__(self, argument):
-        return '$> {} =>'.format(str(argument.args[0]))
+        return f"$> {argument.args[0]!s} =>"
 
 
 class SEOQueryOptimizer(Expression):
@@ -30,18 +29,21 @@ class SEOQueryOptimizer(Expression):
         self.sym_return_type = SEOQueryOptimizer
 
     def forward(self, sym: Symbol, **kwargs) -> Symbol:
-        @core.few_shot(prompt="Extract relationships between entities:\n",
-                  examples=Prompt([
-                        '$> John has a dog. =>John dog EOF',
-                        '$> How can i find on wikipedia an article about programming? Preferably about python programming. =>Wikipedia python programming tutorial EOF',
-                        '$> Similarly, the term general linguistics is used to distinguish core linguistics from other types of study =>general linguistics term, core linguistics from other types of study EOF',
-                  ]),
-                  pre_processors=[SEOQueryOptimizerPreProcessor()],
-                  post_processors=[StripPostProcessor()],
-                  stop=['EOF'], **kwargs)
+        @core.few_shot(
+            prompt="Extract relationships between entities:\n",
+            examples=Prompt(
+                [
+                    "$> John has a dog. =>John dog EOF",
+                    "$> How can i find on wikipedia an article about programming? Preferably about python programming. =>Wikipedia python programming tutorial EOF",
+                    "$> Similarly, the term general linguistics is used to distinguish core linguistics from other types of study =>general linguistics term, core linguistics from other types of study EOF",
+                ]
+            ),
+            pre_processors=[SEOQueryOptimizerPreProcessor()],
+            post_processors=[StripPostProcessor()],
+            stop=["EOF"],
+            **kwargs,
+        )
         def _func(_, text) -> str:
             pass
 
         return _func(self, sym)
-
-