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

symai/models/errors.py

@@ -1,10 +1,9 @@
-from pydantic import BaseModel
-
 class ExceptionWithUsage(Exception):
     def __init__(self, message, usage):
         super().__init__(message)
         self.usage = usage
 
+
 class TypeValidationError(Exception):
     def __init__(self, prompt: str, result: str, violations: list[str], *args):
         super().__init__(*args)

symai/ops/__init__.py

@@ -1,25 +1,35 @@
-from .primitives import *
+from . import primitives as _primitives
+
+__all__ = getattr(_primitives, "__all__", None)  # noqa
+if __all__ is None:
+    __all__ = [name for name in dir(_primitives) if not name.startswith("_")]
+
+for _name in __all__:
+    globals()[_name] = getattr(_primitives, _name)
 
 SYMBOL_PRIMITIVES = [
-    OperatorPrimitives,
-    IterationPrimitives,
-    ValueHandlingPrimitives,
-    StringHelperPrimitives,
-    CastingPrimitives,
-    ComparisonPrimitives,
-    ExpressionHandlingPrimitives,
-    DataHandlingPrimitives,
-    UniquenessPrimitives,
-    PatternMatchingPrimitives,
-    DictHandlingPrimitives,
-    QueryHandlingPrimitives,
-    ExecutionControlPrimitives,
-    TemplateStylingPrimitives,
-    DataClusteringPrimitives,
-    EmbeddingPrimitives,
-    IndexingPrimitives,
-    IOHandlingPrimitives,
-    PersistencePrimitives,
-    OutputHandlingPrimitives,
-    FineTuningPrimitives,
+    _primitives.OperatorPrimitives,
+    _primitives.IterationPrimitives,
+    _primitives.ValueHandlingPrimitives,
+    _primitives.StringHelperPrimitives,
+    _primitives.CastingPrimitives,
+    _primitives.ComparisonPrimitives,
+    _primitives.ExpressionHandlingPrimitives,
+    _primitives.DataHandlingPrimitives,
+    _primitives.UniquenessPrimitives,
+    _primitives.PatternMatchingPrimitives,
+    _primitives.DictHandlingPrimitives,
+    _primitives.QueryHandlingPrimitives,
+    _primitives.ExecutionControlPrimitives,
+    _primitives.TemplateStylingPrimitives,
+    _primitives.DataClusteringPrimitives,
+    _primitives.EmbeddingPrimitives,
+    _primitives.IndexingPrimitives,
+    _primitives.IOHandlingPrimitives,
+    _primitives.PersistencePrimitives,
+    _primitives.OutputHandlingPrimitives,
+    _primitives.FineTuningPrimitives,
 ]
+
+del _name
+del _primitives

symai/ops/measures.py

@@ -1,7 +1,8 @@
 import numpy as np
-
 from scipy import linalg
 
+from ..utils import UserMessage
+
 
 def calculate_frechet_distance(mu1, sigma1, mu2, sigma2, eps=1e-6):
     """Numpy implementation of the Frechet Distance.
@@ -31,19 +32,18 @@ def calculate_frechet_distance(mu1, sigma1, mu2, sigma2, eps=1e-6):
     sigma1 = np.atleast_2d(sigma1)
     sigma2 = np.atleast_2d(sigma2)
 
-    assert mu1.shape == mu2.shape, \
-        'Training and test mean vectors have different lengths'
-    assert sigma1.shape == sigma2.shape, \
-        'Training and test covariances have different dimensions'
+    assert mu1.shape == mu2.shape, "Training and test mean vectors have different lengths"
+    assert sigma1.shape == sigma2.shape, "Training and test covariances have different dimensions"
 
     diff = mu1 - mu2
 
     # Product might be almost singular
     covmean, _ = linalg.sqrtm(sigma1.dot(sigma2), disp=False)
     if not np.isfinite(covmean).all():
-        msg = ('fid calculation produces singular product; '
-            'adding %s to diagonal of cov estimates') % eps
-        print(msg)
+        msg = (
+            f"fid calculation produces singular product; adding {eps} to diagonal of cov estimates"
+        )
+        UserMessage(msg)
         offset = np.eye(sigma1.shape[0]) * eps
         covmean = linalg.sqrtm((sigma1 + offset).dot(sigma2 + offset))
 
@@ -51,15 +51,14 @@ def calculate_frechet_distance(mu1, sigma1, mu2, sigma2, eps=1e-6):
     if np.iscomplexobj(covmean):
         if not np.allclose(np.diagonal(covmean).imag, 0, atol=1e-3):
             m = np.max(np.abs(covmean.imag))
-            raise ValueError('Imaginary component {}'.format(m))
+            UserMessage(f"Imaginary component {m}", raise_with=ValueError)
         covmean = covmean.real
 
     tr_covmean = np.trace(covmean)
-    val = diff.dot(diff) + np.trace(sigma1) + np.trace(sigma2) - 2 * tr_covmean
-    return val
+    return diff.dot(diff) + np.trace(sigma1) + np.trace(sigma2) - 2 * tr_covmean
 
 
-def calculate_mmd(x, y, kernel='rbf', kernel_mul=2.0, kernel_num=5, fix_sigma=None, eps=1e-9):
+def calculate_mmd(x, y, kernel="rbf", kernel_mul=2.0, kernel_num=5, fix_sigma=None, eps=1e-9):
     def gaussian_kernel(source, target, kernel_mul, kernel_num, fix_sigma):
         n_samples = source.shape[0] + target.shape[0]
         total = np.concatenate([source, target], axis=0)
@@ -67,28 +66,28 @@ def calculate_mmd(x, y, kernel='rbf', kernel_mul=2.0, kernel_num=5, fix_sigma=No
         total1 = np.expand_dims(total, 1)
         L2_distance = np.sum((total0 - total1) ** 2, axis=2)
 
-        if fix_sigma:
-            bandwidth = fix_sigma
-        else:
-            bandwidth = np.sum(L2_distance) / (n_samples ** 2 - n_samples + eps)
+        bandwidth = fix_sigma or np.sum(L2_distance) / (n_samples**2 - n_samples + eps)
         bandwidth /= kernel_mul ** (kernel_num // 2)
-        bandwidth_list = [bandwidth * (kernel_mul ** i) for i in range(kernel_num)]
-        kernel_val = [np.exp(-L2_distance / (bandwidth_temp + eps)) for bandwidth_temp in bandwidth_list]
+        bandwidth_list = [bandwidth * (kernel_mul**i) for i in range(kernel_num)]
+        kernel_val = [
+            np.exp(-L2_distance / (bandwidth_temp + eps)) for bandwidth_temp in bandwidth_list
+        ]
         return np.sum(kernel_val, axis=0)
 
     def linear_mmd2(f_of_X, f_of_Y):
         delta = f_of_X.mean(axis=0) - f_of_Y.mean(axis=0)
-        loss = np.dot(delta, delta.T)
-        return loss
+        return np.dot(delta, delta.T)
 
-    if kernel == 'linear':
+    if kernel == "linear":
         return linear_mmd2(x, y)
-    elif kernel == 'rbf':
+    if kernel == "rbf":
         batch_size = x.shape[0]
-        kernels = gaussian_kernel(x, y, kernel_mul=kernel_mul, kernel_num=kernel_num, fix_sigma=fix_sigma)
+        kernels = gaussian_kernel(
+            x, y, kernel_mul=kernel_mul, kernel_num=kernel_num, fix_sigma=fix_sigma
+        )
         xx = np.mean(kernels[:batch_size, :batch_size])
         yy = np.mean(kernels[batch_size:, batch_size:])
         xy = np.mean(kernels[:batch_size, batch_size:])
         yx = np.mean(kernels[batch_size:, :batch_size])
-        loss = xx + yy - xy - yx
-        return loss
+        return xx + yy - xy - yx
+    return None