symbolicai 1.5.0__py3-none-any.whl → 1.7.0__py3-none-any.whl

symai/backend/engines/crawler/engine_selenium.py

@@ -1,94 +0,0 @@
-from typing import Callable
-from bs4 import BeautifulSoup
-
-from ...base import Engine
-from ...driver.webclient import connect_browsers, dump_page_source, page_loaded
-from ....symbol import Result
-
-
-class SeleniumResult(Result):
-    def __init__(self, value, **kwargs) -> None:
-        super().__init__(value, **kwargs)
-        if value is not None:
-            self.raw    = value
-            self._value = self.extract()
-
-    def extract(self):
-        tmp = self.value if isinstance(self.value, list) else [self.value]
-        res = []
-        for r in tmp:
-            if r is None:
-                continue
-            soup = BeautifulSoup(r, 'html.parser')
-            text = soup.getText()
-            res.append(text)
-        res = None if len(res) == 0 else '\n'.join(res)
-        return res
-
-
-class SeleniumEngine(Engine):
-    def __init__(self, debug: bool = False):
-        super().__init__()
-        self.debug = debug
-        self.driver_handler = None
-        self.name = self.__class__.__name__
-
-    def _init_crawler_engine(self):
-        self.driver_handler = connect_browsers(debug=False, proxy=None)
-
-    def get_page_source(self, url: str, pattern: str, script: Callable = None) -> str:
-        # deprecated
-        driver = self.driver_handler()
-        try:
-            driver.get(url)
-            with page_loaded(driver, pattern, debug=self.debug):
-                if script: driver.execute_script(script)
-            return driver.page_source
-        except Exception as ex:
-            if self.debug: dump_page_source(driver)
-            if self.debug: print(ex)
-            return f"Sorry, I cannot find the page you are looking for: {ex}"
-
-    def id(self) -> str:
-        return 'crawler'
-
-    def forward(self, argument):
-        urls, patterns  = argument.prop.prepared_input
-        urls     = urls if isinstance(urls, list) else [urls]
-
-        patterns = patterns if isinstance(patterns, list) else [patterns]
-        assert len(urls) == len(patterns)
-        rsp = []
-
-        self._init_crawler_engine()
-
-        for url, p in zip(urls, patterns):
-            page = self.get_page_source(url=url, pattern=p)
-            rsp.append(page)
-
-        metadata = {}
-        rsp = SeleniumResult(rsp)
-        return [rsp], metadata
-
-    def prepare(self, argument):
-        assert not argument.prop.processed_input, "CrawlerEngine does not support processed_input."
-        assert argument.prop.urls, "CrawlerEngine requires urls."
-
-        argument.prop.urls      = [str(argument.prop.url)]
-        argument.prop.patterns  = [str(argument.prop.pattern)]
-
-        # be tolerant to kwarg or arg and assign values of urls and patterns
-        # assign urls
-        if len(argument.args) >= 1:
-            argument.prop.urls = argument.args[0]
-        elif len(argument.kwargs) >= 1:
-            keys = list(argument.kwargs.keys())
-            argument.prop.urls = argument.kwargs[keys[0]]
-        # assign patterns
-        if len(argument.args) >= 2:
-            argument.prop.patterns = argument.args[1]
-        elif len(argument.kwargs) >= 2:
-            keys = list(argument.kwargs.keys())
-            argument.prop.patterns = argument.kwargs[keys[1]]
-
-        argument.prop.prepared_input = (argument.prop.urls, argument.prop.patterns)

symai/backend/engines/drawing/engine_dall_e.py

@@ -1,131 +0,0 @@
-import logging
-import openai
-import requests
-import tempfile
-
-from typing import Optional
-
-from ...base import Engine
-from ...settings import SYMAI_CONFIG
-from ....symbol import Result
-
-
-logging.getLogger("openai").setLevel(logging.ERROR)
-logging.getLogger("requests").setLevel(logging.ERROR)
-logging.getLogger("urllib").setLevel(logging.ERROR)
-logging.getLogger("httpx").setLevel(logging.ERROR)
-logging.getLogger("httpcore").setLevel(logging.ERROR)
-
-
-class DalleResult(Result):
-    def __init__(self, value, **kwargs) -> None:
-        super().__init__(value, **kwargs)
-        # unpack the result
-        if hasattr(value, 'data') and len(value.data) > 0:
-            self._value = value.data[0].url
-
-    # use tempfile to download the image
-    def download_images(self):
-        if not hasattr(self.value, 'data') or len(self.value.data) <= 0:
-            return None
-        files = []
-        # download the images
-        for url in enumerate(self.value.data):
-            path = tempfile.NamedTemporaryFile(suffix='.png').name
-            r = requests.get(url, allow_redirects=True)
-            with open(path, 'wb') as f:
-                f.write(r.content)
-            files.append(path)
-        return files
-
-
-class DrawingEngine(Engine):
-    def __init__(self, size: int = 1024, api_key: Optional[str] = None, model: Optional[str] = None):
-        super().__init__()
-        self.config = SYMAI_CONFIG
-        openai.api_key = self.config['DRAWING_ENGINE_API_KEY'] if api_key is None else api_key
-        self.model = self.config['DRAWING_ENGINE_MODEL'] if model is None else model
-        logger = logging.getLogger('openai')
-        logger.setLevel(logging.WARNING)
-        self.size = size # defaults to 1024 instead of 512 because dall-e-3 requires 1024
-
-    def id(self) -> str:
-        if  self.config['DRAWING_ENGINE_API_KEY'] and self.config['DRAWING_ENGINE_MODEL'].startswith("dall-e"):
-            return 'drawing'
-        return super().id() # default to unregistered
-
-    def command(self, *args, **kwargs):
-        super().command(*args, **kwargs)
-        if 'DRAWING_ENGINE_API_KEY' in kwargs:
-            openai.api_key = kwargs['DRAWING_ENGINE_API_KEY']
-        if 'DRAWING_ENGINE_MODEL' in kwargs:
-            self.model = kwargs['DRAWING_ENGINE_MODEL']
-
-    def forward(self, argument):
-        prompt          = argument.prop.prepared_input
-        kwargs          = argument.kwargs
-        model           = kwargs.get('model', self.model)
-        size            = f"{kwargs['image_size']}x{kwargs['image_size']}" if 'image_size' in kwargs else f"{self.size}x{self.size}"
-        n               = kwargs.get('n', 1)
-        quality         = kwargs.get('quality', 'standard')
-        response_format = kwargs.get('response_format', 'url')
-        style           = kwargs.get('style', 'vivid')
-        except_remedy = kwargs['except_remedy'] if 'except_remedy' in kwargs else None
-
-        callback = None
-        try:
-            if kwargs['operation'] == 'create':
-
-                callback = openai.images.generate
-                res = openai.images.generate(
-                    model=model,
-                    prompt=prompt,
-                    n=n,
-                    size=size,
-                    quality=quality,
-                    response_format=response_format,
-                    style=style,
-                )
-            elif kwargs['operation'] == 'variation':
-                assert 'image_path' in kwargs
-                image_path = kwargs['image_path']
-
-                callback = openai.images.create_variation
-                res = openai.images.create_variation(
-                    model=model,
-                    image=open(image_path, "rb"),
-                    n=n,
-                    size=size,
-                    response_format=response_format,
-                )
-            elif kwargs['operation'] == 'edit':
-                assert 'mask_path' in kwargs
-                assert 'image_path' in kwargs
-                mask_path = kwargs['mask_path']
-                image_path = kwargs['image_path']
-
-                callback = openai.images.edit
-                res = openai.images.edit(
-                    model=model,
-                    image=open(image_path, "rb"),
-                    mask=open(mask_path, "rb"),
-                    prompt=prompt,
-                    n=n,
-                    size=size,
-                    response_format=response_format,
-                )
-            else:
-                raise Exception(f"Unknown operation: {kwargs['operation']}")
-
-        except Exception as e:
-            if except_remedy is None:
-                raise e
-            res = except_remedy(self, e, callback, argument)
-
-        metadata = {}
-
-        rsp = DalleResult(res)
-        return [rsp], metadata
-
-    def prepare(self, argument):
-        argument.prop.prepared_input = str(argument.prop.processed_input)

symai/backend/engines/embedding/engine_plugin_embeddings.py

@@ -1,12 +0,0 @@
-from ...base import Engine
-from ...settings import SYMAI_CONFIG
-
-
-class PluginEmbeddingEngine(Engine):
-    def id(self) -> str:
-        if not SYMAI_CONFIG['EMBEDDING_ENGINE_API_KEY'] and not SYMAI_CONFIG['EMBEDDING_ENGINE_MODEL'].startswith("llama"):
-            from ....functional import EngineRepository
-
-            # Register the embedding engine from the plugin
-            EngineRepository.register_from_plugin('embedding', plugin='ExtensityAI/embeddings', kwargs={'model': 'all-mpnet-base-v2'}, allow_engine_override=True)
-        return super().id() # do not register this engine as we want the plugin to be used

symai/backend/engines/experiments/engine_bard_wrapper.py

@@ -1,131 +0,0 @@
-import logging
-from typing import List
-
-import requests
-import tiktoken
-from bardapi import Bard
-
-from ...base import Engine
-from ...mixin.openai import OpenAIMixin
-from ...settings import SYMAI_CONFIG
-
-
-class BardEngine(Engine, OpenAIMixin):
-    def __init__(self, timeout: int = 30):
-        super().__init__()
-        self.timeout    = timeout
-        config          = SYMAI_CONFIG
-        self.api_key    = config['NEUROSYMBOLIC_ENGINE_API_KEY']
-        self.model      = config['NEUROSYMBOLIC_ENGINE_MODEL']
-        logger          = logging.getLogger('openai')
-        self.tokenizer  = tiktoken.encoding_for_model(self.model)
-        self.max_tokens = self.api_max_tokens()
-        self.bard       = None
-        logger.setLevel(logging.WARNING)
-
-    def init_session(self):
-        self.session    = requests.Session()
-        self.session.headers = {
-                    "Host": "bard.google.com",
-                    "X-Same-Domain": "1",
-                    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.114 Safari/537.36",
-                    "Content-Type": "application/x-www-form-urlencoded;charset=UTF-8",
-                    "Origin": "https://bard.google.com",
-                    "Referer": "https://bard.google.com/",
-                }
-        self.session.cookies.set("__Secure-1PSID", self.api_key)
-        self.bard = Bard(token=self.api_key,
-                         session=self.session,
-                         timeout=self.timeout)
-
-    def id(self) -> str:
-        if   self.config['NEUROSYMBOLIC_ENGINE_MODEL'] and \
-            (self.config['NEUROSYMBOLIC_ENGINE_MODEL'].startswith('bard')):
-            return 'neurosymbolic'
-        return super().id() # default to unregistered
-
-    def command(self, *args, **kwargs):
-        super().command(*args, **kwargs)
-        if 'NEUROSYMBOLIC_ENGINE_API_KEY' in kwargs:
-            self.api_key = kwargs['NEUROSYMBOLIC_ENGINE_API_KEY']
-        if 'NEUROSYMBOLIC_ENGINE_MODEL' in kwargs:
-            self.model = kwargs['NEUROSYMBOLIC_ENGINE_MODEL']
-
-    def compute_remaining_tokens(self, prompts: list) -> int:
-        # iterate over prompts and compute number of tokens
-        prompt = prompts[0]
-        val = len(self.tokenizer.encode(prompt))
-        return int((self.max_tokens - val) * 0.98)
-
-    def forward(self, argument):
-        if self.bard is None:
-            self.init_session()
-
-        kwargs              = argument.kwargs
-        prompts_            = argument.prop.prepared_input
-        prompts_            = prompts_ if isinstance(prompts_, list) else [prompts_]
-        except_remedy       = kwargs['except_remedy'] if 'except_remedy' in kwargs else None
-
-        try:
-            res = self.bard.get_answer(prompts_[0])
-        except Exception as e:
-            if except_remedy is None:
-                raise e
-            callback = self.connection.root.predict
-            res = except_remedy(self, e, callback, argument)
-
-        metadata = {}
-
-        rsp    = [res['content']]
-        output = rsp if isinstance(prompts_, list) else rsp[0]
-        return output, metadata
-
-    def prepare(self, argument):
-        if argument.prop.raw_input:
-            if not argument.prop.processed_input:
-                raise ValueError('Need to provide a prompt instruction to the engine if raw_input is enabled.')
-            argument.prop.prepared_input = argument.prop.processed_input
-            return
-
-        user:   str = ""
-        system: str = ""
-        system      = f'{system}\n' if system and len(system) > 0 else ''
-
-        ref = argument.prop.instance
-        static_ctxt, dyn_ctxt = ref.global_context
-        if len(static_ctxt) > 0:
-            system += f"[STATIC CONTEXT]\n{static_ctxt}\n\n"
-
-        if len(dyn_ctxt) > 0:
-            system += f"[DYNAMIC CONTEXT]\n{dyn_ctxt}\n\n"
-
-        payload = argument.prop.payload
-        if payload is not None:
-            system += f"[ADDITIONAL CONTEXT]\n{payload}\n\n"
-
-        examples: List[str] = argument.prop.examples
-        if examples and len(examples) > 0:
-            system += f"[EXAMPLES]\n{str(examples)}\n\n"
-
-        if argument.prop.prompt is not None and len(argument.prop.prompt) > 0:
-            val = str(argument.prop.prompt)
-            system += f"[INSTRUCTION]\n{val}"
-
-        suffix: str = str(argument.prop.processed_input)
-        if '=>' in suffix:
-            user += f"[LAST TASK]\n"
-
-        if '[SYSTEM_INSTRUCTION::]: <<<' in suffix and argument.prop.parse_system_instructions:
-            parts = suffix.split('\n>>>\n')
-            # first parts are the system instructions
-            for p in parts[:-1]:
-                system += f"{p}\n"
-            # last part is the user input
-            suffix = parts[-1]
-        user += f"{suffix}"
-
-        if argument.prop.template_suffix is not None:
-            user += f"\n[[PLACEHOLDER]]\n{argument.prop.template_suffix}\n\n"
-            user += f"Only generate content for the placeholder `[[PLACEHOLDER]]` following the instructions and context information. Do NOT write `[[PLACEHOLDER]]` or anything else in your output.\n\n"
-
-        argument.prop.prepared_input = [f'---------SYSTEM BEHAVIOR--------\n{system}\n\n---------USER REQUEST--------\n{user}']

symai/backend/engines/experiments/engine_gptfinetuner.py

@@ -1,32 +0,0 @@
-import os
-from typing import List
-
-import openai
-
-from ....utils import Args
-from ...base import Engine
-from ...settings import SYMAI_CONFIG
-
-
-class GPTFineTuner(Engine):
-    def __init__(self):
-        super().__init__()
-        config          = SYMAI_CONFIG
-        openai.api_key  = config['NEUROSYMBOLIC_ENGINE_API_KEY']
-        self.base_model = "babbage"
-
-    def forward(self, argument):
-        kwargs = argument.kwargs
-        assert '__cmd__' in kwargs, "Missing __cmd__ argument"
-        rsp = None
-
-        raise NotImplementedError("GPTFineTuner is not implemented yet")
-
-        del kwargs['__cmd__']
-
-        metadata = {}
-
-        return [rsp], metadata
-
-    def prepare(self, argument):
-        assert not argument.prop.processed_input, "GPTFineTuner does not support processed_input."

symai/backend/engines/experiments/engine_llamacpp_completion.py

@@ -1,142 +0,0 @@
-import logging
-from typing import List
-
-from ...base import Engine
-from ...settings import SYMAI_CONFIG
-
-import requests
-import json
-
-
-class LLaMACppCompletionClient():
-    def __init__(self, base_url="http://localhost:8000"):
-        self.base_url = base_url
-
-    def create_completion(self, completion_request):
-        # Preparing header information
-        headers = {
-            'Content-Type': 'application/json',
-            'Accept': 'application/json'
-        }
-
-        # Performing POST request
-        response = requests.post(f"{self.base_url}/v1/engines/copilot-codex/completions",
-                                 data=json.dumps(completion_request),
-                                 headers=headers)
-
-        print(response)
-
-        # Parsing response
-        if response.status_code == 200:
-            return json.loads(response.text)
-        else:
-            raise Exception(f"Request failed with status code {response.status_code}")
-
-
-class LLaMACppCompletionEngine(Engine):
-    def __init__(self):
-        super().__init__()
-        config          = SYMAI_CONFIG
-        self.model      = config['NEUROSYMBOLIC_ENGINE_MODEL']
-        logger          = logging.getLogger('LLaMA')
-        logger.setLevel(logging.WARNING)
-
-        self.client = LLaMACppCompletionClient() # Initialize LLaMACpp client here
-
-    def command(self, *args, **kwargs):
-        super().command(*args, **kwargs)
-        if 'NEUROSYMBOLIC_ENGINE_MODEL' in kwargs:
-            self.model = kwargs['NEUROSYMBOLIC_ENGINE_MODEL']
-
-    def forward(self, argument):
-        prompts_            = argument.prop.prepared_input
-        prompts_            = prompts_ if isinstance(prompts_, list) else [prompts_]
-        kwargs              = argument.kwargs
-        max_tokens          = kwargs['max_tokens'] if 'max_tokens' in kwargs else 4096
-        temperature         = kwargs['temperature'] if 'temperature' in kwargs else 0.7
-        top_p               = kwargs['top_p'] if 'top_p' in kwargs else 1
-        except_remedy       = kwargs['except_remedy'] if 'except_remedy' in kwargs else None
-
-        completion_request = {
-            "prompt": prompts_,
-            "stop": ["\n\n", "-------"]
-            #"max_tokens": max_tokens,
-            #"temperature": temperature,
-            #"top_p": top_p,
-            #"mirostat_mode": 0,
-            #"mirostat_tau": 0.2,
-            #"mirostat_eta": 0.5,
-            #"echo": False
-        }
-
-        try:
-            print(completion_request)
-            res = self.client.create_completion(completion_request)
-        except Exception as e:
-            if except_remedy is None:
-                raise e
-            callback = self.connection.root.predict
-            res = except_remedy(self, e, callback, argument)
-
-
-        metadata = {}
-
-        rsp    = [r['text'] for r in res['choices']]
-        output = rsp if isinstance(prompts_, list) else rsp[0]
-        return output, metadata
-
-    def prepare(self, argument):
-        if argument.prop.raw_input:
-            if not argument.prop.processed_input:
-                raise ValueError('Need to provide a prompt instruction to the engine if raw_input is enabled.')
-            argument.prop.prepared_input = argument.prop.processed_input
-            return
-
-        user:   str = ""
-        system: str = ""
-        system      = f'{system}\n' if system and len(system) > 0 else ''
-
-        ref = argument.prop.instance
-        static_ctxt, dyn_ctxt = ref.global_context
-        if len(static_ctxt) > 0:
-            system += f"[STATIC CONTEXT]\n{static_ctxt}\n\n"
-
-        if len(dyn_ctxt) > 0:
-            system += f"[DYNAMIC CONTEXT]\n{dyn_ctxt}\n\n"
-
-        payload = argument.prop.payload
-        if payload is not None:
-            system += f"[ADDITIONAL CONTEXT]\n{str(payload)}\n\n"
-
-        examples: List[str] = argument.prop.examples
-        if examples and len(examples) > 0:
-            system += f"[EXAMPLES]\n{str(examples)}\n\n"
-
-        if argument.prop.prompt is not None and len(argument.prop.prompt) > 0:
-            val = str(argument.prop.prompt)
-            system += f"[INSTRUCTION]\n{val}"
-
-        suffix: str = str(argument.prop.processed_input)
-        if '=>' in suffix:
-            user += f"[LAST TASK]\n"
-
-        if '[SYSTEM_INSTRUCTION::]: <<<' in suffix and argument.prop.parse_system_instructions:
-            parts = suffix.split('\n>>>\n')
-            # first parts are the system instructions
-            for p in parts[:-1]:
-                system += f"{p}\n"
-            # last part is the user input
-            suffix = parts[-1]
-        user += f"{suffix}"
-
-        if argument.prop.template_suffix is not None:
-            user += f"\n[[PLACEHOLDER]]\n{str(argument.prop.template_suffix)}\n\n"
-            user += f"Only generate content for the placeholder `[[PLACEHOLDER]]` following the instructions and context information. Do NOT write `[[PLACEHOLDER]]` or anything else in your output.\n\n"
-
-        argument.prop.prepared_input = [f'---------SYSTEM BEHAVIOR--------\n{system}\n\n---------USER REQUEST--------\n{user}']
-
-
-if __name__ == '__main__':
-    engine = LLaMACppCompletionEngine()
-    res = engine.forward(["\n\n### Instructions:\nWhat is the capital of Romania?\n\n### Response:\n"])
-    print(res)