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

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()

symai/collect/stats.py

@@ -1,434 +0,0 @@
-import json
-import re
-from collections.abc import Callable
-from json import JSONEncoder
-from pathlib import Path
-from typing import Any, Union
-
-import numpy as np
-import torch
-
-from ..ops.primitives import OperatorPrimitives
-from ..symbol import Symbol
-from ..utils import UserMessage
-
-SPECIAL_CONSTANT = "__aggregate_"
-EXCLUDE_LIST = ["_ipython_canary_method_should_not_exist_", "__custom_documentations__"]
-
-
-def _normalize_name(name: str) -> str:
-    # Replace any character that is not a letter or a number with an underscore
-    normalized_name = re.sub(r"[^a-zA-Z0-9]", "_", name)
-    return normalized_name.lower()
-
-
-class AggregatorJSONEncoder(JSONEncoder):
-    def default(self, obj):
-        if isinstance(obj, np.ndarray):
-            return obj.tolist()
-        # drop active from state
-        if isinstance(obj, Aggregator):
-            state = obj.__dict__.copy()
-            state.pop("_raise_error", None)
-            state.pop("_active", None)
-            state.pop("_finalized", None)
-            state.pop("_map", None)
-            # drop everything that starts with SPECIAL_CONSTANT
-            for key in list(state.keys()):
-                if (
-                    (not key.startswith(SPECIAL_CONSTANT) and key != "_value")
-                    or (key == "_value" and obj._value == [])
-                    or key.replace(SPECIAL_CONSTANT, "") in EXCLUDE_LIST
-                ):
-                    state.pop(key, None)
-            return state
-        return obj.__dict__
-
-
-class Aggregator(Symbol):
-    def __init__(
-        self,
-        value: Union["Aggregator", Symbol] | None = None,
-        path: str | None = None,
-        active: bool = True,
-        raise_error: bool = False,
-        *args,
-        **kwargs,
-    ):
-        super().__init__(*args, **kwargs)
-        # disable nesy engine to avoid side effects
-        self.__disable_nesy_engine__ = True
-        if value is not None and isinstance(value, Symbol):
-            # use this to avoid recursion on map setter
-            self._value = value._value
-            if isinstance(self._value, np.ndarray):
-                self._value = self._value.tolist()
-            elif isinstance(self._value, torch.Tensor):
-                self._value = self._value.detach().cpu().numpy().tolist()
-            elif not isinstance(self._value, (list, tuple)):
-                self._value = [self._value]
-        elif value is not None:
-            UserMessage(
-                f"Aggregator object must be of type Aggregator or Symbol! Got: {type(value)}",
-                raise_with=Exception,
-            )
-        else:
-            self._value = []
-        self._raise_error = raise_error
-        self._active = active
-        self._finalized = False
-        self._map = None
-        self._path = path
-
-    def __new__(
-        cls,
-        *args,
-        mixin: bool | None = None,
-        primitives: list[type] | None = None,  # only inherit arithmetic primitives
-        callables: list[tuple[str, Callable]] | None = None,
-        semantic: bool = False,
-        **kwargs,
-    ) -> "Symbol":
-        if primitives is None:
-            primitives = [OperatorPrimitives]
-        return super().__new__(
-            cls,
-            *args,
-            mixin=mixin,
-            primitives=primitives,
-            callables=callables,
-            semantic=semantic,
-            **kwargs,
-        )
-
-    def __getattr__(self, name):
-        # replace name special characters and spaces with underscores
-        name = _normalize_name(name)
-        # Dynamically create new aggregator instance if it does not exist
-        if self._active and name not in self.__dict__:
-            aggregator = Aggregator(path=name)
-            aggregator._parent = self
-            self._children.append(aggregator)
-            # create a new aggregate aggregator
-            # named {SPECIAL_CONSTANT}{name} for automatic aggregation
-            self.__dict__[f"{SPECIAL_CONSTANT}{name}"] = aggregator
-            # add also a property with the same name but without the SPECIAL_CONSTANT prefix as a shortcut
-            self.__dict__[name] = self.__dict__[f"{SPECIAL_CONSTANT}{name}"]
-            return self.__dict__.get(name)
-        if not self._active and name not in self.__dict__:
-            UserMessage(
-                f"Aggregator object is frozen! No attribute {name} found!", raise_with=Exception
-            )
-        return self.__dict__.get(name)
-
-    def __setattr__(self, name, value):
-        # replace name special characters and spaces with underscores
-        name = _normalize_name(name)
-        return super().__setattr__(name, value)
-
-    def __delattr__(self, name):
-        # replace name special characters and spaces with underscores
-        name = _normalize_name(name)
-        return super().__delattr__(name)
-
-    def __getitem__(self, name):
-        # replace name special characters and spaces with underscores
-        name = _normalize_name(name)
-        return self.__getattr__(name)
-
-    def __setitem__(self, name, value):
-        # replace name special characters and spaces with underscores
-        name = _normalize_name(name)
-        return self.__setattr__(name, value)
-
-    def __delitem__(self, name):
-        # replace name special characters and spaces with underscores
-        name = _normalize_name(name)
-        return self.__delattr__(name)
-
-    def __setstate__(self, state):
-        # replace name special characters and spaces with underscores
-        # drop active from state
-        state.pop("_raise_error", None)
-        state.pop("_active", None)
-        state.pop("_finalized", None)
-        state.pop("_map", None)
-        return super().__setstate__(state)
-
-    @staticmethod
-    def _set_values(obj, dictionary, parent, strict: bool = True):
-        # recursively reconstruct the object
-        for key, value in dictionary.items():
-            attr_key = key
-            attr_value = value
-            if isinstance(attr_value, dict):
-                if parent is not None:
-                    obj._path = attr_key
-                attr_value = Aggregator._reconstruct(attr_value, parent=parent, strict=strict)
-            if attr_key.startswith(SPECIAL_CONSTANT):
-                attr_key = attr_key.replace(SPECIAL_CONSTANT, "")
-            if attr_key == "_value":
-                try:
-                    attr_value = np.asarray(attr_value, dtype=np.float32)
-                except Exception as e:
-                    if strict:
-                        msg = f"Could not set value of Aggregator object: {obj.path}! ERROR: {e}"
-                        UserMessage(msg)
-                        raise Exception(msg) from e
-            obj.__setattr__(attr_key, attr_value)
-
-    @staticmethod
-    def _reconstruct(dictionary, parent=None, strict: bool = True):
-        obj = Aggregator()
-        obj._parent = parent
-        if parent is not None:
-            parent._children.append(obj)
-        Aggregator._set_values(obj, dictionary, parent=obj, strict=strict)
-        return obj
-
-    def __str__(self) -> str:
-        """
-        Get the string representation of the Symbol object.
-
-        Returns:
-            str: The string representation of the Symbol object.
-        """
-        return str(self.entries)
-
-    def _to_symbol(self, other) -> Symbol:
-        sym = super()._to_symbol(other)
-        res = Aggregator(sym)
-        res._parent = self
-        self._children.append(res)
-        return
-
-    @property
-    def path(self) -> str:
-        path = ""
-        obj = self
-        while obj is not None:
-            if obj._path is not None:
-                path = obj._path.replace(SPECIAL_CONSTANT, "") + "." + path
-            obj = obj._parent
-        return path[:-1]  # remove last dot
-
-    def __or__(self, other: Any) -> Any:
-        self.add(other)
-        return other
-
-    def __ror__(self, other: Any) -> Any:
-        self.add(other)
-        return other
-
-    def __ior__(self, other: Any) -> Any:
-        self.add(other)
-        return other
-
-    def __len__(self) -> int:
-        return len(self._value)
-
-    @property
-    def entries(self):
-        return self._value
-
-    @property
-    def value(self):
-        if self.map is not None:
-            return np.asarray(self.map(np.asarray(self._value, dtype=np.float32)))
-        return np.asarray(self._value, dtype=np.float32)
-
-    @property
-    def map(self):
-        return self._map if not self.empty() else None
-
-    @map.setter
-    def map(self, value):
-        self._set_map_recursively(value)
-
-    def _set_map_recursively(self, map):
-        self._map = map
-        for key, value in self.__dict__.items():
-            if isinstance(value, Aggregator) and (
-                not key.startswith("_") or key.startswith(SPECIAL_CONSTANT)
-            ):
-                value.map = map
-
-    def shape(self):
-        if len(self.entries) > 0:
-            return np.asarray(self.entries).shape
-        return ()
-
-    def serialize(self):
-        return json.dumps(self, cls=AggregatorJSONEncoder)
-
-    def save(self, path: str):
-        with Path(path).open("w") as f:
-            json.dump(self, f, cls=AggregatorJSONEncoder)
-
-    @staticmethod
-    def load(path: str, strict: bool = True):
-        with Path(path).open() as f:
-            json_ = json.load(f)
-        return Aggregator._reconstruct(json_, strict=strict)
-
-    def empty(self) -> bool:
-        return len(self) == 0
-
-    def add(self, entries):
-        # Add entries to the aggregator
-        if not self.active and self._finalized:
-            UserMessage("Aggregator object is frozen!", raise_with=Exception)
-            return
-        try:
-            processed_entries = self._prepare_entries(entries)
-            if processed_entries is None:
-                return
-            processed_entries = self._squeeze_entries(processed_entries)
-            self.entries.append(processed_entries)
-        except Exception as e:
-            msg = f"Could not add entries to Aggregator object! Please verify type or original error: {e}"
-            if self._raise_error:
-                UserMessage(msg)
-                raise Exception(msg) from e
-            UserMessage(msg)
-
-    def _prepare_entries(self, entries):
-        valid_types = (
-            tuple,
-            list,
-            np.float32,
-            np.float64,
-            np.ndarray,
-            torch.Tensor,
-            int,
-            float,
-            bool,
-            str,
-            Symbol,
-        )
-        assert isinstance(entries, valid_types), (
-            f"Entries must be a tuple, list, numpy array, torch tensor, integer, float, boolean, string, or Symbol! Got: {type(entries)}"
-        )
-        if isinstance(entries, torch.Tensor):
-            return entries.detach().cpu().numpy().astype(np.float32)
-        if isinstance(entries, (tuple, list)):
-            return np.asarray(entries, dtype=np.float32)
-        if isinstance(entries, bool):
-            return int(entries)
-        if isinstance(entries, str):
-            return Symbol(entries).embedding.astype(np.float32)
-        if isinstance(entries, Symbol):
-            # Use this to avoid recursion on map setter
-            self.add(entries._value)
-            return None
-        if isinstance(entries, Aggregator):
-            self.add(entries.get())
-            return None
-        return entries
-
-    def _squeeze_entries(self, entries):
-        if isinstance(entries, (np.ndarray, np.float32)):
-            return entries.squeeze()
-        return entries
-
-    def keys(self):
-        # Get all key names of items that have the SPECIAL_CONSTANT prefix
-        return [
-            key.replace(SPECIAL_CONSTANT, "")
-            for key in self.__dict__
-            if not key.startswith("_") and key.replace(SPECIAL_CONSTANT, "") not in EXCLUDE_LIST
-        ]
-
-    @property
-    def active(self):
-        # Get the active status of the aggregator
-        return self._active
-
-    @active.setter
-    def active(self, value):
-        # Set the active status of the aggregator
-        assert isinstance(value, bool), f"Active status must be a boolean! Got: {type(value)}"
-        self._active = value
-
-    @property
-    def finalized(self):
-        # Get the finalized status of the aggregator
-        return self._finalized
-
-    @finalized.setter
-    def finalized(self, value):
-        # Set the finalized status of the aggregator
-        assert isinstance(value, bool), f"Finalized status must be a boolean! Got: {type(value)}"
-        self._finalized = value
-
-    def finalize(self):
-        # Finalizes the dynamic creation of the aggregators and freezes the object to prevent further changes
-        self._active = False
-        self._finalized = True
-
-        def raise_exception(name, value):
-            if name == "map":
-                self.__setattr__(name, value)
-            else:
-                UserMessage("Aggregator object is frozen!", raise_with=Exception)
-
-        self.__setattr__ = raise_exception
-
-        def get_attribute(*args, **kwargs):
-            return self.__dict__.get(*args, **kwargs)
-
-        self.__getattr__ = get_attribute
-        # Do the same recursively for all properties of type Aggregator
-        for key, value in self.__dict__.items():
-            if isinstance(value, Aggregator) and (
-                not key.startswith("_") or key.startswith(SPECIAL_CONSTANT)
-            ):
-                value.finalize()
-
-    def get(self, *args, **kwargs):
-        if self._map is not None:
-            return self._map(self.entries, *args, **kwargs)
-        # Get the entries of the aggregator
-        return self.entries
-
-    def clear(self):
-        # Clear the entries of the aggregator
-        if self._finalized:
-            UserMessage("Aggregator object is frozen!", raise_with=Exception)
-        self._value = []
-
-    def sum(self, axis=0):
-        # Get the sum of the entries of the aggregator
-        return np.sum(self.entries, axis=axis)
-
-    def mean(self, axis=0):
-        # Get the mean of the entries of the aggregator
-        return np.mean(self.entries, axis=axis)
-
-    def median(self, axis=0):
-        # Get the median of the entries of the aggregator
-        return np.median(self.entries, axis=axis)
-
-    def var(self, axis=0):
-        # Get the variance of the entries of the aggregator
-        return np.var(self.entries, axis=axis)
-
-    def cov(self, rowvar=False):
-        # Get the covariance of the entries of the aggregator
-        return np.cov(self.entries, rowvar=rowvar)
-
-    def moment(self, moment=2, axis=0):
-        # Get the moment of the entries of the aggregator
-        return np.mean(np.power(self.entries, moment), axis=axis)
-
-    def std(self, axis=0):
-        # Get the standard deviation of the entries of the aggregator
-        return np.std(self.entries, axis=axis)
-
-    def min(self, axis=0):
-        # Get the minimum of the entries of the aggregator
-        return np.min(self.entries, axis=axis)
-
-    def max(self, axis=0):
-        # Get the maximum of the entries of the aggregator
-        return np.max(self.entries, axis=axis)