symbolicai 0.21.0__py3-none-any.whl → 1.1.0__py3-none-any.whl

symai/collect/dynamic.py

@@ -1,5 +1,5 @@
-import re
 import ast
+import re
 
 
 class DynamicClass:
@@ -20,7 +20,7 @@ def create_dynamic_class(class_name, **kwargs):
 
 def parse_custom_class_instances(s):
     pattern = r"(\w+)\((.*?)\)"
-    if type(s) != str:
+    if not isinstance(s, str):
         return s
     matches = re.finditer(pattern, s)
 
@@ -28,80 +28,90 @@ def parse_custom_class_instances(s):
         class_name = match.group(1)
         class_args = match.group(2)
         try:
-            parsed_args = ast.literal_eval(f'{{{class_args}}}')
-        except:
+            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
 
-# TODO: fix to properly parse nested lists and dicts
-def create_object_from_string(str_class):
-    def updated_attributes_process(str_class):
-        # Regular expression to extract key-value pairs
-        attr_pattern = r"(\w+)=(\[.*?\]|\{.*?\}|'.*?'|None|\w+)"
-        attributes = re.findall(attr_pattern, str_class)
-
-        # Create an instance of the dynamic class with initial attributes
-        updated_attributes = []
-        # remove string up until 'content='
-        content = str_class.split('ChatCompletionMessage(content=')[-1].split(", role=")[0][1:-1]
-        updated_attributes.append(('content', content))
-        for key, value in attributes:
-            if key.startswith("'") and key.endswith("'"):
-                key = key.strip("'")
-            if key.startswith('"') and key.endswith('"'):
-                key = key.strip('"')
-            if value.startswith("'") and value.endswith("'"):
-                value = value.strip("'")
-            if value.startswith('"') and value.endswith('"'):
-                value = value.strip('"')
-
-            if value.startswith('[') and value.endswith(']'):
-                value = parse_value(value)
-                dir(value)
-                if hasattr(value, '__dict__'):
-                    for k in value.__dict__.keys():
-                        v = getattr(value, k)
-                        if type(v) == str:
-                            value[k.strip("'")] = v.strip("'")
-            elif value.startswith('{') and value.endswith('}'):
-                value = parse_value(value)
-                new_value = {}
-                for k in value.keys():
-                    v = value[k]
-                    if type(v) == str:
-                        v = v.strip("'")
-                    new_value[k.strip("'")] = v
-                value = new_value
-            updated_attributes.append((key, value))
-        return updated_attributes
-
-    def parse_value(value):
-        try:
-            value = parse_custom_class_instances(value)
-            if type(value) != str:
-                return value
-            if value.startswith('['):
-                value = value[1:-1]
-                values = value.split(',')
-                return [parse_value(v.strip()) for v in values]
-            elif value.startswith('{'):
-                value = value[1:-1]
-                values = value.split(',')
-                return {k.strip(): parse_value(v.strip()) for k, v in [v.split(':', 1) for v in values]}
-            res = ast.literal_eval(value)
-            if isinstance(res, dict):
-                return {k: parse_value(v) for k, v in res.items()}
-            elif isinstance(res, list) or isinstance(res, tuple) or isinstance(res, set):
-                return [parse_value(v) for v in res]
-            else:
-                return res
-        except:
+
+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
 
-    updated_attributes = updated_attributes_process(str_class)
-    obj = DynamicClass(**{key: parse_value(value) for key, value in updated_attributes})
 
-    return obj
+# 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,14 +1,21 @@
+from __future__ import annotations
+
 import json
 import logging
 from datetime import datetime
-from typing import Any, Dict, List, Optional
+from typing import TYPE_CHECKING, Any
 
 from bson.objectid import ObjectId
-from pymongo.collection import Collection
-from pymongo.database import Database
 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__)
 
@@ -24,35 +31,36 @@ def rec_serialize(obj):
     if isinstance(obj, (int, float, bool)):
         # For simple types, return the string representation directly.
         return obj
-    elif isinstance(obj, dict):
+    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()}
-    elif isinstance(obj, (list, tuple, set)):
+    if isinstance(obj, (list, tuple, set)):
         # For lists, tuples, and sets, serialize each element.
         return [rec_serialize(elem) for elem in obj]
-    else:
-        # Attempt JSON serialization first, then fall back to str(...)
-        try:
-            return json.dumps(obj)
-        except TypeError:
-            return str(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: Optional[MongoClient]      = None
-        self.db: Optional[Database]             = None
-        self.collection: Optional[Collection]   = None
-
-    def __enter__(self) -> 'CollectionRepository':
+        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: Optional[type], exc_val: Optional[Exception], exc_tb: Optional[Any]) -> None:
+    def __exit__(
+        self, exc_type: type | None, exc_val: Exception | None, exc_tb: Any | None
+    ) -> None:
         self.close()
 
     def ping(self) -> bool:
@@ -60,62 +68,70 @@ class CollectionRepository:
             return False
         # Send a ping to confirm a successful connection
         try:
-            self.client.admin.command('ping')
+            self.client.admin.command("ping")
             return True
         except Exception as e:
-            print("Connection failed: " + str(e))
+            UserMessage(f"Connection failed: {e}")
             return False
 
-    def add(self, forward: Any, engine: Any, metadata: Dict[str, Any] = {}) -> Any:
+    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()
+            "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
+        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 as e:
+        except Exception:
             return None
 
-    def get(self, record_id: str) -> Optional[Dict[str, Any]]:
+    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: Optional[Any]             = None,
-               engine: Optional[str]              = None,
-               metadata: Optional[Dict[str, Any]] = None) -> Any:
+        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()}
+        updates: dict[str, Any] = {"updated_at": datetime.now()}
         if forward is not None:
-            updates['forward']  = forward
+            updates["forward"] = forward
         if engine is not None:
-            updates['engine']   = engine
+            updates["engine"] = engine
         if metadata is not None:
-            updates['metadata'] = metadata
+            updates["metadata"] = metadata
 
-        return self.collection.update_one({'_id': ObjectId(record_id)}, {'$set': updates}) if self.collection else None
+        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
+        return self.collection.delete_one({"_id": ObjectId(record_id)}) if self.collection else None
 
-    def list(self, filters: Optional[Dict[str, Any]] = None, limit: int = 0) -> List[Dict[str, Any]]:
+    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: Optional[Dict[str, Any]] = None) -> int:
+    def count(self, filters: dict[str, Any] | None = None) -> int:
         if not self.support_community:
             return None
         if filters is None:
@@ -126,14 +142,14 @@ class CollectionRepository:
         try:
             if self.client is None and self.support_community:
                 self.client = MongoClient(self.uri)
-                self.db     = self.client[self.db_name]
+                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.client = False
+            self.db = None
             self.collection = None
-            print("[WARN] MongoClient: Connection failed: " + str(e))
+            UserMessage(f"[WARN] MongoClient: Connection failed: {e}")
 
     def close(self) -> None:
         if self.client is not None: