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

symai/backend/engines/neurosymbolic/engine_openai_gptX_completion.py

@@ -1,277 +0,0 @@
-import logging
-from copy import deepcopy
-from typing import List, Optional
-
-import openai
-import tiktoken
-
-from ....misc.console import ConsoleStyle
-from ....utils import CustomUserWarning
-from ...base import Engine
-from ...mixin.openai import OpenAIMixin
-from ...settings import SYMAI_CONFIG
-
-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 InvalidRequestErrorRemedyCompletionStrategy:
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-
-    def __call__(self, engine, error, callback, argument):
-        openai_kwargs = {}
-        kwargs   = argument.kwargs
-        prompts_ = argument.prop.prepared_input
-        # send prompt to GPT-X Completion-based
-        stop  = kwargs['stop'] if 'stop' in kwargs else None
-        model = kwargs['model'] if 'model' in kwargs else None
-
-        msg = str(error)
-        handle = None
-        try:
-            if "This model's maximum context length is" in msg:
-                handle = 'type1'
-                max_ = engine.max_context_tokens
-                usr = msg.split('tokens. ')[1].split(' ')[-1]
-                overflow_tokens = int(usr) - int(max_)
-            elif "is less than the minimum" in msg:
-                handle = 'type2'
-                overflow_tokens = engine.max_response_tokens
-            else:
-                raise Exception(msg) from error
-        except Exception as e:
-            raise e from error
-
-        # unify the format to use same remedy strategy for both chat and completion
-        values = prompts_[0].replace('---------SYSTEM BEHAVIOR--------\n', '').split('\n\n---------USER REQUEST--------\n')
-        prompts_ = [{'role': 'system', 'content': values[0]}, {'role': 'user', 'content': values[1]}]
-
-        prompts = [p for p in prompts_ if p['role'] == 'user']
-        system_prompt = [p for p in prompts_ if p['role'] == 'system']
-
-        def compute_required_tokens(prompts: dict) -> int:
-            # iterate over prompts and compute number of tokens
-            prompts_ = [role['content'] for role in prompts]
-            prompt = ''.join(prompts_)
-            val = len(engine.tokenizer.encode(prompt, disallowed_special=()))
-            return val
-
-        def compute_remaining_tokens(prompts: list) -> int:
-            val = compute_required_tokens(prompts)
-            return int((engine.max_context_tokens - val) * 0.99)
-
-        if handle == 'type1':
-            truncated_content_ = [p['content'][overflow_tokens:] for p in prompts]
-            truncated_prompts_ = [{'role': p['role'], 'content': c} for p, c in zip(prompts, truncated_content_)]
-            CustomUserWarning(f"WARNING: Overflow tokens detected. Reducing prompt size by {overflow_tokens} characters.")
-        elif handle == 'type2':
-            user_prompts = [p['content'] for p in prompts]
-            new_prompt   = [*system_prompt]
-            new_prompt.extend([{'role': p['role'], 'content': c} for p, c in zip(prompts, user_prompts)])
-            overflow_tokens = compute_required_tokens(new_prompt) - int(engine.max_context_tokens * 0.70)
-            if overflow_tokens > 0:
-                CustomUserWarning(f'WARNING: Overflow tokens detected. Reducing prompt size to 70% of model context size ({engine.max_context_tokens}).')
-                for i, content in enumerate(user_prompts):
-                    token_ids = engine.tokenizer.encode(content)
-                    if overflow_tokens >= len(token_ids):
-                        overflow_tokens -= len(token_ids)
-                        user_prompts[i] = ''
-                    else:
-                        new_content = engine.tokenizer.decode(token_ids[:-overflow_tokens])
-                        user_prompts[i] = new_content
-                        overflow_tokens = 0
-                        break
-
-            new_prompt = [*system_prompt]
-            new_prompt.extend([{'role': p['role'], 'content': c} for p, c in zip(prompts, user_prompts)])
-            assert compute_required_tokens(new_prompt) <= engine.max_context_tokens, \
-                f"Token overflow: prompts exceed {engine.max_context_tokens} tokens after truncation"
-
-            truncated_prompts_ = [{'role': p['role'], 'content': c.strip()} for p, c in zip(prompts, user_prompts) if c.strip()]
-        else:
-            raise Exception('Invalid handle case for remedy strategy.') from error
-
-        truncated_prompts_ = [*system_prompt, *truncated_prompts_]
-
-        # convert map to list of strings
-        max_tokens          = kwargs['max_tokens'] if 'max_tokens' in kwargs else compute_remaining_tokens(truncated_prompts_)
-        temperature         = kwargs['temperature'] if 'temperature' in kwargs else 1
-        frequency_penalty   = kwargs['frequency_penalty'] if 'frequency_penalty' in kwargs else 0
-        presence_penalty    = kwargs['presence_penalty'] if 'presence_penalty' in kwargs else 0
-        top_p               = kwargs['top_p'] if 'top_p' in kwargs else 1
-        suffix              = kwargs['template_suffix'] if 'template_suffix' in kwargs else None
-
-        system = truncated_prompts_[0]['content']
-        user = truncated_prompts_[1]['content']
-        truncated_prompts_ = [f'---------SYSTEM BEHAVIOR--------\n{system}\n\n---------USER REQUEST--------\n{user}']
-
-        if stop is not None:
-            openai_kwargs['stop'] = stop
-
-        return callback(model=model,
-                        prompt=truncated_prompts_,
-                        suffix=suffix,
-                        max_tokens=max_tokens,
-                        temperature=temperature,
-                        frequency_penalty=frequency_penalty,
-                        presence_penalty=presence_penalty,
-                        top_p=top_p,
-                        n=1,
-                        **openai_kwargs)
-
-
-
-class GPTXCompletionEngine(Engine, OpenAIMixin):
-    def __init__(self, api_key: Optional[str] = None, model: Optional[str] = None):
-        super().__init__()
-        logger = logging.getLogger('openai')
-        logger.setLevel(logging.WARNING)
-        self.config = deepcopy(SYMAI_CONFIG)
-        if self.id() != 'neurosymbolic':
-            return # do not initialize if not neurosymbolic; avoids conflict with llama.cpp check in EngineRepository.register_from_package
-        openai.api_key           = self.config['NEUROSYMBOLIC_ENGINE_API_KEY'] if api_key is None else api_key
-        self.model               = self.config['NEUROSYMBOLIC_ENGINE_MODEL'] if model is None else model
-        self.tokenizer           = tiktoken.encoding_for_model(self.model)
-        self.max_context_tokens  = self.api_max_context_tokens()
-        self.max_response_tokens = self.api_max_response_tokens()
-        self.except_remedy       = None
-
-    def id(self) -> str:
-        if   self.config['NEUROSYMBOLIC_ENGINE_MODEL'] and \
-            (self.config['NEUROSYMBOLIC_ENGINE_MODEL'].startswith('text-') or \
-             self.config['NEUROSYMBOLIC_ENGINE_MODEL'].startswith('davinci') or \
-             self.config['NEUROSYMBOLIC_ENGINE_MODEL'].startswith('curie') or \
-             self.config['NEUROSYMBOLIC_ENGINE_MODEL'].startswith('babbage') or \
-             self.config['NEUROSYMBOLIC_ENGINE_MODEL'].startswith('ada')):
-            return 'neurosymbolic'
-        return super().id() # default to unregistered
-
-    def command(self, *args, **kwargs):
-        super().command(*args, **kwargs)
-        if 'NEUROSYMBOLIC_ENGINE_API_KEY' in kwargs:
-            openai.api_key = kwargs['NEUROSYMBOLIC_ENGINE_API_KEY']
-        if 'NEUROSYMBOLIC_ENGINE_MODEL' in kwargs:
-            self.model     = kwargs['NEUROSYMBOLIC_ENGINE_MODEL']
-        if 'except_remedy' in kwargs:
-            self.except_remedy = kwargs['except_remedy']
-
-    def compute_required_tokens(self, prompts: list) -> int:
-       # iterate over prompts and compute number of tokens
-        prompt = prompts[0] # index 0 is correct since we only have one prompt in legacy mode
-        val = len(self.tokenizer.encode(prompt, disallowed_special=()))
-        return val
-
-    def compute_remaining_tokens(self, prompts: list) -> int:
-        val = self.compute_required_tokens(prompts)
-        return min(self.max_context_tokens - val, self.max_response_tokens)
-
-    def forward(self, argument):
-        kwargs              = argument.kwargs
-        prompts_            = argument.prop.prepared_input
-
-        # send prompt to GPT-3
-        max_tokens          = kwargs['max_tokens'] if 'max_tokens' in kwargs else self.compute_remaining_tokens(prompts_)
-        stop                = kwargs['stop'] if 'stop' in kwargs else None
-        model               = kwargs['model'] if 'model' in kwargs else self.model
-        temperature         = kwargs['temperature'] if 'temperature' in kwargs else 0.7
-        frequency_penalty   = kwargs['frequency_penalty'] if 'frequency_penalty' in kwargs else 0
-        presence_penalty    = kwargs['presence_penalty'] if 'presence_penalty' in kwargs else 0
-        top_p               = kwargs['top_p'] if 'top_p' in kwargs else 1
-        except_remedy       = kwargs['except_remedy'] if 'except_remedy' in kwargs else self.except_remedy
-
-        try:
-            res = openai.completions.create(model=model,
-                                            prompt=prompts_,
-                                            max_tokens=max_tokens,
-                                            temperature=temperature,
-                                            frequency_penalty=frequency_penalty,
-                                            presence_penalty=presence_penalty,
-                                            top_p=top_p,
-                                            stop=stop,
-                                            n=1)
-        except Exception as e:
-            callback = openai.completions.create
-            kwargs['model'] = kwargs['model'] if 'model' in kwargs else self.model
-            if except_remedy is not None:
-                res = except_remedy(self, e, callback, argument)
-            else:
-                try:
-                    # implicit remedy strategy
-                    except_remedy = InvalidRequestErrorRemedyCompletionStrategy()
-                    res = except_remedy(self, e, callback, argument)
-                except Exception as e2:
-                    ex = Exception(f'Failed to handle exception: {e}. Also failed implicit remedy strategy after retry: {e2}')
-                    raise ex from e
-
-        metadata = {}
-        # TODO: remove system behavior and user request from output. consider post-processing
-        def replace_verbose(rsp):
-            rsp = rsp.replace('---------SYSTEM BEHAVIOR--------\n', '')
-            rsp = rsp.replace('\n\n---------USER REQUEST--------\n', '')
-            return rsp
-
-        rsp    = [replace_verbose(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.')
-            value = argument.prop.processed_input
-            if type(value) is not list:
-                value = [str(value)]
-            argument.prop.prepared_input = value
-            return
-
-        _non_verbose_output = """[META INSTRUCTIONS START]\nYou do not output anything else, like verbose preambles or post explanation, such as "Sure, let me...", "Hope that was helpful...", "Yes, I can help you with that...", etc. Consider well formatted output, e.g. for sentences use punctuation, spaces etc. or for code use indentation, etc. Never add meta instructions information to your output!\n"""
-
-        user:   str = ""
-        system: str = ""
-
-        if argument.prop.suppress_verbose_output:
-            system  += _non_verbose_output
-        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/collect/__init__.py

@@ -1,8 +0,0 @@
-from .dynamic import create_object_from_string
-from .pipeline import CollectionRepository, rec_serialize
-
-__all__ = [
-    "CollectionRepository",
-    "create_object_from_string",
-    "rec_serialize",
-]

symai/collect/dynamic.py

@@ -1,117 +0,0 @@
-import ast
-import re
-
-
-class DynamicClass:
-    def __init__(self, **kwargs):
-        self.__dict__.update(kwargs)
-
-    def __repr__(self):
-        return str(self.__dict__)
-
-    @staticmethod
-    def from_string(s):
-        return create_object_from_string(s)
-
-
-def create_dynamic_class(class_name, **kwargs):
-    return type(class_name, (DynamicClass,), kwargs)()
-
-
-def parse_custom_class_instances(s):
-    pattern = r"(\w+)\((.*?)\)"
-    if not isinstance(s, str):
-        return s
-    matches = re.finditer(pattern, s)
-
-    for match in matches:
-        class_name = match.group(1)
-        class_args = match.group(2)
-        try:
-            parsed_args = ast.literal_eval(f"{{{class_args}}}")
-        except (ValueError, SyntaxError):
-            parsed_args = create_object_from_string(class_args)
-        class_instance = create_dynamic_class(class_name, **parsed_args)
-        s = s.replace(match.group(0), repr(class_instance))
-
-    return s
-
-
-def _strip_quotes(text):
-    if not isinstance(text, str):
-        return text
-    if text.startswith("'") and text.endswith("'"):
-        return text.strip("'")
-    if text.startswith('"') and text.endswith('"'):
-        return text.strip('"')
-    return text
-
-
-def _extract_content(str_class):
-    return str_class.split("ChatCompletionMessage(content=")[-1].split(", role=")[0][1:-1]
-
-
-def _parse_value(value):
-    try:
-        value = parse_custom_class_instances(value)
-        if not isinstance(value, str):
-            return value
-        if value.startswith("["):
-            inner_values = value[1:-1]
-            values = inner_values.split(",")
-            return [_parse_value(v.strip()) for v in values]
-        if value.startswith("{"):
-            inner_values = value[1:-1]
-            values = inner_values.split(",")
-            return {
-                k.strip(): _parse_value(v.strip()) for k, v in [v.split(":", 1) for v in values]
-            }
-        result = ast.literal_eval(value)
-        if isinstance(result, dict):
-            return {k: _parse_value(v) for k, v in result.items()}
-        if isinstance(result, (list, tuple, set)):
-            return [_parse_value(v) for v in result]
-        return result
-    except (ValueError, SyntaxError):
-        return value
-
-
-def _process_list_value(raw_value):
-    parsed_value = _parse_value(raw_value)
-    dir(parsed_value)
-    if hasattr(parsed_value, "__dict__"):
-        for key in parsed_value.__dict__:
-            value = getattr(parsed_value, key)
-            if isinstance(value, str):
-                parsed_value[key.strip("'")] = value.strip("'")
-    return parsed_value
-
-
-def _process_dict_value(raw_value):
-    parsed_value = _parse_value(raw_value)
-    new_value = {}
-    for key, value in parsed_value.items():
-        stripped_value = value.strip("'") if isinstance(value, str) else value
-        new_value[key.strip("'")] = stripped_value
-    return new_value
-
-
-def _collect_attributes(str_class):
-    attr_pattern = r"(\w+)=(\[.*?\]|\{.*?\}|'.*?'|None|\w+)"
-    attributes = re.findall(attr_pattern, str_class)
-    updated_attributes = [("content", _extract_content(str_class))]
-    for key, raw_value in attributes:
-        attr_key = _strip_quotes(key)
-        attr_value = _strip_quotes(raw_value)
-        if attr_value.startswith("[") and attr_value.endswith("]"):
-            attr_value = _process_list_value(attr_value)
-        elif attr_value.startswith("{") and attr_value.endswith("}"):
-            attr_value = _process_dict_value(attr_value)
-        updated_attributes.append((attr_key, attr_value))
-    return updated_attributes
-
-
-# TODO: fix to properly parse nested lists and dicts
-def create_object_from_string(str_class):
-    updated_attributes = _collect_attributes(str_class)
-    return DynamicClass(**{key: _parse_value(value) for key, value in updated_attributes})

symai/collect/pipeline.py

@@ -1,156 +0,0 @@
-from __future__ import annotations
-
-import json
-import logging
-from datetime import datetime
-from typing import TYPE_CHECKING, Any
-
-from bson.objectid import ObjectId
-from pymongo.mongo_client import MongoClient
-
-from ..backend.settings import SYMAI_CONFIG
-from ..utils import UserMessage
-
-if TYPE_CHECKING:
-    from pymongo.collection import Collection
-    from pymongo.database import Database
-else:
-    Collection = Database = Any
-
-logger = logging.getLogger(__name__)
-
-
-def rec_serialize(obj):
-    """
-    Recursively serialize a given object into a string representation, handling
-    nested structures like lists and dictionaries.
-
-    :param obj: The object to be serialized.
-    :return: A string representation of the serialized object.
-    """
-    if isinstance(obj, (int, float, bool)):
-        # For simple types, return the string representation directly.
-        return obj
-    if isinstance(obj, dict):
-        # For dictionaries, serialize each value. Keep keys as strings.
-        return {str(key): rec_serialize(value) for key, value in obj.items()}
-    if isinstance(obj, (list, tuple, set)):
-        # For lists, tuples, and sets, serialize each element.
-        return [rec_serialize(elem) for elem in obj]
-    # Attempt JSON serialization first, then fall back to str(...)
-    try:
-        return json.dumps(obj)
-    except TypeError:
-        return str(obj)
-
-
-class CollectionRepository:
-    def __init__(self) -> None:
-        self.support_community: bool = SYMAI_CONFIG["SUPPORT_COMMUNITY"]
-        self.uri: str = SYMAI_CONFIG["COLLECTION_URI"]
-        self.db_name: str = SYMAI_CONFIG["COLLECTION_DB"]
-        self.collection_name: str = SYMAI_CONFIG["COLLECTION_STORAGE"]
-        self.client: MongoClient | None = None
-        self.db: Database | None = None
-        self.collection: Collection | None = None
-
-    def __enter__(self) -> CollectionRepository:
-        self.connect()
-        return self
-
-    def __exit__(
-        self, exc_type: type | None, exc_val: Exception | None, exc_tb: Any | None
-    ) -> None:
-        self.close()
-
-    def ping(self) -> bool:
-        if not self.support_community:
-            return False
-        # Send a ping to confirm a successful connection
-        try:
-            self.client.admin.command("ping")
-            return True
-        except Exception as e:
-            UserMessage(f"Connection failed: {e}")
-            return False
-
-    def add(self, forward: Any, engine: Any, metadata: dict[str, Any] | None = None) -> Any:
-        if metadata is None:
-            metadata = {}
-        if not self.support_community:
-            return None
-        record = {
-            "forward": forward,
-            "engine": engine,
-            "metadata": metadata,
-            "created_at": datetime.now(),
-            "updated_at": datetime.now(),
-        }
-        try:  # assure that adding a record does never cause a system error
-            return self.collection.insert_one(record).inserted_id if self.collection else None
-        except Exception:
-            return None
-
-    def get(self, record_id: str) -> dict[str, Any] | None:
-        if not self.support_community:
-            return None
-        return self.collection.find_one({"_id": ObjectId(record_id)}) if self.collection else None
-
-    def update(
-        self,
-        record_id: str,
-        forward: Any | None = None,
-        engine: str | None = None,
-        metadata: dict[str, Any] | None = None,
-    ) -> Any:
-        if not self.support_community:
-            return None
-        updates: dict[str, Any] = {"updated_at": datetime.now()}
-        if forward is not None:
-            updates["forward"] = forward
-        if engine is not None:
-            updates["engine"] = engine
-        if metadata is not None:
-            updates["metadata"] = metadata
-
-        return (
-            self.collection.update_one({"_id": ObjectId(record_id)}, {"$set": updates})
-            if self.collection
-            else None
-        )
-
-    def delete(self, record_id: str) -> Any:
-        if not self.support_community:
-            return None
-        return self.collection.delete_one({"_id": ObjectId(record_id)}) if self.collection else None
-
-    def list(self, filters: dict[str, Any] | None = None, limit: int = 0) -> list[dict[str, Any]]:
-        if not self.support_community:
-            return None
-        if filters is None:
-            filters = {}
-        return list(self.collection.find(filters).limit(limit)) if self.collection else []
-
-    def count(self, filters: dict[str, Any] | None = None) -> int:
-        if not self.support_community:
-            return None
-        if filters is None:
-            filters = {}
-        return self.collection.count_documents(filters) if self.collection else 0
-
-    def connect(self) -> None:
-        try:
-            if self.client is None and self.support_community:
-                self.client = MongoClient(self.uri)
-                self.db = self.client[self.db_name]
-                self.collection = self.db[self.collection_name]
-        except Exception as e:
-            # disable retries
-            self.client = False
-            self.db = None
-            self.collection = None
-            UserMessage(f"[WARN] MongoClient: Connection failed: {e}")
-
-    def close(self) -> None:
-        if self.client is not None:
-            self.client.close()