fix(solver): catch solver execption in main solver

.github/workflows/code-check.yml

@@ -0,0 +1,34 @@
+name: CI
+
+on:
+  push:
+  pull_request:
+  workflow_dispatch:
+  repository_dispatch:
+    types: [my_event]
+jobs:
+  format-check:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.10'
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install pre-commit pytest pytest-cov 
+          pip install -r requirements.txt
+          pip install -e .
+          pip install black==24.10.0
+      - name: Run pre-commit
+        run: pre-commit run --all-files
+
+      # - name: Run unit tests
+      #   run: pushd tests/unit && pytest && popd
+

.github/workflows/pr-title-check.yml

@@ -0,0 +1,28 @@
+name: "Lint PR"
+
+on:
+  pull_request_target:
+    types:
+      - opened
+      - edited
+      - synchronize
+
+jobs:
+  main:
+    name: Validate PR title
+    runs-on: ubuntu-latest
+    steps:
+      # https://www.conventionalcommits.org/en/v1.0.0/#summary
+      - uses: amannn/action-semantic-pull-request@v5
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          requireScope: true
+          subjectPattern: ^(?![A-Z]).+$
+          # If `subjectPattern` is configured, you can use this property to override
+          # the default error message that is shown when the pattern doesn't match.
+          # The variables `subject` and `title` can be used within the message.
+          subjectPatternError: |
+            The subject "{subject}" found in the pull request title "{title}"
+            didn't match the configured pattern. Please ensure that the subject
+            doesn't start with an uppercase character.

.gitignore

@@ -12,4 +12,6 @@
 *.pyc
 /dist
 .vscode/
+.idea/
+.venv/
 __pycache__/

.pre-commit-config.yaml

@@ -0,0 +1,17 @@
+repos:
+  - repo: https://github.com/psf/black
+    rev: 22.3.0
+    hooks:
+      - id: black
+        files: ^kag/.*\.py$
+        exclude: |
+          (?x)^(
+            kag/solver/logic/core_modules/rule_runner/rule_runner.py |
+            kag/solver/logic/core_modules/parser/logic_node_parser.py
+          )$
+
+  - repo: https://github.com/pycqa/flake8
+    rev: 4.0.1
+    hooks:
+      - id: flake8
+        files: ^kag/.*\.py$

KAG_VERSION

@@ -1 +1 @@
-0.5.2-beta1
+0.6

MANIFEST.in

@@ -1,2 +1,6 @@
 recursive-include kag *
 recursive-exclude kag/examples *
+global-exclude *.pyc
+global-exclude *.pyo
+global-exclude *.pyd
+global-exclude __pycache__

build.sh

@@ -0,0 +1,5 @@
+rm -rf build
+
+rm -rf dist
+
+python setup.py sdist bdist_wheel

kag/__init__.py

@@ -1,3 +1,4 @@
+# flake8: noqa
 # Apache License
 # Version 2.0, January 2004
 # http://www.apache.org/licenses/
@@ -202,8 +203,27 @@
 
 
 __package_name__ = "openspg-kag"
-__version__ = "0.5.2-beta1"
+__version__ = "0.6"
 
-from kag.common.env import init_env
+# Register Built-in Components
+from kag.common.conf import init_env
 
 init_env()
+
+import kag.interface
+import kag.interface.solver.execute
+import kag.interface.solver.plan
+import kag.solver.execute
+import kag.solver.plan
+import kag.solver.retriever
+import kag.solver.tools
+import kag.builder.component
+import kag.builder.default_chain
+import kag.builder.runner
+import kag.builder.prompt
+import kag.solver.prompt
+import kag.common.vectorize_model
+import kag.common.llm
+import kag.common.checkpointer
+import kag.solver
+import kag.bin.commands

kag/bin/base.py

@@ -0,0 +1,49 @@
+# -*- coding: utf-8 -*-
+# Copyright 2023 OpenSPG Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
+# in compliance with the License. You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software distributed under the License
+# is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+# or implied.
+
+import argparse
+import logging
+import typing
+from kag.common.registry import Registrable
+
+logger = logging.getLogger()
+
+
+def add_commands(
+    subparsers: argparse._SubParsersAction, command_names: typing.List[str] = None
+):
+    """add commands to subparsers"""
+    all_cmds = Command.list_available()
+    if command_names is None:
+        logger.warn("invalid command_names, will add all available commands.")
+        command_names = all_cmds
+    for cmd in command_names:
+        if cmd not in all_cmds:
+            raise ValueError(f"command {cmd} not in available commands {all_cmds}")
+        # Command Subclasses doesn't accept init args, so just pass subclass name is OK.
+        cls = Command.from_config(cmd)
+        cls.add_to_parser(subparsers)
+
+
+class Command(Registrable):
+    def get_handler(self):
+        """return handler of current command"""
+        return self.handler
+
+    def add_to_parser(self, subparsers: argparse._SubParsersAction):
+        """setup accept arguments"""
+        raise NotImplementedError("setup_parser not implemented yet.")
+
+    @staticmethod
+    def handler(args: argparse.Namespace):
+        """function to proces the request."""
+        raise NotImplementedError("handler not implemented yet.")

kag/common/retriever/__init__.py → kag/bin/commands/__init__.py

@@ -9,10 +9,7 @@
 # Unless required by applicable law or agreed to in writing, software distributed under the License
 # is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
 # or implied.
+from kag.bin.commands.info import ListRegisterInfo
 
-from kag.common.retriever.kag_retriever import DefaultRetriever
-from kag.common.retriever.retriever import Retriever
-__all__ = [
-    "DefaultRetriever",
-    "Retriever"
-]
+
+__all__ = ["ListRegisterInfo"]

kag/bin/commands/info.py

@@ -0,0 +1,115 @@
+# -*- coding: utf-8 -*-
+# Copyright 2023 OpenSPG Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
+# in compliance with the License. You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software distributed under the License
+# is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+# or implied.
+import argparse
+from tabulate import tabulate
+from kag.bin.base import Command
+from kag.common.registry import Registrable
+from kag.common.utils import reset, bold, red, green, blue
+
+
+@Command.register("register_info")
+class ListRegisterInfo(Command):
+    def add_to_parser(self, subparsers: argparse._SubParsersAction):
+        parser = subparsers.add_parser(
+            "interface", help="Show the interface info of the KAG components."
+        )
+        parser.add_argument("--cls", help="class name to query")
+        parser.add_argument(
+            "--list", help="list all component interfaces in KAG", action="store_true"
+        )
+        parser.set_defaults(func=self.get_handler())
+
+    @staticmethod
+    def get_cls(cls_name):
+        interface_classes = Registrable.list_all_registered(with_leaf_classes=False)
+        for item in interface_classes:
+            if item.__name__ == cls_name:
+                return item
+        raise ValueError(f"class {cls_name} is not a valid kag configurable class")
+
+    @staticmethod
+    def handle_list(args: argparse.Namespace):
+        interface_classes = Registrable.list_all_registered(with_leaf_classes=False)
+        data = []
+        for cls in interface_classes:
+            data.append([cls.__name__, cls.__module__])
+        headers = [f"{bold}{red}class{reset}", f"{bold}{red}module{reset}"]
+        msg = (
+            f"{bold}{red}Below are the interfaces provided by KAG."
+            f"For detailed information on each class, please use the command `kag interface --cls $class_name`{reset}"
+        )
+        print(msg)
+        print(tabulate(data, headers, tablefmt="grid"))
+
+    @staticmethod
+    def handle_cls(args: argparse.Namespace):
+        cls_obj = ListRegisterInfo.get_cls(args.cls)
+        if not issubclass(cls_obj, Registrable):
+            raise ValueError(f"class {args.cls} is not a valid kag configurable class")
+        availables = cls_obj.list_available_with_detail()
+        seg = " " * 20
+
+        deduped_availables = {}
+        for register_name, cls_info in availables.items():
+            cls = cls_info["class"]
+            if cls not in deduped_availables:
+                deduped_availables[cls] = [register_name]
+            else:
+                deduped_availables[cls].append(register_name)
+
+        print(f"{bold}{red}{seg}Documentation of {args.cls}{seg}{reset}")
+        import inspect
+
+        print(inspect.getdoc(cls_obj))
+        print(f"{bold}{red}{seg}Registered subclasses of {args.cls}{seg}{reset}")
+        visited = set()
+        for register_name, cls_info in availables.items():
+            cls = cls_info["class"]
+            if cls in visited:
+                continue
+            visited.add(cls)
+            print(f"{bold}{blue}[{cls}]{reset}")
+            register_names = " / ".join([f'"{x}"' for x in deduped_availables[cls]])
+            print(f"{bold}{green}Register Name:{reset} {register_names}\n")
+
+            # print(f"Class Name: {cls_info['class']}")
+            print(f"{bold}{green}Documentation:{reset}\n{cls_info['doc']}\n")
+            print(f"{bold}{green}Initializer:{reset}\n{cls_info['constructor']}\n")
+
+            required_arguments = []
+            for item in cls_info["params"]["required_params"]:
+                required_arguments.append(f"  {item}")
+            if len(required_arguments) == 0:
+                required_arguments = "  No Required Arguments found"
+            else:
+                required_arguments = "\n".join(required_arguments)
+            print(f"{bold}{green}Required Arguments:{reset}\n{required_arguments}\n")
+
+            optional_arguments = []
+            for item in cls_info["params"]["optional_params"]:
+                optional_arguments.append(f"  {item}")
+            if len(optional_arguments) == 0:
+                optional_arguments = "  No Optional Arguments found"
+            else:
+                optional_arguments = "\n".join(optional_arguments)
+            print(f"{bold}{green}Optional Arguments:{reset}\n{optional_arguments}\n")
+            print(f"{bold}{green}Sample Useage:{reset}\n  {cls_info['sample_useage']}")
+            # for k, v in cls_info.items():
+            #     print(f"{k}: {v}")
+            print("\n")
+
+    @staticmethod
+    def handler(args: argparse.Namespace):
+        if args.list:
+            ListRegisterInfo.handle_list(args)
+        else:
+            ListRegisterInfo.handle_cls(args)

kag/bin/kag_cmds.py

@@ -0,0 +1,35 @@
+# -*- coding: utf-8 -*-
+# Copyright 2023 OpenSPG Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
+# in compliance with the License. You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software distributed under the License
+# is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+# or implied.
+import argparse
+from kag.bin.base import add_commands
+
+
+def build_parser():
+    parser = argparse.ArgumentParser()
+    subparsers = parser.add_subparsers(
+        dest="subcommand_name",
+        title="subcommands",
+        help="subcommands supported by kag",
+    )
+    # add registered commands to parser
+    cmds = [
+        "register_info",
+    ]
+    add_commands(subparsers, cmds)
+    return parser
+
+
+def main():
+    """entry point of script"""
+    parser = build_parser()
+    args = parser.parse_args()
+    args.func(args)