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

symai/prompts.py

@@ -1,12 +1,13 @@
 import threading
-from abc import ABC
+from collections.abc import Callable
 from enum import Enum
-from typing import Any, Callable, List
+from typing import Any
 
 from .exceptions import TemplatePropertyException
+from .utils import UserMessage
 
 
-class Prompt(ABC):
+class Prompt:
     stop_token = 'EOF'
 
     def __init__(self, value, **format_kwargs):
@@ -21,22 +22,26 @@ class Prompt(ABC):
                 elif isinstance(v, Prompt):
                     self._value += v.value
                 else:
-                    raise ValueError(f"List of values must be strings or Prompts, not {type(v)}")
+                    msg = f"List of values must be strings or Prompts, not {type(v)}"
+                    UserMessage(msg)
+                    raise ValueError(msg)
         elif isinstance(value, Prompt):
             self._value += value.value
         elif isinstance(value, Callable):
             res = value()
             self._value += res.value
         else:
-            raise TypeError(f"Prompt value must be of type str, List[str], Prompt, or List[Prompt], not {type(value)}")
+            msg = f"Prompt value must be of type str, List[str], Prompt, or List[Prompt], not {type(value)}"
+            UserMessage(msg)
+            raise TypeError(msg)
         self.dynamic_value = []
         self.format_kwargs = format_kwargs
 
     @property
-    def value(self) -> List[str]:
+    def value(self) -> list[str]:
         return self._value
 
-    def __call__(self, *args: Any, **kwds: Any) -> List["Prompt"]:
+    def __call__(self, *_args: Any, **_kwds: Any) -> list["Prompt"]:
         return self.value
 
     def __str__(self) -> str:
@@ -48,11 +53,17 @@ class Prompt(ABC):
                 template_ = '{'+k+'}'
                 count = val_.count(template_)
                 if count <= 0:
-                    raise TemplatePropertyException(f"Template property `{k}` not found.")
-                elif count > 1:
-                    raise TemplatePropertyException(f"Template property {k} found multiple times ({count}), expected only once.")
+                    msg = f"Template property `{k}` not found."
+                    UserMessage(msg)
+                    raise TemplatePropertyException(msg)
+                if count > 1:
+                    msg = f"Template property {k} found multiple times ({count}), expected only once."
+                    UserMessage(msg)
+                    raise TemplatePropertyException(msg)
                 if v is None:
-                    raise TemplatePropertyException(f"Invalid value: Template property {k} is None.")
+                    msg = f"Invalid value: Template property {k} is None."
+                    UserMessage(msg)
+                    raise TemplatePropertyException(msg)
                 val_ = val_.replace(template_, v)
         return val_
 
@@ -99,7 +110,7 @@ class PromptRegistry:
         if cls._instance is None:
             with cls._lock:
                 if cls._instance is None:
-                    cls._instance = super(PromptRegistry, cls).__new__(cls)
+                    cls._instance = super().__new__(cls)
                     cls._instance._default_language = PromptLanguage.ENGLISH
                     cls._instance._default_model = ModelName.ALL
                     cls._instance._model_fallback = True
@@ -164,12 +175,15 @@ class PromptRegistry:
             and key in dictionary[model][lang]
         ):
             return dictionary[model][lang][key]
-        elif self._model_fallback and model != ModelName.ALL:
+        if self._model_fallback and model != ModelName.ALL:
             return self._retrieve_value(dictionary, ModelName.ALL, lang, key)
 
-        raise ValueError(
-            f"Prompt value {key} not found for language {lang} and model {model} (fallback: {self._model_fallback})"
+        msg = (
+            f"Prompt value {key} not found for language {lang} and model {model} "
+            f"(fallback: {self._model_fallback})"
         )
+        UserMessage(msg)
+        raise ValueError(msg)
 
     def register_value(
         self,
@@ -222,13 +236,11 @@ class PromptRegistry:
             if format:
                 prefix, suffix = tag_data['delimiters']
                 return f"{prefix}{tag_value}{suffix}"
-            else:
-                return tag_value
+            return tag_value
 
         if format:
             return f"{self._tag_prefix}{tag_data}{self._tag_suffix}"
-        else:
-            return tag_data
+        return tag_data
 
     def has_value(
         self, key, model: ModelName = ModelName.ALL, lang: PromptLanguage = None
@@ -260,24 +272,26 @@ class PromptRegistry:
 
 class JsonPromptTemplate(Prompt):
     def __init__(self, query: str, json_format: dict):
-        super().__init__(["""Process the query over the data to create a Json format: <data_query> => [JSON_BEGIN]<json_output>[JSON_END].
---------------------------
-The json format is:
-{json_format}
---------------------------
-The generated output must follow the <json_output> formatting, however the keys and values must be replaced with the requested user data query results. Definition of the <data_query> := {query}
---------------------------
-Do not return anything other than a valid json format.
-Your first character must always be a""" \
-"""'{' and your last character must always be a '}', everything else follows the user specified instructions.
-Only use double quotes " for the keys and values.
-Start the generation process after [JSON_BEGIN] and end it with [JSON_END].
-Every key that has no semantic placeholder brackets around it (e.g. {placeholder}, {entity}, {attribute}, etc.) must be available in the generated json output.
-All semantic placeholders (e.g. {placeholder}, {entity}, {attribute}, etc.) must be replaced according to their wheather or not they are found in the data query results.
-DO NOT WRITE the semantic placeholders (e.g. {placeholder}, {entity}, {attribute}, etc.) in the generated json output.
---------------------------
-
-"""], query=query, json_format=str(json_format))
+        json_format_str = str(json_format)
+        prompt_template = (
+            "Process the query over the data to create a Json format: <data_query> => [JSON_BEGIN]<json_output>[JSON_END].\n"
+            "--------------------------\n"
+            "The json format is:\n"
+            f"{json_format_str}\n"
+            "--------------------------\n"
+            "The generated output must follow the <json_output> formatting, however the keys and values must be replaced with the requested user data query results. "
+            f"Definition of the <data_query> := {query}\n"
+            "--------------------------\n"
+            "Do not return anything other than a valid json format.\n"
+            "Your first character must always be a '{{' and your last character must always be a '}}', everything else follows the user specified instructions.\n"
+            'Only use double quotes " for the keys and values.\n'
+            "Start the generation process after [JSON_BEGIN] and end it with [JSON_END].\n"
+            "Every key that has no semantic placeholder brackets around it (e.g. {placeholder}, {entity}, {attribute}, etc.) must be available in the generated json output.\n"
+            "All semantic placeholders (e.g. {placeholder}, {entity}, {attribute}, etc.) must be replaced according to their wheather or not they are found in the data query results.\n"
+            "DO NOT WRITE the semantic placeholders (e.g. {placeholder}, {entity}, {attribute}, etc.) in the generated json output.\n"
+            "--------------------------\n\n"
+        )
+        super().__init__([prompt_template], query=query, json_format=json_format_str)
 
 
 class FuzzyEquals(Prompt):
@@ -314,7 +328,7 @@ class FuzzyEquals(Prompt):
             "['zz', 'yy', 'xx'] == 'ZZ | YY | XX' =>True",
             "'House, Mouse, CARS' == 'house | mouse | cars' =>True",
             "'we hav teh most efective systeem in the citi.' == 'We have the most effective system in the city.' =>True",
-            "【Ｓｅｍａｎｔｉｃ░ｐｒｏｇｒａｍｍｉｎｇ】 == 'semantic programming' =>True",
+            "'[SEMANTIC_PROGRAMMING]' == 'semantic programming' =>True",
             "'e' == 'constant' =>True",
             "'e' == '2.718...' =>True",
             "1/3 == '0.30...' =>False"
@@ -585,7 +599,7 @@ class FewShotPattern(Prompt):
 class StartsWith(Prompt):
     def __init__(self):
         super().__init__([
-            # Semantic examples – understanding concepts (positive cases)
+            # Semantic examples - understanding concepts (positive cases)
             "'The apple fell from the tree.' startswith 'fruit' =>True",
             "'The red rose bloomed in spring.' startswith 'flower' =>True",
             "'My dog loves to play fetch.' startswith 'animal' =>True",
@@ -601,7 +615,7 @@ class StartsWith(Prompt):
             "'The earthquake shook the entire city.' startswith 'natural disaster' =>True",
             "'She invested in stocks and bonds.' startswith 'finance' =>True",
             "'The police officer directed traffic.' startswith 'law enforcement' =>True",
-            # Semantic examples – negative cases
+            # Semantic examples - negative cases
             "'The book was very interesting.' startswith 'vehicle' =>False",
             "'The mountain peak was covered in snow.' startswith 'ocean' =>False",
             "'She played the piano beautifully.' startswith 'sports' =>False",
@@ -614,7 +628,7 @@ class StartsWith(Prompt):
 class EndsWith(Prompt):
     def __init__(self):
         super().__init__([
-            # Semantic examples – understanding concepts (positive cases)
+            # Semantic examples - understanding concepts (positive cases)
             "'She sliced a ripe banana.' endswith 'fruit' =>True",
             "'He adopted a small puppy.' endswith 'animal' =>True",
             "'They commuted by train.' endswith 'vehicle' =>True",
@@ -625,7 +639,7 @@ class EndsWith(Prompt):
             "'He flew to Spain.' endswith 'country' =>True",
             "'The chef baked fresh bread.' endswith 'food' =>True",
             "'They filmed a documentary about dolphins.' endswith 'animal' =>True",
-            # Semantic examples – negative cases
+            # Semantic examples - negative cases
             "'The sun set behind the mountains.' endswith 'vehicle' =>False",
             "'He repaired the motorcycle.' endswith 'instrument' =>False",
             "'They enjoyed a salad.' endswith 'building' =>False",
@@ -700,7 +714,7 @@ class SimpleSymbolicExpression(Prompt):
             '"x² = 9" or "x = 4" =>Either x² = 9 or x = 4.',
             '"x² = 9" xor "x = 4" =>Exactly one of x² = 9 or x = 4, but not both.',
             '"x² = 9" implies "x = ±3" =>If x² = 9, then x = ±3.',
-            '"f′(x) = 0" ++ "f has a local extremum" =>A critical point indicates f has a local extremum.',
+            '"f prime (x) = 0" ++ "f has a local extremum" =>A critical point indicates f has a local extremum.',
             '"a² + b² = c²" * "c = 13" =>In the right-triangle where c = 13, a² + b² = 169.',
             '"limₓ→0 sin x / x = 1" and "x approaches 0" =>As x approaches 0, sin x / x tends to 1.',
             """"SELECT name FROM customers" + "WHERE city = 'Paris'" =>SELECT name FROM customers WHERE city = 'Paris'.""",
@@ -709,7 +723,7 @@ class SimpleSymbolicExpression(Prompt):
             """"x > 3" and "x < 7" =>3 < x < 7.""",
             """"a divides b" implies "b mod a = 0" =>If a divides b, then b mod a = 0.""",
             """"p" xor "not p" =>Exactly one of p or not p, but not both.""",
-            """"f′(x) exists" ++ "f(x) continuous" =>A differentiable function is necessarily continuous.""",
+            """"f prime (x) exists" ++ "f(x) continuous" =>A differentiable function is necessarily continuous.""",
             """"SELECT * FROM orders" / "status = 'PENDING'" =>If status = 'PENDING', SELECT * FROM orders.""",
             """"x = 2" + "y = 3" * "z = x + y" =>With x = 2 and y = 3, z = 5.""",
             """"temperature rises" >> "ice melts" =>Because temperature rises, ice melts."""
@@ -734,7 +748,7 @@ class LogicExpression(Prompt):
             # AND
             "expr 'All humans are mortal' and 'Socrates is a human' =>'Therefore, Socrates is mortal.'",
             "expr 'If it rains, the ground gets wet' and 'It is raining' =>'Therefore, the ground gets wet.'",
-            "expr 'The sky is blue' and 'The sky is not blue' =>'Contradiction – both cannot be true together.'",
+            "expr 'The sky is blue' and 'The sky is not blue' =>'Contradiction - both cannot be true together.'",
             # OR
             "expr 'It is Monday' or 'It is a holiday' =>'Either it is Monday, a holiday, or possibly both.'",
             "expr 'Alice is at home' or 'Bob is at home' =>'Alice or Bob is at home, perhaps both.'",

symai/server/huggingface_server.py

@@ -1,14 +1,17 @@
 import argparse
 import random
-from typing import List, Optional
 
 import numpy as np
 import torch
-from fastapi import FastAPI, Request
+from fastapi import FastAPI
 from pydantic import BaseModel
-from transformers import (AutoModelForCausalLM, AutoTokenizer,
-                          BitsAndBytesConfig, StoppingCriteria,
-                          StoppingCriteriaList)
+from transformers import (
+    AutoModelForCausalLM,
+    AutoTokenizer,
+    BitsAndBytesConfig,
+    StoppingCriteria,
+    StoppingCriteriaList,
+)
 
 # General arguments
 parser = argparse.ArgumentParser(description="FastAPI server for Hugging Face models")
@@ -84,7 +87,7 @@ class StoppingCriteriaSub(StoppingCriteria):
         self.stop_words = stop_words
         self.tokenizer = tokenizer
 
-    def __call__(self, input_ids: torch.LongTensor, scores: torch.FloatTensor, **kwargs) -> bool:
+    def __call__(self, input_ids: torch.LongTensor, _scores: torch.FloatTensor, **_kwargs) -> bool:
         for stop_word in self.stop_words:
             if self.tokenizer.decode(input_ids[0][-len(self.tokenizer.encode(stop_word)):]).strip() == stop_word:
                 return True
@@ -92,26 +95,26 @@ class StoppingCriteriaSub(StoppingCriteria):
 
 class TokenizeRequest(BaseModel):
     input: str
-    add_special_tokens: Optional[bool] = False
+    add_special_tokens: bool | None = False
 
 class DetokenizeRequest(BaseModel):
-    tokens: List[int]
-    skip_special_tokens: Optional[bool] = True
+    tokens: list[int]
+    skip_special_tokens: bool | None = True
 
 class ChatCompletionRequest(BaseModel):
-    messages: List[dict]
+    messages: list[dict]
     temperature: float = 1.
     top_p: float = 1.
-    stop: Optional[List[str]] = None
-    seed: Optional[int] = None
-    max_tokens: Optional[int] = 2048
-    max_tokens_forcing: Optional[int] = None
+    stop: list[str] | None = None
+    seed: int | None = None
+    max_tokens: int | None = 2048
+    max_tokens_forcing: int | None = None
     top_k: int = 50
     logprobs: bool = False
     do_sample: bool = True
     num_beams: int = 1
     num_beam_groups: int = 1
-    eos_token_id: Optional[int] = None
+    eos_token_id: int | None = None
 
 @app.post("/chat")
 def chat_completions(request: ChatCompletionRequest):
@@ -145,7 +148,7 @@ def chat_completions(request: ChatCompletionRequest):
     new_tokens = outputs.sequences[0][inputs.input_ids.shape[-1]:]
     generated_text = tokenizer.decode(new_tokens, skip_special_tokens=True)
 
-    response = {
+    return {
         "choices": [
             {
                 "message": {
@@ -175,8 +178,6 @@ def chat_completions(request: ChatCompletionRequest):
         }
     }
 
-    return response
-
 @app.post("/tokenize")
 def tokenize(request: TokenizeRequest):
     tokens = tokenizer.encode(request.input, add_special_tokens=request.add_special_tokens)
@@ -188,7 +189,9 @@ def detokenize(request: DetokenizeRequest):
     return {"text": text}
 
 def huggingface_server():
-    import uvicorn
-    from functools import partial
+    # Lazy imports keep optional server dependencies out of module import path.
+    from functools import partial # noqa
+    import uvicorn # noqa
+
     command = partial(uvicorn.run, app)
     return command, args

symai/server/llama_cpp_server.py

@@ -1,9 +1,11 @@
 import argparse
 import subprocess
 import sys
-import os
+from pathlib import Path
+
 from loguru import logger
 
+
 def llama_cpp_server():
     parser = argparse.ArgumentParser(description="A wrapper for llama_cpp.", add_help=False)
     parser.add_argument("--help", action="store_true", help="Show available options for llama_cpp server.")
@@ -16,23 +18,23 @@ def llama_cpp_server():
     if main_args.help:
         if main_args.env == 'python':
             command = [sys.executable, "-m", "llama_cpp.server", "--help"]
-            subprocess.run(command)
+            subprocess.run(command, check=False)
         else:
             if not main_args.cpp_server_path:
                 logger.error("Error: --cpp-server-path is required when using cpp environment")
                 sys.exit(1)
-            if not os.path.exists(main_args.cpp_server_path):
+            if not Path(main_args.cpp_server_path).exists():
                 logger.error(f"Error: Executable not found at {main_args.cpp_server_path}")
                 sys.exit(1)
             command = [main_args.cpp_server_path, "--help"]
-            subprocess.run(command)
+            subprocess.run(command, check=False)
         sys.exit(0)
 
     if main_args.env == 'cpp':
         if not main_args.cpp_server_path:
             logger.error("Error: --cpp-server-path is required when using cpp environment")
             sys.exit(1)
-        if not os.path.exists(main_args.cpp_server_path):
+        if not Path(main_args.cpp_server_path).exists():
             logger.error(f"Error: Executable not found at {main_args.cpp_server_path}")
             sys.exit(1)
         command = [

symai/shell.py

@@ -1,16 +1,15 @@
 import argparse
 import os
 
+from . import SYMAI_VERSION
 from .components import Lambda, Try
 from .core import few_shot
 from .misc.console import ConsoleStyle
 from .misc.loader import Loader
 from .post_processors import StripPostProcessor
 from .pre_processors import PreProcessor
-from .symbol import Expression
 from .shellsv import run as shellsv_run
-from . import SYMAI_VERSION
-
+from .symbol import Expression
 
 SHELL_CONTEXT = """[Description]
 This shell program is the command interpreter on the Linux systems, MacOS and Windows PowerShell.
@@ -47,7 +46,7 @@ $> New-Item -ItemType Directory -Path <path> EOF
 
 class ShellPreProcessor(PreProcessor):
     def __call__(self, argument):
-        return '// {}\n$>'.format(str(argument.prop.instance))
+        return f'// {argument.prop.instance!s}\n$>'
 
 
 class Shell(Expression):