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

symai/extended/packages/symdev.py

@@ -11,7 +11,7 @@ from ... import config_manager
 
 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 self.package_dir.exists():
             self.package_dir.mkdir(parents=True)
@@ -19,71 +19,76 @@ class PackageInitializer:
         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):
             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 IndexError:
-            logger.error('Invalid package name: {git_username}/{package_name}')
+            logger.error("Invalid package name: {git_username}/{package_name}")
             parser.print_help()
             exit(1)
 
         package_path = self.package_dir / username / package_name
         if package_path.exists():
-            logger.info('Package already exists')
+            logger.info("Package already exists")
             exit(1)
 
-        logger.info('Creating package...')
+        logger.info("Creating package...")
         package_path.mkdir(parents=True)
-        src_path = package_path / 'src'
+        src_path = package_path / "src"
         src_path.mkdir(parents=True)
 
-        with (package_path / '.gitignore').open('w'):
+        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'):
+        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:
+        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
 
 
@@ -102,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: ' + str(package_path))
+            logger.success("Package created successfully at: " + str(package_path))
 
 
 def run() -> None:
     PackageInitializer()
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     run()

symai/extended/packages/sympkg.py

@@ -13,7 +13,7 @@ from ...utils import UserMessage
 
 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 self.package_dir.exists():
             self.package_dir.mkdir(parents=True)
@@ -21,10 +21,10 @@ class PackageHandler:
         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)
@@ -32,31 +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])
-        command_aliases = {'l': 'list_packages'}
+        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(command) == 1 and not hasattr(self, command):
-            logger.error('Unrecognized command')
+            logger.error("Unrecognized command")
             parser.print_help()
             exit(1)
         else:
             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:])
@@ -65,10 +67,9 @@ 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)
 
@@ -77,34 +78,36 @@ class PackageHandler:
 
     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

@@ -14,8 +14,8 @@ from ...misc.loader import Loader
 
 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 self.package_dir.exists():
             self.package_dir.mkdir(parents=True)
@@ -24,20 +24,20 @@ class PackageRunner:
 
         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])
-            command_aliases = {'l': 'list_aliases'}
+            command_aliases = {"l": "list_aliases"}
             command = command_aliases.get(args.command, args.command)
             getattr(self, command)()
         except Exception:
@@ -55,46 +55,50 @@ class PackageRunner:
             return json.load(f)
 
     def save_aliases(self, aliases):
-        with self.aliases_file.open('w') as f:
+        with self.aliases_file.open("w") as f:
             json.dump(aliases, f)
 
     def console(self, header: str, output: object | None = None):
-        with ConsoleStyle('success'):
+        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(f"Alias run of `{args.alias}` not found. Please check your command {args}")
+            with ConsoleStyle("error"):
+                logger.error(
+                    f"Alias run of `{args.alias}` not found. Please check your command {args}"
+                )
             parser.print_help()
             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
             package_path = Path(package)
@@ -105,12 +109,14 @@ class PackageRunner:
                 # GitHub reference
                 expr = Import(package, **kwargs)
         except Exception as e:
-            with ConsoleStyle('error'):
-                logger.error(f"Error: {e!s} in package `{package}`.\nPlease check your command {args} or if package is available.")
+            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 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:
@@ -125,11 +131,16 @@ class PackageRunner:
 
     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()
@@ -142,15 +153,15 @@ class PackageRunner:
         # 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()
@@ -164,5 +175,5 @@ def run() -> None:
     PackageRunner()
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     run()

symai/extended/repo_cloner.py

@@ -17,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: 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)
 
@@ -34,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():
-            UserMessage(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:
-                    UserMessage(f'Repository {repo_name} updated.')
+                    UserMessage(f"Repository {repo_name} updated.")
                 else:
-                    UserMessage(f'Repository {repo_name} is up-to-date.')
+                    UserMessage(f"Repository {repo_name} is up-to-date.")
             except Exception as e:
-                UserMessage(f'An error occurred: {e}')
+                UserMessage(f"An error occurred: {e}")
                 raise e
         else:
-            UserMessage(f'Cloning repository {repo_name}...')
+            UserMessage(f"Cloning repository {repo_name}...")
             try:
                 Repo.clone_from(url, self.repo_dir / repo_name)
-                UserMessage(f'Repository {repo_name} cloned successfully.')
+                UserMessage(f"Repository {repo_name} cloned successfully.")
             except Exception as e:
-                UserMessage(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

@@ -16,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 f'$> {argument.args[0]!s} =>'
+        return f"$> {argument.args[0]!s} =>"
 
 
 class SEOQueryOptimizer(Expression):
@@ -29,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)
-
-