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

symai/ops/primitives.py

@@ -31,12 +31,18 @@ class Primitive:
         super().__init__(*args, **kwargs)
         # by default, disable shortcut matches and neuro-symbolic iterations
         self.__semantic__ = self.__semantic__ or Primitive.__semantic__
-        self.__disable_nesy_engine__ = self.__disable_nesy_engine__ or Primitive.__disable_nesy_engine__
-        self.__disable_none_shortcut__ = self.__disable_none_shortcut__ or Primitive.__disable_none_shortcut__
+        self.__disable_nesy_engine__ = (
+            self.__disable_nesy_engine__ or Primitive.__disable_nesy_engine__
+        )
+        self.__disable_none_shortcut__ = (
+            self.__disable_none_shortcut__ or Primitive.__disable_none_shortcut__
+        )
 
     @staticmethod
     def _is_iterable(value):
-        return isinstance(value, (list, tuple, set, dict, bytes, bytearray, range, torch.Tensor, np.ndarray))
+        return isinstance(
+            value, (list, tuple, set, dict, bytes, bytearray, range, torch.Tensor, np.ndarray)
+        )
 
 
 class OperatorPrimitives(Primitive):
@@ -47,14 +53,20 @@ class OperatorPrimitives(Primitive):
             other = self._to_type(other)
         # None shortcut
         if not self.__disable_none_shortcut__ and (self.value is None or other.value is None):
-            UserMessage(f"unsupported {self._symbol_type.__class__} value operand type(s) for {op}: '{type(self.value)}' and '{type(other.value)}'", raise_with=TypeError)
+            UserMessage(
+                f"unsupported {self._symbol_type.__class__} value operand type(s) for {op}: '{type(self.value)}' and '{type(other.value)}'",
+                raise_with=TypeError,
+            )
         # try type specific function
         try:
             # try type specific function
             value = func(self, other)
             if value is NotImplemented:
-                operation = '' if op is None else op
-                UserMessage(f"unsupported {self._symbol_type.__class__} value operand type(s) for {operation}: '{type(self.value)}' and '{type(other.value)}'", raise_with=TypeError)
+                operation = "" if op is None else op
+                UserMessage(
+                    f"unsupported {self._symbol_type.__class__} value operand type(s) for {operation}: '{type(self.value)}' and '{type(other.value)}'",
+                    raise_with=TypeError,
+                )
             return value
         except Exception as ex:
             self._metadata._error = ex
@@ -62,20 +74,23 @@ class OperatorPrimitives(Primitive):
         return None
 
     def __throw_error_on_nesy_engine_call(self, func):
-        '''
+        """
         This function raises an error if the neuro-symbolic engine is disabled.
-        '''
+        """
         if self.__disable_nesy_engine__:
-            UserMessage(f"unsupported {self.__class__} value operand type(s) for {func.__name__}: '{type(self.value)}'", raise_with=TypeError)
+            UserMessage(
+                f"unsupported {self.__class__} value operand type(s) for {func.__name__}: '{type(self.value)}'",
+                raise_with=TypeError,
+            )
 
     def __bool__(self) -> bool:
-        '''
+        """
         Get the boolean value of the Symbol.
         If the Symbol's value is of type 'bool', the method returns the boolean value, otherwise it returns False.
 
         Returns:
             bool: The boolean value of the Symbol.
-        '''
+        """
         val = False
         if isinstance(self.value, bool):
             val = self.value
@@ -84,12 +99,13 @@ class OperatorPrimitives(Primitive):
 
         return val
 
-    '''
+    """
     This mixin contains functions that perform arithmetic operations on symbols or symbol values.
     The functions in this mixin are bound to the 'neurosymbolic' engine for evaluation.
-    '''
+    """
+
     def __contains__(self, other: Any) -> bool:
-        '''
+        """
         Check if a Symbol object is present in another Symbol object.
         By default, if 'other' is not a Symbol, it's casted to a Symbol object.
 
@@ -98,10 +114,12 @@ class OperatorPrimitives(Primitive):
 
         Returns:
             bool: True if the current Symbol contains the 'other' Symbol, otherwise False.
-        '''
-        result = self.__try_type_specific_func(other, lambda self, other: other.value in self.value, op='in')
+        """
+        result = self.__try_type_specific_func(
+            other, lambda self, other: other.value in self.value, op="in"
+        )
 
-        if not self.__semantic__ and not getattr(other, '__semantic__', False):
+        if not self.__semantic__ and not getattr(other, "__semantic__", False):
             return result
 
         self.__throw_error_on_nesy_engine_call(self.__contains__)
@@ -113,7 +131,7 @@ class OperatorPrimitives(Primitive):
         return self._to_type(_func(self, other))
 
     def __eq__(self, other: Any) -> bool:
-        '''
+        """
         Check if the current Symbol is equal to another Symbol.
         By default, if 'other' is not a Symbol, it's casted to a Symbol object.
 
@@ -122,13 +140,15 @@ class OperatorPrimitives(Primitive):
 
         Returns:
             bool: True if the current Symbol is equal to the 'other' Symbol, otherwise False.
-        '''
+        """
         if self is other:
             return True
 
-        result = self.__try_type_specific_func(other, lambda self, other: self.value == other.value, op='==')
+        result = self.__try_type_specific_func(
+            other, lambda self, other: self.value == other.value, op="=="
+        )
 
-        if not self.__semantic__ and not getattr(other, '__semantic__', False):
+        if not self.__semantic__ and not getattr(other, "__semantic__", False):
             return self._to_type(result)
 
         self.__throw_error_on_nesy_engine_call(self.__eq__)
@@ -140,7 +160,7 @@ class OperatorPrimitives(Primitive):
         return self._to_type(_func(self, other))
 
     def __ne__(self, other: Any) -> bool:
-        '''
+        """
         This method checks if a Symbol object is not equal to another Symbol by using the __eq__ method.
         By default, if 'other' is not a Symbol, it's casted to a Symbol object.
 
@@ -149,16 +169,18 @@ class OperatorPrimitives(Primitive):
 
         Returns:
             bool: True if the current Symbol is not equal to the 'other' Symbol, otherwise False.
-        '''
-        result = self.__try_type_specific_func(other, lambda self, other:  self.value != other.value, op='!=')
+        """
+        result = self.__try_type_specific_func(
+            other, lambda self, other: self.value != other.value, op="!="
+        )
 
-        if not self.__semantic__ and not getattr(other, '__semantic__', False):
+        if not self.__semantic__ and not getattr(other, "__semantic__", False):
             return result
 
         return not self.__eq__(other)
 
     def __gt__(self, other: Any) -> bool:
-        '''
+        """
         This method checks if a Symbol object is greater than another Symbol using the @core.compare() decorator with the '>' operator.
         By default, if 'other' is not a Symbol, it's casted to a Symbol object.
 
@@ -167,22 +189,24 @@ class OperatorPrimitives(Primitive):
 
         Returns:
             bool: True if the current Symbol is greater than the 'other' Symbol, otherwise False.
-        '''
-        result = self.__try_type_specific_func(other, lambda self, other: self.value > other.value, op='>')
+        """
+        result = self.__try_type_specific_func(
+            other, lambda self, other: self.value > other.value, op=">"
+        )
 
-        if not self.__semantic__ and not getattr(other, '__semantic__', False):
+        if not self.__semantic__ and not getattr(other, "__semantic__", False):
             return self._to_type(result)
 
         self.__throw_error_on_nesy_engine_call(self.__gt__)
 
-        @core.compare(operator='>')
+        @core.compare(operator=">")
         def _func(_, other) -> bool:
             pass
 
         return self._to_type(_func(self, other))
 
     def __lt__(self, other: Any) -> bool:
-        '''
+        """
         This method checks if a Symbol object is less than another Symbol using the @core.compare() decorator with the '<' operator.
         By default, if 'other' is not a Symbol, it's casted to a Symbol object.
 
@@ -191,22 +215,24 @@ class OperatorPrimitives(Primitive):
 
         Returns:
             bool: True if the current Symbol is less than the 'other' Symbol, otherwise False.
-        '''
-        result = self.__try_type_specific_func(other, lambda self, other: self.value < other.value, op='<')
+        """
+        result = self.__try_type_specific_func(
+            other, lambda self, other: self.value < other.value, op="<"
+        )
 
-        if not self.__semantic__ and not getattr(other, '__semantic__', False):
+        if not self.__semantic__ and not getattr(other, "__semantic__", False):
             return self._to_type(result)
 
         self.__throw_error_on_nesy_engine_call(self.__lt__)
 
-        @core.compare(operator='<')
+        @core.compare(operator="<")
         def _func(_, other) -> bool:
             pass
 
         return self._to_type(_func(self, other))
 
     def __le__(self, other) -> bool:
-        '''
+        """
         This method checks if a Symbol object is less than or equal to another Symbol using the @core.compare() decorator with the '<=' operator.
         By default, if 'other' is not a Symbol, it's casted to a Symbol object.
 
@@ -215,22 +241,24 @@ class OperatorPrimitives(Primitive):
 
         Returns:
             bool: True if the current Symbol is less than or equal to the 'other' Symbol, otherwise False.
-        '''
-        result = self.__try_type_specific_func(other, lambda self, other: self.value <= other.value, op='<=')
+        """
+        result = self.__try_type_specific_func(
+            other, lambda self, other: self.value <= other.value, op="<="
+        )
 
-        if not self.__semantic__ and not getattr(other, '__semantic__', False):
+        if not self.__semantic__ and not getattr(other, "__semantic__", False):
             return self._to_type(result)
 
         self.__throw_error_on_nesy_engine_call(self.__le__)
 
-        @core.compare(operator='<=')
+        @core.compare(operator="<=")
         def _func(_, other) -> bool:
             pass
 
         return self._to_type(_func(self, other))
 
     def __ge__(self, other) -> bool:
-        '''
+        """
         This method checks if a Symbol object is greater than or equal to another Symbol using the @core.compare() decorator with the '>=' operator.
         By default, if 'other' is not a Symbol, it's casted to a Symbol object.
 
@@ -239,29 +267,31 @@ class OperatorPrimitives(Primitive):
 
         Returns:
             bool: True if the current Symbol is greater than or equal to the 'other' Symbol, otherwise False.
-        '''
-        result = self.__try_type_specific_func(other, lambda self, other: self.value >= other.value, op='>=')
+        """
+        result = self.__try_type_specific_func(
+            other, lambda self, other: self.value >= other.value, op=">="
+        )
 
-        if not self.__semantic__ and not getattr(other, '__semantic__', False):
+        if not self.__semantic__ and not getattr(other, "__semantic__", False):
             return self._to_type(result)
 
         self.__throw_error_on_nesy_engine_call(self.__ge__)
 
-        @core.compare(operator='>=')
+        @core.compare(operator=">=")
         def _func(_, other) -> bool:
             pass
 
         return self._to_type(_func(self, other))
 
-    def __neg__(self) -> 'Symbol':
-        '''
+    def __neg__(self) -> "Symbol":
+        """
         Return the negated value of the Symbol.
         The method uses the @core.negate decorator to compute the negation of the Symbol value.
 
         Returns:
             Symbol: The negated value of the Symbol.
-        '''
-        result = self.__try_type_specific_func(False, lambda self, _: -self.value, op='-')
+        """
+        result = self.__try_type_specific_func(False, lambda self, _: -self.value, op="-")
 
         if not self.__semantic__:
             return self._to_type(result)
@@ -274,19 +304,19 @@ class OperatorPrimitives(Primitive):
 
         return self._to_type(_func(self))
 
-    def __invert__(self) -> 'Symbol':
-        '''
+    def __invert__(self) -> "Symbol":
+        """
         Return the inverted value of the Symbol (logical NOT).
         The method uses the @core.invert decorator to compute the inversion of the Symbol value.
         This allows using the ~ operator for semantic inversion.
 
         Returns:
             Symbol: The negated value of the Symbol.
-        '''
+        """
         if isinstance(self.value, bool):
             return self._to_type(not self.value)
 
-        result = self.__try_type_specific_func(False, lambda self, _: ~self.value, op='~')
+        result = self.__try_type_specific_func(False, lambda self, _: ~self.value, op="~")
 
         if not self.__semantic__:
             return self._to_type(result)
@@ -299,8 +329,8 @@ class OperatorPrimitives(Primitive):
 
         return self._to_type(_func(self))
 
-    def __lshift__(self, other: Any) -> 'Symbol':
-        '''
+    def __lshift__(self, other: Any) -> "Symbol":
+        """
         Add new information to the Symbol.
         The method uses the @core.include decorator to incorporate information into the Symbol.
 
@@ -309,10 +339,12 @@ class OperatorPrimitives(Primitive):
 
         Returns:
             Symbol: The Symbol with the new information included.
-        '''
-        result = self.__try_type_specific_func(other, lambda self, other: self.value << other.value, op='<<')
+        """
+        result = self.__try_type_specific_func(
+            other, lambda self, other: self.value << other.value, op="<<"
+        )
 
-        if not self.__semantic__ and not getattr(other, '__semantic__', False):
+        if not self.__semantic__ and not getattr(other, "__semantic__", False):
             return self._to_type(result)
 
         self.__throw_error_on_nesy_engine_call(self.__lshift__)
@@ -323,8 +355,8 @@ class OperatorPrimitives(Primitive):
 
         return self._to_type(_func(self, other))
 
-    def __rlshift__(self, other: Any) -> 'Symbol':
-        '''
+    def __rlshift__(self, other: Any) -> "Symbol":
+        """
         Add new information to the Symbol.
         The method uses the @core.include decorator to incorporate information into the Symbol.
 
@@ -333,10 +365,12 @@ class OperatorPrimitives(Primitive):
 
         Returns:
             Symbol: The Symbol with the new information included.
-        '''
-        result = self.__try_type_specific_func(other, lambda self, other: other.value << self.value, op='<<')
+        """
+        result = self.__try_type_specific_func(
+            other, lambda self, other: other.value << self.value, op="<<"
+        )
 
-        if not self.__semantic__ and not getattr(other, '__semantic__', False):
+        if not self.__semantic__ and not getattr(other, "__semantic__", False):
             return self._to_type(result)
 
         self.__throw_error_on_nesy_engine_call(self.__rlshift__)
@@ -347,8 +381,8 @@ class OperatorPrimitives(Primitive):
 
         return self._to_type(_func(self, other))
 
-    def __ilshift__(self, other: Any) -> 'Symbol':
-        '''
+    def __ilshift__(self, other: Any) -> "Symbol":
+        """
         Add new information to the Symbol.
         The method uses the @core.include decorator to incorporate information into the Symbol.
 
@@ -357,10 +391,12 @@ class OperatorPrimitives(Primitive):
 
         Returns:
             Symbol: The Symbol with the new information included.
-        '''
-        result = self.__try_type_specific_func(other, lambda self, other: self.value << other.value, op='<<=')
+        """
+        result = self.__try_type_specific_func(
+            other, lambda self, other: self.value << other.value, op="<<="
+        )
 
-        if not self.__semantic__ and not getattr(other, '__semantic__', False):
+        if not self.__semantic__ and not getattr(other, "__semantic__", False):
             self._value = result
             return self
 
@@ -369,12 +405,13 @@ class OperatorPrimitives(Primitive):
         @core.include()
         def _func(_, information: str):
             pass
+
         self._value = _func(self, other)
 
         return self
 
-    def __rshift__(self, other: Any) -> 'Symbol':
-        '''
+    def __rshift__(self, other: Any) -> "Symbol":
+        """
         Add new information to the Symbol.
         The method uses the @core.include decorator to incorporate information into the Symbol.
 
@@ -383,10 +420,12 @@ class OperatorPrimitives(Primitive):
 
         Returns:
             Symbol: The Symbol with the new information included.
-        '''
-        result = self.__try_type_specific_func(other, lambda self, other: self.value >> other.value, op='>>')
+        """
+        result = self.__try_type_specific_func(
+            other, lambda self, other: self.value >> other.value, op=">>"
+        )
 
-        if not self.__semantic__ and not getattr(other, '__semantic__', False):
+        if not self.__semantic__ and not getattr(other, "__semantic__", False):
             return self._to_type(result)
 
         self.__throw_error_on_nesy_engine_call(self.__rshift__)
@@ -397,8 +436,8 @@ class OperatorPrimitives(Primitive):
 
         return self._to_type(_func(self, other))
 
-    def __rrshift__(self, other: Any) -> 'Symbol':
-        '''
+    def __rrshift__(self, other: Any) -> "Symbol":
+        """
         Add new information to the Symbol.
         The method uses the @core.include decorator to incorporate information into the Symbol.
 
@@ -407,10 +446,12 @@ class OperatorPrimitives(Primitive):
 
         Returns:
             Symbol: The Symbol with the new information included.
-        '''
-        result = self.__try_type_specific_func(other, lambda self, other: other.value >> self.value, op='>>')
+        """
+        result = self.__try_type_specific_func(
+            other, lambda self, other: other.value >> self.value, op=">>"
+        )
 
-        if not self.__semantic__ and not getattr(other, '__semantic__', False):
+        if not self.__semantic__ and not getattr(other, "__semantic__", False):
             return self._to_type(result)
 
         self.__throw_error_on_nesy_engine_call(self.__rrshift__)
@@ -421,8 +462,8 @@ class OperatorPrimitives(Primitive):
 
         return self._to_type(_func(self, other))
 
-    def __irshift__(self, other: Any) -> 'Symbol':
-        '''
+    def __irshift__(self, other: Any) -> "Symbol":
+        """
         Add new information to the Symbol.
         The method uses the @core.include decorator to incorporate information into the Symbol.
 
@@ -431,10 +472,12 @@ class OperatorPrimitives(Primitive):
 
         Returns:
             Symbol: The Symbol with the new information included.
-        '''
-        result = self.__try_type_specific_func(other, lambda self, other: self.value >> other.value, op='>>=')
+        """
+        result = self.__try_type_specific_func(
+            other, lambda self, other: self.value >> other.value, op=">>="
+        )
 
-        if not self.__semantic__ and not getattr(other, '__semantic__', False):
+        if not self.__semantic__ and not getattr(other, "__semantic__", False):
             self._value = result
             return self
 
@@ -443,12 +486,13 @@ class OperatorPrimitives(Primitive):
         @core.include()
         def _func(_, information: str):
             pass
+
         self._value = _func(self, other)
 
         return self
 
-    def __add__(self, other: Any) -> 'Symbol':
-        '''
+    def __add__(self, other: Any) -> "Symbol":
+        """
         Combine the Symbol with another value.
         By default, if 'other' is not a Symbol, it's casted to a Symbol object.
         The method uses the @core.combine decorator to merge the Symbol and the other value.
@@ -458,10 +502,12 @@ class OperatorPrimitives(Primitive):
 
         Returns:
             Symbol: The Symbol combined with the other value.
-        '''
-        result = self.__try_type_specific_func(other, lambda self, other: self.value + other.value, op='+')
+        """
+        result = self.__try_type_specific_func(
+            other, lambda self, other: self.value + other.value, op="+"
+        )
 
-        if not self.__semantic__ and not getattr(other, '__semantic__', False):
+        if not self.__semantic__ and not getattr(other, "__semantic__", False):
             return self._to_type(result)
 
         self.__throw_error_on_nesy_engine_call(self.__add__)
@@ -472,8 +518,8 @@ class OperatorPrimitives(Primitive):
 
         return self._to_type(_func(self, other))
 
-    def __radd__(self, other) -> 'Symbol':
-        '''
+    def __radd__(self, other) -> "Symbol":
+        """
         Combine another value with the Symbol.
         By default, if 'other' is not a Symbol, it's casted to a Symbol object.
         The method uses the @core.combine decorator to merge the other value and the Symbol.
@@ -483,10 +529,12 @@ class OperatorPrimitives(Primitive):
 
         Returns:
             Symbol: The other value combined with the Symbol.
-        '''
-        result = self.__try_type_specific_func(other, lambda self, other: other.value + self.value, op='+')
+        """
+        result = self.__try_type_specific_func(
+            other, lambda self, other: other.value + self.value, op="+"
+        )
 
-        if not self.__semantic__ and not getattr(other, '__semantic__', False):
+        if not self.__semantic__ and not getattr(other, "__semantic__", False):
             return self._to_type(result)
 
         self.__throw_error_on_nesy_engine_call(self.__radd__)
@@ -497,8 +545,8 @@ class OperatorPrimitives(Primitive):
 
         return self._to_type(_func(other, self))
 
-    def __iadd__(self, other: Any) -> 'Symbol':
-        '''
+    def __iadd__(self, other: Any) -> "Symbol":
+        """
         This method adds another value to the Symbol and updates its value with the result.
         By default, if 'other' is not a Symbol, it's casted to a Symbol object.
 
@@ -507,10 +555,12 @@ class OperatorPrimitives(Primitive):
 
         Returns:
             Symbol: The updated Symbol with the added value.
-        '''
-        result = self.__try_type_specific_func(other, lambda self, other: self.value + other.value, op='+=')
+        """
+        result = self.__try_type_specific_func(
+            other, lambda self, other: self.value + other.value, op="+="
+        )
 
-        if not self.__semantic__ and not getattr(other, '__semantic__', False):
+        if not self.__semantic__ and not getattr(other, "__semantic__", False):
             self._value = result
             return self
         other = self._to_type(other)
@@ -518,8 +568,8 @@ class OperatorPrimitives(Primitive):
 
         return self
 
-    def __sub__(self, other: Any) -> 'Symbol':
-        '''
+    def __sub__(self, other: Any) -> "Symbol":
+        """
         Replace occurrences of a value with another value in the Symbol.
         By default, if 'other' is not a Symbol, it's casted to a Symbol object.
         The method uses the @core.replace decorator to replace occurrences of the other value with an empty string in the Symbol.
@@ -529,10 +579,12 @@ class OperatorPrimitives(Primitive):
 
         Returns:
             Symbol: The Symbol with occurrences of the other value replaced with an empty string.
-        '''
-        result = self.__try_type_specific_func(other, lambda self, other: self.value - other.value, op='-')
+        """
+        result = self.__try_type_specific_func(
+            other, lambda self, other: self.value - other.value, op="-"
+        )
 
-        if not self.__semantic__ and not getattr(other, '__semantic__', False):
+        if not self.__semantic__ and not getattr(other, "__semantic__", False):
             return self._to_type(result)
 
         self.__throw_error_on_nesy_engine_call(self.__sub__)
@@ -541,10 +593,10 @@ class OperatorPrimitives(Primitive):
         def _func(_, text: str, replace: str, value: str):
             pass
 
-        return self._to_type(_func(self, other, ''))
+        return self._to_type(_func(self, other, ""))
 
-    def __rsub__(self, other: Any) -> 'Symbol':
-        '''
+    def __rsub__(self, other: Any) -> "Symbol":
+        """
         Subtracts the symbol value from another one and removes the substrings that match the symbol value.
         By default, if 'other' is not a Symbol, it's casted to a Symbol object.
         Using the core.replace decorator, this function creates a _func method to remove matching substrings.
@@ -554,10 +606,12 @@ class OperatorPrimitives(Primitive):
 
         Returns:
             Symbol: A new symbol with the result of the subtraction.
-        '''
-        result = self.__try_type_specific_func(other, lambda self, other: other.value - self.value, op='-')
+        """
+        result = self.__try_type_specific_func(
+            other, lambda self, other: other.value - self.value, op="-"
+        )
 
-        if not self.__semantic__ and not getattr(other, '__semantic__', False):
+        if not self.__semantic__ and not getattr(other, "__semantic__", False):
             return self._to_type(result)
 
         self.__throw_error_on_nesy_engine_call(self.__rsub__)
@@ -565,12 +619,13 @@ class OperatorPrimitives(Primitive):
         @core.replace()
         def _func(_, text: str, replace: str, value: str):
             pass
+
         other = self._to_type(other)
 
-        return self._to_type(_func(other, self, ''))
+        return self._to_type(_func(other, self, ""))
 
-    def __isub__(self, other: Any) -> 'Symbol':
-        '''
+    def __isub__(self, other: Any) -> "Symbol":
+        """
         In-place subtraction of the symbol value by the other symbol value.
         By default, if 'other' is not a Symbol, it's casted to a Symbol object.
 
@@ -579,10 +634,12 @@ class OperatorPrimitives(Primitive):
 
         Returns:
             Symbol: The current symbol with the updated value.
-        '''
-        result = self.__try_type_specific_func(other, lambda self, other: self.value - other.value, op='-=')
+        """
+        result = self.__try_type_specific_func(
+            other, lambda self, other: self.value - other.value, op="-="
+        )
 
-        if not self.__semantic__ and not getattr(other, '__semantic__', False):
+        if not self.__semantic__ and not getattr(other, "__semantic__", False):
             self._value = result
             return self
         val = self.__sub__(other)
@@ -591,7 +648,7 @@ class OperatorPrimitives(Primitive):
         return self
 
     def __and__(self, other: Any) -> Any:
-        '''
+        """
         Performs a logical AND operation between the symbol value and another.
         By default, if 'other' is not a Symbol, it's casted to a Symbol object.
         Uses the core.logic decorator with operator='and' to create a _func method for the AND operation.
@@ -601,22 +658,24 @@ class OperatorPrimitives(Primitive):
 
         Returns:
             Symbol: A new symbol with the result of the AND operation.
-        '''
-        result = self.__try_type_specific_func(other, lambda self, other: self.value & other.value, op='&')
+        """
+        result = self.__try_type_specific_func(
+            other, lambda self, other: self.value & other.value, op="&"
+        )
 
-        if not self.__semantic__ and not getattr(other, '__semantic__', False):
+        if not self.__semantic__ and not getattr(other, "__semantic__", False):
             return self._to_type(result)
 
         self.__throw_error_on_nesy_engine_call(self.__and__)
 
-        @core.logic(operator='and')
+        @core.logic(operator="and")
         def _func(_, a: str, b: str):
             pass
 
         return self._to_type(_func(self, other))
 
     def __rand__(self, other: Any) -> Any:
-        '''
+        """
         Performs a logical AND operation between the symbol value and another.
         By default, if 'other' is not a Symbol, it's casted to a Symbol object.
         Uses the core.logic decorator with operator='and' to create a _func method for the AND operation.
@@ -626,23 +685,26 @@ class OperatorPrimitives(Primitive):
 
         Returns:
             Symbol: A new symbol with the result of the AND operation.
-        '''
-        result = self.__try_type_specific_func(other, lambda self, other:  other.value & self.value, op='&')
+        """
+        result = self.__try_type_specific_func(
+            other, lambda self, other: other.value & self.value, op="&"
+        )
 
-        if not self.__semantic__ and not getattr(other, '__semantic__', False):
+        if not self.__semantic__ and not getattr(other, "__semantic__", False):
             return self._to_type(result)
 
         self.__throw_error_on_nesy_engine_call(self.__rand__)
 
-        @core.logic(operator='and')
+        @core.logic(operator="and")
         def _func(_, a: str, b: str):
             pass
+
         other = self._to_type(other)
 
         return self._to_type(_func(other, self))
 
     def __iand__(self, other: Any) -> Any:
-        '''
+        """
         Performs a logical AND operation between the symbol value and another.
         By default, if 'other' is not a Symbol, it's casted to a Symbol object.
         Uses the core.logic decorator with operator='and' to create a _func method for the AND operation.
@@ -652,24 +714,27 @@ class OperatorPrimitives(Primitive):
 
         Returns:
             Symbol: A new symbol with the result of the AND operation.
-        '''
-        result = self.__try_type_specific_func(other, lambda self, other: self.value & other.value, op='&=')
+        """
+        result = self.__try_type_specific_func(
+            other, lambda self, other: self.value & other.value, op="&="
+        )
 
-        if not self.__semantic__ and not getattr(other, '__semantic__', False):
+        if not self.__semantic__ and not getattr(other, "__semantic__", False):
             self._value = result
             return self
 
         self.__throw_error_on_nesy_engine_call(self.__iand__)
 
-        @core.logic(operator='and')
+        @core.logic(operator="and")
         def _func(_, a: str, b: str):
             pass
+
         self._value = _func(self, other)
 
         return self
 
     def __or__(self, other: Any) -> Any:
-        '''
+        """
         Performs a logical OR operation between the symbol value and another.
         By default, if 'other' is not a Symbol, it's casted to a Symbol object.
         Uses the core.logic decorator with operator='or' to create a _func method for the OR operation.
@@ -679,27 +744,30 @@ class OperatorPrimitives(Primitive):
 
         Returns:
             Symbol: A new symbol with the result of the OR operation.
-        '''
+        """
         # Exclude the evaluation for the Aggregator class; keep import local to avoid ops.primitives <-> collect.stats cycle.
-        from ..collect.stats import Aggregator # noqa
+        from ..collect.stats import Aggregator  # noqa
+
         if isinstance(other, Aggregator):
             return NotImplemented
 
-        result = self.__try_type_specific_func(other, lambda self, other: self.value | other.value, op='|')
+        result = self.__try_type_specific_func(
+            other, lambda self, other: self.value | other.value, op="|"
+        )
 
-        if not self.__semantic__ and not getattr(other, '__semantic__', False):
+        if not self.__semantic__ and not getattr(other, "__semantic__", False):
             return self._to_type(result)
 
         self.__throw_error_on_nesy_engine_call(self.__or__)
 
-        @core.logic(operator='or')
+        @core.logic(operator="or")
         def _func(_, a: str, b: str):
             pass
 
         return self._to_type(_func(self, other))
 
-    def __ror__(self, other: Any) -> 'Symbol':
-        '''
+    def __ror__(self, other: Any) -> "Symbol":
+        """
         Performs a logical OR operation between the symbol value and another.
         By default, if 'other' is not a Symbol, it's casted to a Symbol object.
 
@@ -708,28 +776,32 @@ class OperatorPrimitives(Primitive):
 
         Returns:
             Symbol: A new Symbol object with the concatenated value.
-        '''
+        """
         # Exclude the evaluation for the Aggregator class; keep import local to avoid ops.primitives <-> collect.stats cycle.
-        from ..collect.stats import Aggregator # noqa
+        from ..collect.stats import Aggregator  # noqa
+
         if isinstance(other, Aggregator):
             return NotImplemented
 
-        result = self.__try_type_specific_func(other, lambda self, other: self.value | other.value, op='|')
+        result = self.__try_type_specific_func(
+            other, lambda self, other: self.value | other.value, op="|"
+        )
 
-        if not self.__semantic__ and not getattr(other, '__semantic__', False):
+        if not self.__semantic__ and not getattr(other, "__semantic__", False):
             return self._to_type(result)
 
         self.__throw_error_on_nesy_engine_call(self.__ror__)
 
-        @core.logic(operator='or')
+        @core.logic(operator="or")
         def _func(a: str, b: str):
             pass
+
         other = self._to_type(other)
 
         return self._to_type(_func(other, self))
 
-    def __ior__(self, other: Any) -> 'Symbol':
-        '''
+    def __ior__(self, other: Any) -> "Symbol":
+        """
         Performs a logical OR operation between the symbol value and another.
         By default, if 'other' is not a Symbol, it's casted to a Symbol object.
 
@@ -738,30 +810,34 @@ class OperatorPrimitives(Primitive):
 
         Returns:
             Symbol: A new Symbol object with the concatenated value.
-        '''
+        """
         # Exclude the evaluation for the Aggregator class; keep import local to avoid ops.primitives <-> collect.stats cycle.
-        from ..collect.stats import Aggregator # noqa
+        from ..collect.stats import Aggregator  # noqa
+
         if isinstance(other, Aggregator):
             return NotImplemented
 
-        result = self.__try_type_specific_func(other, lambda self, other: self.value | other.value, op='|=')
+        result = self.__try_type_specific_func(
+            other, lambda self, other: self.value | other.value, op="|="
+        )
 
-        if not self.__semantic__ and not getattr(other, '__semantic__', False):
+        if not self.__semantic__ and not getattr(other, "__semantic__", False):
             self._value = result
             return self
         result = self._to_type(str(self) + str(other))
 
         self.__throw_error_on_nesy_engine_call(self.__ior__)
 
-        @core.logic(operator='or')
+        @core.logic(operator="or")
         def _func(_, a: str, b: str):
             pass
+
         self._value = _func(self, other)
 
         return self
 
     def __xor__(self, other: Any) -> Any:
-        '''
+        """
         Performs a logical XOR operation between the symbol value and another.
         By default, if 'other' is not a Symbol, it's casted to a Symbol object.
         Uses the core.logic decorator with operator='xor' to create a _func method for the XOR operation.
@@ -771,22 +847,24 @@ class OperatorPrimitives(Primitive):
 
         Returns:
             Symbol: A new symbol with the result of the XOR operation.
-        '''
-        result = self.__try_type_specific_func(other, lambda self, other: self.value ^ other.value, op='^')
+        """
+        result = self.__try_type_specific_func(
+            other, lambda self, other: self.value ^ other.value, op="^"
+        )
 
-        if not self.__semantic__ and not getattr(other, '__semantic__', False):
+        if not self.__semantic__ and not getattr(other, "__semantic__", False):
             return self._to_type(result)
 
         self.__throw_error_on_nesy_engine_call(self.__xor__)
 
-        @core.logic(operator='xor')
+        @core.logic(operator="xor")
         def _func(_, a: str, b: str):
             pass
 
         return self._to_type(_func(self, other))
 
-    def __rxor__(self, other: Any) -> 'Symbol':
-        '''
+    def __rxor__(self, other: Any) -> "Symbol":
+        """
         Performs a logical XOR operation between the symbol value and another.
         By default, if 'other' is not a Symbol, it's casted to a Symbol object.
         Uses the core.logic decorator with operator='xor' to create a _func method for the XOR operation.
@@ -796,22 +874,24 @@ class OperatorPrimitives(Primitive):
 
         Returns:
             Symbol: A new symbol with the result of the XOR operation.
-        '''
-        result = self.__try_type_specific_func(other, lambda self, other: other.value ^ self.value, op='^')
+        """
+        result = self.__try_type_specific_func(
+            other, lambda self, other: other.value ^ self.value, op="^"
+        )
 
-        if not self.__semantic__ and not getattr(other, '__semantic__', False):
+        if not self.__semantic__ and not getattr(other, "__semantic__", False):
             return self._to_type(result)
 
         self.__throw_error_on_nesy_engine_call(self.__rxor__)
 
-        @core.logic(operator='xor')
+        @core.logic(operator="xor")
         def _func(_, a: str, b: str):
             pass
 
         return self._to_type(_func(other, self))
 
-    def __ixor__(self, other: Any) -> 'Symbol':
-        '''
+    def __ixor__(self, other: Any) -> "Symbol":
+        """
         Performs a logical XOR operation between the symbol value and another.
         By default, if 'other' is not a Symbol, it's casted to a Symbol object.
         Uses the core.logic decorator with operator='xor' to create a _func method for the XOR operation.
@@ -821,24 +901,27 @@ class OperatorPrimitives(Primitive):
 
         Returns:
             Symbol: A new symbol with the result of the XOR operation.
-        '''
-        result = self.__try_type_specific_func(other, lambda self, other: self.value ^ other.value, op='^=')
+        """
+        result = self.__try_type_specific_func(
+            other, lambda self, other: self.value ^ other.value, op="^="
+        )
 
-        if not self.__semantic__ and not getattr(other, '__semantic__', False):
+        if not self.__semantic__ and not getattr(other, "__semantic__", False):
             self._value = result
             return self
 
         self.__throw_error_on_nesy_engine_call(self.__ixor__)
 
-        @core.logic(operator='xor')
+        @core.logic(operator="xor")
         def _func(_, a: str, b: str):
             pass
+
         self._value = _func(self, other)
 
         return self
 
-    def __matmul__(self, other: Any) -> 'Symbol':
-        '''
+    def __matmul__(self, other: Any) -> "Symbol":
+        """
         This method concatenates the string representation of two Symbol objects and returns a new Symbol with the concatenated result.
         By default, if 'other' is not a Symbol, it's casted to a Symbol object.
 
@@ -847,16 +930,22 @@ class OperatorPrimitives(Primitive):
 
         Returns:
             Symbol: A new Symbol object with the concatenated value.
-        '''
-        if (isinstance(self.value, str) and isinstance(other, str)) or \
-            (isinstance(self.value, str) and isinstance(other, self._symbol_type) and isinstance(other.value, str)):
+        """
+        if (isinstance(self.value, str) and isinstance(other, str)) or (
+            isinstance(self.value, str)
+            and isinstance(other, self._symbol_type)
+            and isinstance(other.value, str)
+        ):
             other = self._to_type(other)
-            return self._to_type(f'{self.value}{other.value}')
-        UserMessage(f'This method is only supported for string concatenation! Got {type(self.value)} and {type(other)} instead.', raise_with=TypeError)
+            return self._to_type(f"{self.value}{other.value}")
+        UserMessage(
+            f"This method is only supported for string concatenation! Got {type(self.value)} and {type(other)} instead.",
+            raise_with=TypeError,
+        )
         return None
 
-    def __rmatmul__(self, other: Any) -> 'Symbol':
-        '''
+    def __rmatmul__(self, other: Any) -> "Symbol":
+        """
         This method concatenates the string representation of two Symbol objects in a reversed order and returns a new Symbol with the concatenated result.
         By default, if 'other' is not a Symbol, it's casted to a Symbol object.
 
@@ -865,13 +954,15 @@ class OperatorPrimitives(Primitive):
 
         Returns:
             Symbol: A new Symbol object with the concatenated value.
-        '''
-        result = self.__try_type_specific_func(other, lambda self, other:  self._to_type(self.value).__matmul__(other), op='@')
+        """
+        result = self.__try_type_specific_func(
+            other, lambda self, other: self._to_type(self.value).__matmul__(other), op="@"
+        )
 
         return self._to_type(result)
 
-    def __imatmul__(self, other: Any) -> 'Symbol':
-        '''
+    def __imatmul__(self, other: Any) -> "Symbol":
+        """
         This method concatenates the string representation of two Symbol objects and assigns the concatenated result to the value of the current Symbol object.
         By default, if 'other' is not a Symbol, it's casted to a Symbol object.
 
@@ -880,14 +971,16 @@ class OperatorPrimitives(Primitive):
 
         Returns:
             Symbol: The current Symbol object with the concatenated value.
-        '''
-        result = self.__try_type_specific_func(other, lambda self, other: self._to_type(self.value).__matmul__(other), op='@=')
+        """
+        result = self.__try_type_specific_func(
+            other, lambda self, other: self._to_type(self.value).__matmul__(other), op="@="
+        )
         self._value = result
 
         return self
 
-    def __truediv__(self, other: Any) -> 'Symbol':
-        '''
+    def __truediv__(self, other: Any) -> "Symbol":
+        """
         Divides the symbol value by another, splitting the symbol value by the other value.
         The string representation of the other value is used to split the symbol value.
 
@@ -896,15 +989,17 @@ class OperatorPrimitives(Primitive):
 
         Returns:
             Symbol: A new symbol with the result of the division.
-        '''
-        result = self.__try_type_specific_func(other, lambda self, other: self.value / other.value, op='/')
+        """
+        result = self.__try_type_specific_func(
+            other, lambda self, other: self.value / other.value, op="/"
+        )
         if result is not None:
             return self._to_type(result)
 
         return self._to_type(str(self).split(str(other)))
 
-    def __rtruediv__(self, other: Any) -> 'Symbol':
-        '''
+    def __rtruediv__(self, other: Any) -> "Symbol":
+        """
         Divides the symbol value by another, splitting the symbol value by the other value.
         The string representation of the other value is used to split the symbol value.
 
@@ -913,17 +1008,21 @@ class OperatorPrimitives(Primitive):
 
         Returns:
             Symbol: A new symbol with the result of the division.
-        '''
-        result = self.__try_type_specific_func(other, lambda self, other: other.value / self.value, op='/')
+        """
+        result = self.__try_type_specific_func(
+            other, lambda self, other: other.value / self.value, op="/"
+        )
         if result is not None:
             return self._to_type(result)
 
-        UserMessage('Division operation not supported semantically! Might change in the future.', raise_with=NotImplementedError)
+        UserMessage(
+            "Division operation not supported semantically! Might change in the future.",
+            raise_with=NotImplementedError,
+        )
         return None
 
-
-    def __itruediv__(self, other: Any) -> 'Symbol':
-        '''
+    def __itruediv__(self, other: Any) -> "Symbol":
+        """
         Divides the symbol value by another, splitting the symbol value by the other value.
         The string representation of the other value is used to split the symbol value.
 
@@ -932,18 +1031,22 @@ class OperatorPrimitives(Primitive):
 
         Returns:
             Symbol: A new symbol with the result of the division.
-        '''
-        result = self.__try_type_specific_func(other, lambda self, other: self.value / other.value, op='/=')
+        """
+        result = self.__try_type_specific_func(
+            other, lambda self, other: self.value / other.value, op="/="
+        )
         if result is not None:
             self._value = result
             return self
 
-        UserMessage('Division operation not supported semantically! Might change in the future.', raise_with=NotImplementedError)
+        UserMessage(
+            "Division operation not supported semantically! Might change in the future.",
+            raise_with=NotImplementedError,
+        )
         return None
 
-
-    def __floordiv__(self, other: Any) -> 'Symbol':
-        '''
+    def __floordiv__(self, other: Any) -> "Symbol":
+        """
         Floor divides the symbol value by another, splitting the symbol value by the other value.
         The string representation of the other value is used to split the symbol value.
 
@@ -952,16 +1055,21 @@ class OperatorPrimitives(Primitive):
 
         Returns:
             Symbol: A new symbol with the result of the division.
-        '''
-        result = self.__try_type_specific_func(other, lambda self, other: self.value // other.value, op='//')
+        """
+        result = self.__try_type_specific_func(
+            other, lambda self, other: self.value // other.value, op="//"
+        )
         if result is not None:
             return self._to_type(result)
 
-        UserMessage('Floor division operation not supported semantically! Might change in the future.', raise_with=NotImplementedError)
+        UserMessage(
+            "Floor division operation not supported semantically! Might change in the future.",
+            raise_with=NotImplementedError,
+        )
         return None
 
-    def __rfloordiv__(self, other: Any) -> 'Symbol':
-        '''
+    def __rfloordiv__(self, other: Any) -> "Symbol":
+        """
         Floor divides the symbol value by another, splitting the symbol value by the other value.
         The string representation of the other value is used to split the symbol value.
 
@@ -970,16 +1078,21 @@ class OperatorPrimitives(Primitive):
 
         Returns:
             Symbol: A new symbol with the result of the division.
-        '''
-        result = self.__try_type_specific_func(other, lambda self, other: other.value // self.value, op='//')
+        """
+        result = self.__try_type_specific_func(
+            other, lambda self, other: other.value // self.value, op="//"
+        )
         if result is not None:
             return self._to_type(result)
 
-        UserMessage('Floor division operation not supported semantically! Might change in the future.', raise_with=NotImplementedError)
+        UserMessage(
+            "Floor division operation not supported semantically! Might change in the future.",
+            raise_with=NotImplementedError,
+        )
         return None
 
-    def __ifloordiv__(self, other: Any) -> 'Symbol':
-        '''
+    def __ifloordiv__(self, other: Any) -> "Symbol":
+        """
         Floor divides the symbol value by another, splitting the symbol value by the other value.
         The string representation of the other value is used to split the symbol value.
 
@@ -988,17 +1101,22 @@ class OperatorPrimitives(Primitive):
 
         Returns:
             Symbol: A new symbol with the result of the division.
-        '''
-        result = self.__try_type_specific_func(other, lambda self, other: self.value // other.value, op='//=')
+        """
+        result = self.__try_type_specific_func(
+            other, lambda self, other: self.value // other.value, op="//="
+        )
         if result is not None:
             self._value = result
             return self
 
-        UserMessage('Floor division operation not supported semantically! Might change in the future.', raise_with=NotImplementedError)
+        UserMessage(
+            "Floor division operation not supported semantically! Might change in the future.",
+            raise_with=NotImplementedError,
+        )
         return None
 
-    def __pow__(self, other: Any) -> 'Symbol':
-        '''
+    def __pow__(self, other: Any) -> "Symbol":
+        """
         Power operation on symbol value by another, splitting the symbol value by the other value.
         The string representation of the other value is used to split the symbol value.
 
@@ -1007,17 +1125,21 @@ class OperatorPrimitives(Primitive):
 
         Returns:
             Symbol: A new symbol with the result of the division.
-        '''
-        result = self.__try_type_specific_func(other, lambda self, other: self.value ** other.value, op='**')
+        """
+        result = self.__try_type_specific_func(
+            other, lambda self, other: self.value**other.value, op="**"
+        )
         if result is not None:
             return self._to_type(result)
 
-        UserMessage('Power operation not supported semantically! Might change in the future.', raise_with=NotImplementedError)
+        UserMessage(
+            "Power operation not supported semantically! Might change in the future.",
+            raise_with=NotImplementedError,
+        )
         return None
 
-
-    def __rpow__(self, other: Any) -> 'Symbol':
-        '''
+    def __rpow__(self, other: Any) -> "Symbol":
+        """
         Power operation on symbol value by another, splitting the symbol value by the other value.
         The string representation of the other value is used to split the symbol value.
 
@@ -1026,16 +1148,21 @@ class OperatorPrimitives(Primitive):
 
         Returns:
             Symbol: A new symbol with the result of the division.
-        '''
-        result = self.__try_type_specific_func(other, lambda self, other: other.value ** self.value, op='**')
+        """
+        result = self.__try_type_specific_func(
+            other, lambda self, other: other.value**self.value, op="**"
+        )
         if result is not None:
             return self._to_type(result)
 
-        UserMessage('Power operation not supported semantically! Might change in the future.', raise_with=NotImplementedError)
+        UserMessage(
+            "Power operation not supported semantically! Might change in the future.",
+            raise_with=NotImplementedError,
+        )
         return None
 
-    def __ipow__(self, other: Any) -> 'Symbol':
-        '''
+    def __ipow__(self, other: Any) -> "Symbol":
+        """
         Power operation on symbol value by another, splitting the symbol value by the other value.
         The string representation of the other value is used to split the symbol value.
 
@@ -1044,17 +1171,22 @@ class OperatorPrimitives(Primitive):
 
         Returns:
             Symbol: A new symbol with the result of the division.
-        '''
-        result = self.__try_type_specific_func(other, lambda self, other: self.value ** other.value, op='**=')
+        """
+        result = self.__try_type_specific_func(
+            other, lambda self, other: self.value**other.value, op="**="
+        )
         if result is not None:
             self._value = result
             return self
 
-        UserMessage('Power operation not supported semantically! Might change in the future.', raise_with=NotImplementedError)
+        UserMessage(
+            "Power operation not supported semantically! Might change in the future.",
+            raise_with=NotImplementedError,
+        )
         return None
 
-    def __mod__(self, other: Any) -> 'Symbol':
-        '''
+    def __mod__(self, other: Any) -> "Symbol":
+        """
         Modulo operation on symbol value by another, splitting the symbol value by the other value.
         The string representation of the other value is used to split the symbol value.
 
@@ -1063,16 +1195,21 @@ class OperatorPrimitives(Primitive):
 
         Returns:
             Symbol: A new symbol with the result of the division.
-        '''
-        result = self.__try_type_specific_func(other, lambda self, other: self.value % other.value, op='%')
+        """
+        result = self.__try_type_specific_func(
+            other, lambda self, other: self.value % other.value, op="%"
+        )
         if result is not None:
             return self._to_type(result)
 
-        UserMessage('Modulo operation not supported semantically! Might change in the future.', raise_with=NotImplementedError)
+        UserMessage(
+            "Modulo operation not supported semantically! Might change in the future.",
+            raise_with=NotImplementedError,
+        )
         return None
 
-    def __rmod__(self, other: Any) -> 'Symbol':
-        '''
+    def __rmod__(self, other: Any) -> "Symbol":
+        """
         Modulo operation on symbol value by another, splitting the symbol value by the other value.
         The string representation of the other value is used to split the symbol value.
 
@@ -1081,17 +1218,19 @@ class OperatorPrimitives(Primitive):
 
         Returns:
             Symbol: A new symbol with the result of the division.
-        '''
-        result = self.__try_type_specific_func(other, lambda self, other: other.value % self.value, op='%')
+        """
+        result = self.__try_type_specific_func(
+            other, lambda self, other: other.value % self.value, op="%"
+        )
         if result is not None:
             return self._to_type(result)
 
-        msg = 'Modulo operation not supported! Might change in the future.'
+        msg = "Modulo operation not supported! Might change in the future."
         UserMessage(msg)
         raise NotImplementedError(msg) from self._metadata._error
 
-    def __imod__(self, other: Any) -> 'Symbol':
-        '''
+    def __imod__(self, other: Any) -> "Symbol":
+        """
         Modulo operation on symbol value by another, splitting the symbol value by the other value.
         The string representation of the other value is used to split the symbol value.
 
@@ -1100,17 +1239,22 @@ class OperatorPrimitives(Primitive):
 
         Returns:
             Symbol: A new symbol with the result of the division.
-        '''
-        result = self.__try_type_specific_func(other, lambda self, other: self.value % other.value, op='%=')
+        """
+        result = self.__try_type_specific_func(
+            other, lambda self, other: self.value % other.value, op="%="
+        )
         if result is not None:
             self._value = result
             return self
 
-        UserMessage('Modulo operation not supported semantically! Might change in the future.', raise_with=NotImplementedError)
+        UserMessage(
+            "Modulo operation not supported semantically! Might change in the future.",
+            raise_with=NotImplementedError,
+        )
         return None
 
-    def __mul__(self, other: Any) -> 'Symbol':
-        '''
+    def __mul__(self, other: Any) -> "Symbol":
+        """
         Multiply operation on symbol value by another, splitting the symbol value by the other value.
         The string representation of the other value is used to split the symbol value.
 
@@ -1119,16 +1263,21 @@ class OperatorPrimitives(Primitive):
 
         Returns:
             Symbol: A new symbol with the result of the division.
-        '''
-        result = self.__try_type_specific_func(other, lambda self, other: self.value * other.value, op='*')
+        """
+        result = self.__try_type_specific_func(
+            other, lambda self, other: self.value * other.value, op="*"
+        )
         if result is not None:
             return self._to_type(result)
 
-        UserMessage('Multiply operation not supported semantically! Might change in the future.', raise_with=NotImplementedError)
+        UserMessage(
+            "Multiply operation not supported semantically! Might change in the future.",
+            raise_with=NotImplementedError,
+        )
         return None
 
-    def __rmul__(self, other: Any) -> 'Symbol':
-        '''
+    def __rmul__(self, other: Any) -> "Symbol":
+        """
         Multiply operation on symbol value by another, splitting the symbol value by the other value.
         The string representation of the other value is used to split the symbol value.
 
@@ -1137,16 +1286,21 @@ class OperatorPrimitives(Primitive):
 
         Returns:
             Symbol: A new symbol with the result of the division.
-        '''
-        result = self.__try_type_specific_func(other, lambda self, other: other.value * self.value, op='*')
+        """
+        result = self.__try_type_specific_func(
+            other, lambda self, other: other.value * self.value, op="*"
+        )
         if result is not None:
             return self._to_type(result)
 
-        UserMessage('Multiply operation not supported semantically! Might change in the future.', raise_with=NotImplementedError)
+        UserMessage(
+            "Multiply operation not supported semantically! Might change in the future.",
+            raise_with=NotImplementedError,
+        )
         return None
 
-    def __imul__(self, other: Any) -> 'Symbol':
-        '''
+    def __imul__(self, other: Any) -> "Symbol":
+        """
         Multiply operation on symbol value by another, splitting the symbol value by the other value.
         The string representation of the other value is used to split the symbol value.
 
@@ -1155,20 +1309,26 @@ class OperatorPrimitives(Primitive):
 
         Returns:
             Symbol: A new symbol with the result of the division.
-        '''
-        result = self.__try_type_specific_func(other, lambda self, other: self.value * other.value, op='*=')
+        """
+        result = self.__try_type_specific_func(
+            other, lambda self, other: self.value * other.value, op="*="
+        )
         if result is not None:
             self._value = result
             return self
 
-        UserMessage('Multiply operation not supported semantically! Might change in the future.', raise_with=NotImplementedError)
+        UserMessage(
+            "Multiply operation not supported semantically! Might change in the future.",
+            raise_with=NotImplementedError,
+        )
         return None
 
 
 class CastingPrimitives(Primitive):
-    '''
+    """
     This mixin contains functionalities related to casting symbols.
-    '''
+    """
+
     @property
     def syn(self) -> "Symbol":
         """
@@ -1189,7 +1349,7 @@ class CastingPrimitives(Primitive):
         return self._to_type(self.value, semantic=True)
 
     def cast(self, as_type: type) -> Any:
-        '''
+        """
         Cast the Symbol's value to a specific type.
 
         Args:
@@ -1197,11 +1357,11 @@ class CastingPrimitives(Primitive):
 
         Returns:
             The Symbol's value casted to the specified type.
-        '''
+        """
         return as_type(self.value)
 
     def to(self, as_type: type) -> Any:
-        '''
+        """
         Cast the Symbol's value to a specific type.
 
         Args:
@@ -1209,65 +1369,65 @@ class CastingPrimitives(Primitive):
 
         Returns:
             The Symbol's value casted to the specified type.
-        '''
+        """
         return self.cast(as_type)
 
     def ast(self) -> Any:
-        '''
+        """
         Converts the string representation of the Symbol's value to an abstract syntax tree using 'ast.literal_eval'.
 
         Returns:
             The abstract syntax tree representation of the Symbol's value.
-        '''
+        """
         return ast.literal_eval(str(self.value))
 
     def str(self) -> str:
-        '''
+        """
         Get the string representation of the Symbol's value.
 
         Returns:
             str: The string representation of the Symbol's value.
-        '''
+        """
         return str(self.value)
 
     def int(self) -> int:
-        '''
+        """
         Get the integer representation of the Symbol's value.
 
         Returns:
             int: The integer representation of the Symbol's value.
-        '''
+        """
         return int(self.value)
 
     def float(self) -> float:
-
-        '''
+        """
         Get the float representation of the Symbol's value.
 
         Returns:
             float: The float representation of the Symbol's value.
-        '''
+        """
         return float(self.value)
 
     def bool(self) -> bool:
-        '''
+        """
         Get the boolean representation of the Symbol's value.
 
         Returns:
             bool: The boolean representation of the Symbol's value.
-        '''
+        """
         return bool(self.value)
 
 
-#@TODO: We can do much better than asking the model to generate the entire thing. We can come up with a more structured way, e.g.,
+# @TODO: We can do much better than asking the model to generate the entire thing. We can come up with a more structured way, e.g.,
 #       using a JSON schema (or contracts) and return only the keys where we need to set/del information.
 class IterationPrimitives(Primitive):
-    '''
+    """
     This mixin contains functions that perform iteration operations on symbols or symbol values.
     The functions in this mixin are bound to the 'neurosymbolic' engine for evaluation.
-    '''
-    def __getitem__(self, key: str | int | slice) -> 'Symbol':
-        '''
+    """
+
+    def __getitem__(self, key: str | int | slice) -> "Symbol":
+        """
         Get the item of the Symbol value with the specified key or index.
         If the Symbol value is a list, tuple, or numpy array, the key can be an integer or slice.
         If the Symbol value is a dictionary, the key can be a string or an integer.
@@ -1281,12 +1441,12 @@ class IterationPrimitives(Primitive):
 
         Raises:
             KeyError: If the key or index is not found in the Symbol value.
-        '''
+        """
         if not self.__semantic__:
             try:
                 return self.value[key]
             except Exception:
-                UserMessage(f'Key {key} not found in {self.value}', raise_with=Exception)
+                UserMessage(f"Key {key} not found in {self.value}", raise_with=Exception)
 
         @core.getitem()
         def _func(_, index: str):
@@ -1295,7 +1455,7 @@ class IterationPrimitives(Primitive):
         return self._to_type(_func(self, key))
 
     def __setitem__(self, key: str | int | slice, value: Any) -> None:
-        '''
+        """
         Set the item of the Symbol value with the specified key or index to the given value.
         If the Symbol value is a list, the key can be an integer or slice.
         If the Symbol value is a dictionary, the key can be a string or an integer.
@@ -1307,19 +1467,22 @@ class IterationPrimitives(Primitive):
 
         Raises:
             KeyError: If the key or index is not found in the Symbol value.
-        '''
+        """
         # Local import avoids ops.primitives -> post_processors -> symbol -> ops circular load.
-        from ..post_processors import ASTPostProcessor # noqa
+        from ..post_processors import ASTPostProcessor  # noqa
 
         if not isinstance(self.value, (str, dict, list)):
-            UserMessage(f'Setting item is not supported for {type(self.value)}. Supported types are str, dict, and list.', raise_with=TypeError)
+            UserMessage(
+                f"Setting item is not supported for {type(self.value)}. Supported types are str, dict, and list.",
+                raise_with=TypeError,
+            )
 
         if not self.__semantic__:
             try:
                 self.value[key] = value
                 return
             except Exception:
-                UserMessage(f'Key {key} not found in {self.value}', raise_with=Exception)
+                UserMessage(f"Key {key} not found in {self.value}", raise_with=Exception)
 
         @core.setitem()
         def _func(_, index: str, value: str):
@@ -1327,12 +1490,16 @@ class IterationPrimitives(Primitive):
 
         result = _func(self, key, value)
         try:
-            self._value = ASTPostProcessor()(result) # The type of the object that the model changed was a list or a dict
+            self._value = ASTPostProcessor()(
+                result
+            )  # The type of the object that the model changed was a list or a dict
         except Exception:
-            self._value = result # It was a string, or something failed (because } wasn't close, etc)
+            self._value = (
+                result  # It was a string, or something failed (because } wasn't close, etc)
+            )
 
     def __delitem__(self, key: str | int) -> None:
-        '''
+        """
         Delete the item of the Symbol value with the specified key or index.
         If the Symbol value is a dictionary, the key can be a string or an integer.
         If the direct item deletion fails, the method falls back to using the @core.delitem decorator, which deletes the item using core functions.
@@ -1342,19 +1509,22 @@ class IterationPrimitives(Primitive):
 
         Raises:
             KeyError: If the key or index is not found in the Symbol value.
-        '''
+        """
         # Local import avoids ops.primitives -> post_processors -> symbol -> ops circular load.
-        from ..post_processors import ASTPostProcessor # noqa
+        from ..post_processors import ASTPostProcessor  # noqa
 
         if not isinstance(self.value, (str, dict, list)):
-            UserMessage(f'Setting item is not supported for {type(self.value)}. Supported types are str, dict, and list.', raise_with=TypeError)
+            UserMessage(
+                f"Setting item is not supported for {type(self.value)}. Supported types are str, dict, and list.",
+                raise_with=TypeError,
+            )
 
         if not self.__semantic__:
             try:
                 del self.value[key]
                 return
             except Exception:
-                UserMessage(f'Key {key} not found in {self.value}', raise_with=Exception)
+                UserMessage(f"Key {key} not found in {self.value}", raise_with=Exception)
 
         @core.delitem()
         def _func(_, index: str):
@@ -1362,70 +1532,76 @@ class IterationPrimitives(Primitive):
 
         result = _func(self, key)
         try:
-            self._value = ASTPostProcessor()(result) # The type of the object that the model changed was a list or a dict
+            self._value = ASTPostProcessor()(
+                result
+            )  # The type of the object that the model changed was a list or a dict
         except json.JSONDecodeError:
-            self._value = result # It was a string, or something failed (because } wasn't close, etc)
+            self._value = (
+                result  # It was a string, or something failed (because } wasn't close, etc)
+            )
+
 
-#@TODO: Add tests for this class
+# @TODO: Add tests for this class
 class ValueHandlingPrimitives(Primitive):
-    '''
+    """
     This mixin includes functions responsible for handling symbol values - tokenization, type retrieval, value casting, indexing, etc.
     Future functions might include different methods of processing or manipulating the values of symbols, working with metadata of values, etc.
-    '''
+    """
+
     @property
     def size(self) -> int:
-        '''
+        """
         Get the size of the container of the Symbol's value.
 
         Returns:
             int: The size of the container of the Symbol's value.
-        '''
+        """
         return len(self.value)
 
     @property
     def tokens(self) -> int:
-        '''
+        """
         Tokenize the Symbol's value using the tokenizer method.
         The tokenizer method is bound to the 'neurosymbolic' engine using the @decorator.bind() decorator.
 
         Returns:
             int: The tokenized value of the Symbol.
-        '''
+        """
         return self.tokenizer().encode(str(self))
 
-    @core_ext.bind(engine='neurosymbolic', property='tokenizer')
+    @core_ext.bind(engine="neurosymbolic", property="tokenizer")
     def tokenizer(self) -> Callable:
-        '''
+        """
         The tokenizer method.
         This method is bound to the 'neurosymbolic' engine using the @decorator.bind() decorator.
 
         Returns:
             Callable: The tokenizer.
-        '''
+        """
         pass
 
     @property
     def type(self):
-        '''
+        """
         Get the type of the Symbol.
 
         Returns:
             type: The type of the Symbol.
-        '''
+        """
         return type(self)
 
     @property
     def value_type(self):
-        '''
+        """
         Get the type of the Symbol's value.
 
         Returns:
             type: The type of the Symbol's value.
-        '''
+        """
         return type(self.value)
 
-    def index(self, item: str, **kwargs) -> 'Symbol':
-        '''
+    def index(self, item: str, **kwargs) -> "Symbol":
+        """
         Returns the index of a specified item in the symbol value.
         Uses the core.getitem decorator to create a _func method that finds the index of the item.
 
@@ -1434,19 +1610,22 @@ class ValueHandlingPrimitives(Primitive):
 
         Returns:
             Symbol: A new symbol with the index of the specified item.
-        '''
+        """
+
         @core.getitem(**kwargs)
         def _func(_, item: str) -> int:
             pass
+
         return self._to_type(_func(self, item))
 
 
 class StringHelperPrimitives(Primitive):
-    '''
+    """
     This mixin contains functions that provide additional help for symbols or their values.
-    '''
-    def split(self, delimiter: str, **_kwargs) -> 'Symbol':
-        '''
+    """
+
+    def split(self, delimiter: str, **_kwargs) -> "Symbol":
+        """
         Splits the symbol value by a specified delimiter.
         Uses the core.split decorator to create a _func method that splits the symbol value by the specified delimiter.
 
@@ -1455,13 +1634,13 @@ class StringHelperPrimitives(Primitive):
 
         Returns:
             Symbol: A new symbol with the split value.
-        '''
-        assert isinstance(delimiter, str), f'delimiter must be a string, got {type(delimiter)}'
-        assert isinstance(self.value, str), f'self.value must be a string, got {type(self.value)}'
+        """
+        assert isinstance(delimiter, str), f"delimiter must be a string, got {type(delimiter)}"
+        assert isinstance(self.value, str), f"self.value must be a string, got {type(self.value)}"
         return self._to_type([*self.value.split(delimiter)])
 
-    def join(self, delimiter: str = ' ', **_kwargs) -> 'Symbol':
-        '''
+    def join(self, delimiter: str = " ", **_kwargs) -> "Symbol":
+        """
         Joins the symbol value with a specified delimiter.
 
         Args:
@@ -1469,13 +1648,15 @@ class StringHelperPrimitives(Primitive):
 
         Returns:
             Symbol: A new symbol with the joined str value.
-        '''
-        assert isinstance(delimiter, str),f'delimiter must be a string, got {type(delimiter)}'
-        assert isinstance(self.value, Iterable), f'value must be an iterable, got {type(self.value)}'
+        """
+        assert isinstance(delimiter, str), f"delimiter must be a string, got {type(delimiter)}"
+        assert isinstance(self.value, Iterable), (
+            f"value must be an iterable, got {type(self.value)}"
+        )
         return self._to_type(delimiter.join(self.value))
 
     def startswith(self, prefix: str, **_kwargs) -> bool:
-        '''
+        """
         Checks if the symbol value starts with a specified prefix.
         Uses the core.startswith decorator to create a _func method that checks if the symbol value starts with the specified prefix.
 
@@ -1484,9 +1665,9 @@ class StringHelperPrimitives(Primitive):
 
         Returns:
             bool: True if the symbol value starts with the specified prefix, otherwise False.
-        '''
-        assert isinstance(prefix, str),  f'prefix must be a string, got {type(prefix)}'
-        assert isinstance(self.value, str), f'self.value must be a string, got {type(self.value)}'
+        """
+        assert isinstance(prefix, str), f"prefix must be a string, got {type(prefix)}"
+        assert isinstance(self.value, str), f"self.value must be a string, got {type(self.value)}"
 
         if not self.__semantic__:
             return self.value.startswith(prefix)
@@ -1498,7 +1679,7 @@ class StringHelperPrimitives(Primitive):
         return _func(self, prefix)
 
     def endswith(self, suffix: str, **_kwargs) -> bool:
-        '''
+        """
         Checks if the symbol value ends with a specified suffix.
         Uses the core.endswith decorator to create a _func method that checks if the symbol value ends with the specified suffix.
 
@@ -1507,9 +1688,9 @@ class StringHelperPrimitives(Primitive):
 
         Returns:
             bool: True if the symbol value ends with the specified suffix, otherwise False.
-        '''
-        assert isinstance(suffix, str),  f'suffix must be a string, got {type(suffix)}'
-        assert isinstance(self.value, str), f'self.value must be a string, got {type(self.value)}'
+        """
+        assert isinstance(suffix, str), f"suffix must be a string, got {type(suffix)}"
+        assert isinstance(self.value, str), f"self.value must be a string, got {type(self.value)}"
 
         if not self.__semantic__:
             return self.value.endswith(suffix)
@@ -1522,12 +1703,13 @@ class StringHelperPrimitives(Primitive):
 
 
 class ComparisonPrimitives(Primitive):
-    '''
+    """
     This mixin is dedicated to functions that perform more complex comparison operations between symbols or symbol values.
     This usually involves additional context, which the builtin overrode (e.g. __eq__) functions lack.
-    '''
-    def equals(self, string: str, context: str = 'contextually', **kwargs) -> 'Symbol':
-        '''
+    """
+
+    def equals(self, string: str, context: str = "contextually", **kwargs) -> "Symbol":
+        """
         Checks if the symbol value is equal to another string.
         Uses the core.equals decorator to create a _func method that checks for equality in a specific context.
 
@@ -1537,7 +1719,8 @@ class ComparisonPrimitives(Primitive):
 
         Returns:
             Symbol: A new symbol indicating whether the two strings are equal or not.
-        '''
+        """
+
         @core.equals(context=context, **kwargs)
         def _func(_, string: str) -> bool:
             pass
@@ -1545,7 +1728,7 @@ class ComparisonPrimitives(Primitive):
         return self._to_type(_func(self, string))
 
     def contains(self, element: Any, **kwargs) -> bool:
-        '''
+        """
         Uses the @core.contains decorator, checks whether the symbol's value contains the element.
 
         Args:
@@ -1554,7 +1737,8 @@ class ComparisonPrimitives(Primitive):
 
         Returns:
             bool: True if the symbol's value contains the element, False otherwise.
-        '''
+        """
+
         @core.contains(**kwargs)
         def _func(_, other) -> bool:
             pass
@@ -1562,7 +1746,7 @@ class ComparisonPrimitives(Primitive):
         return _func(self, element)
 
     def isinstanceof(self, query: str, **kwargs) -> bool:
-        '''
+        """
         Check if the current Symbol is an instance of a specific type.
 
         Args:
@@ -1571,7 +1755,8 @@ class ComparisonPrimitives(Primitive):
 
         Returns:
             bool: True if the current Symbol is an instance of the specified type, otherwise False.
-        '''
+        """
+
         @core.isinstanceof()
         def _func(_, query: str, **kwargs) -> bool:
             pass
@@ -1580,35 +1765,41 @@ class ComparisonPrimitives(Primitive):
 
 
 class ExpressionHandlingPrimitives(Primitive):
-    '''
+    """
     This mixin consists of functions that handle symbolic expressions - evaluations, parsing, computation and more.
     Future functionalities in this mixin might include operations to manipulate expressions, more complex evaluation techniques, etc.
-    '''
+    """
+
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
 
     def init_results(self):
         """Ensures _accumulated_results exists, initializing if needed."""
-        if not hasattr(self, '_accumulated_results'):
+        if not hasattr(self, "_accumulated_results"):
             self._accumulated_results = []
 
-    def get_results(self) -> list['Symbol']:
-        '''
+    def get_results(self) -> list["Symbol"]:
+        """
         Retrieves accumulated results from previous interpretations.
 
         Returns:
             List[Symbol]: List of accumulated results
-        '''
+        """
         self.init_results()
         return self._accumulated_results
 
     def clear_results(self):
-        '''Clears the accumulated results'''
+        """Clears the accumulated results"""
         self.init_results()
         self._accumulated_results = []
 
-    def interpret(self, prompt: str | None = "Evaluate the symbolic expressions and return only the result:\n", accumulate: bool = False, **kwargs) -> 'Symbol':
-        '''
+    def interpret(
+        self,
+        prompt: str | None = "Evaluate the symbolic expressions and return only the result:\n",
+        accumulate: bool = False,
+        **kwargs,
+    ) -> "Symbol":
+        """
         Evaluates simple symbolic expressions.
         Uses the core.expression decorator to create a _func method that evaluates the given expression.
 
@@ -1619,9 +1810,9 @@ class ExpressionHandlingPrimitives(Primitive):
 
         Returns:
             Symbol: A new symbol with the result of the expression evaluation.
-        '''
+        """
         # Propagate original input
-        input_value = getattr(self, '_input', self) if hasattr(self, '_input') else self
+        input_value = getattr(self, "_input", self) if hasattr(self, "_input") else self
 
         @core.interpret(prompt=prompt, **kwargs)
         def _func(_):
@@ -1639,26 +1830,28 @@ class ExpressionHandlingPrimitives(Primitive):
 
 
 class DataHandlingPrimitives(Primitive):
-    '''
+    """
     This mixin houses functions that clean, summarize and outline symbols or their values.
     Future implementations in this mixin may include various other cleaning and summarization techniques, error detection/correction in symbols, complex filtering, bulk modifications, or other types of condition-based manipulations on symbols, etc.
-    '''
-    def clean(self, **kwargs) -> 'Symbol':
-        '''
+    """
+
+    def clean(self, **kwargs) -> "Symbol":
+        """
         Cleans the symbol value.
         Uses the core.clean decorator to create a _func method that cleans the symbol value.
 
         Returns:
             Symbol: A new symbol with the cleaned value.
-        '''
+        """
+
         @core.clean(**kwargs)
         def _func(_) -> str:
             pass
 
         return self._to_type(_func(self))
 
-    def summarize(self, context: str | None = None, **kwargs) -> 'Symbol':
-        '''
+    def summarize(self, context: str | None = None, **kwargs) -> "Symbol":
+        """
         Summarizes the symbol value.
         Uses the core.summarize decorator with an optional context to create a _func method that summarizes the symbol value.
 
@@ -1667,29 +1860,31 @@ class DataHandlingPrimitives(Primitive):
 
         Returns:
             Symbol: A new symbol with the summarized value.
-        '''
+        """
+
         @core.summarize(context=context, **kwargs)
         def _func(_) -> str:
             pass
 
         return self._to_type(_func(self))
 
-    def outline(self, **kwargs) -> 'Symbol':
-        '''
+    def outline(self, **kwargs) -> "Symbol":
+        """
         Creates an outline of the symbol value.
         Uses the core.outline decorator to create a _func method that generates an outline of the symbol value.
 
         Returns:
             Symbol: A new symbol with the outline of the value.
-        '''
+        """
+
         @core.outline(**kwargs)
         def _func(_) -> str:
             pass
 
         return self._to_type(_func(self))
 
-    def filter(self, criteria: str, include: bool | None = False, **kwargs) -> 'Symbol':
-        '''
+    def filter(self, criteria: str, include: bool | None = False, **kwargs) -> "Symbol":
+        """
         Filters the symbol value based on a specified criteria.
         Uses the core.filtering decorator with the provided criteria and include flag to create a _func method to filter the symbol value.
 
@@ -1699,15 +1894,16 @@ class DataHandlingPrimitives(Primitive):
 
         Returns:
             Symbol: A new symbol with the filtered value.
-        '''
+        """
+
         @core.filtering(criteria=criteria, include=include, **kwargs)
         def _func(_) -> str:
             pass
 
         return self._to_type(_func(self))
 
-    def map(self, instruction: str, **kwargs) -> 'Symbol':
-        '''
+    def map(self, instruction: str, **kwargs) -> "Symbol":
+        """
         Applies a semantic transformation instruction to each element in an iterable.
         This method transforms each element based on the provided instruction while preserving
         elements that don't match the transformation criteria.
@@ -1721,11 +1917,11 @@ class DataHandlingPrimitives(Primitive):
 
         Raises:
             AssertionError: If the Symbol's value is not iterable or is an unsupported type
-        '''
+        """
         try:
             iter(self.value)
         except TypeError:
-            UserMessage('Map can only be applied to iterable objects', raise_with=AssertionError)
+            UserMessage("Map can only be applied to iterable objects", raise_with=AssertionError)
 
         @core.map(instruction=instruction, **kwargs)
         def _func(_):
@@ -1733,8 +1929,8 @@ class DataHandlingPrimitives(Primitive):
 
         return self._to_type(_func(self))
 
-    def modify(self, changes: str, **kwargs) -> 'Symbol':
-        '''
+    def modify(self, changes: str, **kwargs) -> "Symbol":
+        """
         Modifies the symbol value based on the specified changes.
         Uses the core.modify decorator with the provided changes to create a _func method to modify the symbol value.
 
@@ -1743,15 +1939,16 @@ class DataHandlingPrimitives(Primitive):
 
         Returns:
             Symbol: A new symbol with the modified value.
-        '''
+        """
+
         @core.modify(changes=changes, **kwargs)
         def _func(_) -> str:
             pass
 
         return self._to_type(_func(self))
 
-    def replace(self, old: str, new: str, **kwargs) -> 'Symbol':
-        '''
+    def replace(self, old: str, new: str, **kwargs) -> "Symbol":
+        """
         Replaces one value in the symbol value with another.
         Uses the core.replace decorator to create a _func method that replaces the values in the symbol value.
 
@@ -1761,15 +1958,16 @@ class DataHandlingPrimitives(Primitive):
 
         Returns:
             Symbol: A new symbol with the replaced value.
-        '''
+        """
+
         @core.replace(**kwargs)
         def _func(_, old: str, new: str):
             pass
 
         return self._to_type(_func(self, old, new))
 
-    def remove(self, information: str, **kwargs) -> 'Symbol':
-        '''
+    def remove(self, information: str, **kwargs) -> "Symbol":
+        """
         Removes a specified piece of information from the symbol value.
         Uses the core.replace decorator to create a _func method that removes the specified information.
 
@@ -1778,15 +1976,16 @@ class DataHandlingPrimitives(Primitive):
 
         Returns:
             Symbol: A new symbol with the removed information.
-        '''
+        """
+
         @core.replace(**kwargs)
         def _func(_, text: str, replace: str, value: str):
             pass
 
-        return self._to_type(_func(self, information, ''))
+        return self._to_type(_func(self, information, ""))
 
-    def include(self, information: str, **kwargs) -> 'Symbol':
-        '''
+    def include(self, information: str, **kwargs) -> "Symbol":
+        """
         Includes a specified piece of information in the symbol value.
         Uses the core.include decorator to create a _func method that includes the specified information.
 
@@ -1795,15 +1994,16 @@ class DataHandlingPrimitives(Primitive):
 
         Returns:
             Symbol: A new symbol with the included information.
-        '''
+        """
+
         @core.include(**kwargs)
         def _func(_, information: str):
             pass
 
         return self._to_type(_func(self, information))
 
-    def combine(self, information: str, **kwargs) -> 'Symbol':
-        '''
+    def combine(self, information: str, **kwargs) -> "Symbol":
+        """
         Combines the current symbol value with another string.
         Uses the core.combine decorator to create a _func method that combines the symbol value with another string.
 
@@ -1812,7 +2012,8 @@ class DataHandlingPrimitives(Primitive):
 
         Returns:
             Symbol: A new symbol with the combined value.
-        '''
+        """
+
         @core.combine(**kwargs)
         def _func(_, a: str, b: str):
             pass
@@ -1821,12 +2022,13 @@ class DataHandlingPrimitives(Primitive):
 
 
 class UniquenessPrimitives(Primitive):
-    '''
+    """
     This mixin includes functions that work with unique aspects of symbol values, like extracting unique information or composing new unique symbols.
     Future functionalities might include finding duplicate information, defining levels of uniqueness, etc.
-    '''
-    def unique(self, keys: list[str] | None = None, **kwargs) -> 'Symbol':
-        '''
+    """
+
+    def unique(self, keys: list[str] | None = None, **kwargs) -> "Symbol":
+        """
         Extracts unique information from the symbol value, using provided keys.
         Uses the core.unique decorator with a list of keys to create a _func method that extracts unique data from the symbol value.
 
@@ -1835,23 +2037,25 @@ class UniquenessPrimitives(Primitive):
 
         Returns:
             Symbol: A new symbol with the unique information.
-        '''
+        """
         if keys is None:
             keys = []
+
         @core.unique(keys=keys, **kwargs)
         def _func(_) -> str:
             pass
 
         return self._to_type(_func(self))
 
-    def compose(self, **kwargs) -> 'Symbol':
-        '''
+    def compose(self, **kwargs) -> "Symbol":
+        """
         Composes a text based on the symbol value.
         Uses the core.compose decorator to create a _func method that composes a text using the symbol value.
 
         Returns:
             Symbol: A new symbol with the composed text.
-        '''
+        """
+
         @core.compose(**kwargs)
         def _func(_) -> str:
             pass
@@ -1860,12 +2064,15 @@ class UniquenessPrimitives(Primitive):
 
 
 class PatternMatchingPrimitives(Primitive):
-    '''
+    """
     This mixin houses functions that deal with ranking symbols, extracting details based on patterns, and correcting symbols.
     It will house future functionalities that involve sorting, complex pattern detections, advanced correction techniques etc.
-    '''
-    def rank(self, measure: str | None = 'alphanumeric', order: str | None = 'desc', **kwargs) -> 'Symbol':
-        '''
+    """
+
+    def rank(
+        self, measure: str | None = "alphanumeric", order: str | None = "desc", **kwargs
+    ) -> "Symbol":
+        """
         Ranks the symbol value based on a measure and a sort order.
         Uses the core.rank decorator with the specified measure and order to create a _func method that ranks the symbol value.
 
@@ -1876,15 +2083,16 @@ class PatternMatchingPrimitives(Primitive):
 
         Returns:
             Symbol: A new symbol with the ranked value.
-        '''
+        """
+
         @core.rank(order=order, **kwargs)
         def _func(_, measure: str) -> str:
             pass
 
         return self._to_type(_func(self, measure))
 
-    def extract(self, pattern: str, **kwargs) -> 'Symbol':
-        '''
+    def extract(self, pattern: str, **kwargs) -> "Symbol":
+        """
         Extracts data from the symbol value based on a pattern.
         Uses the core.extract decorator with the specified pattern to create a _func method that extracts data from the symbol value.
 
@@ -1893,15 +2101,16 @@ class PatternMatchingPrimitives(Primitive):
 
         Returns:
             Symbol: A new symbol with the extracted data.
-        '''
+        """
+
         @core.extract(**kwargs)
         def _func(_, pattern: str) -> str:
             pass
 
         return self._to_type(_func(self, pattern))
 
-    def correct(self, context: str, exception: Exception, **kwargs) -> 'Symbol':
-        '''
+    def correct(self, context: str, exception: Exception, **kwargs) -> "Symbol":
+        """
         Corrects the symbol value based on a specified context.
         Uses the @core.correct decorator, corrects the value of the symbol based on the given context.
 
@@ -1912,15 +2121,16 @@ class PatternMatchingPrimitives(Primitive):
 
         Returns:
             Symbol: The corrected value as a Symbol.
-        '''
+        """
+
         @core.correct(context=context, exception=exception, **kwargs)
         def _func(_) -> str:
             pass
 
         return self._to_type(_func(self))
 
-    def translate(self, language: str | None = 'English', **kwargs) -> 'Symbol':
-        '''
+    def translate(self, language: str | None = "English", **kwargs) -> "Symbol":
+        """
         Translates the symbol value to the specified language.
         Uses the @core.translate decorator to translate the symbol's value to the specified language.
 
@@ -1930,15 +2140,16 @@ class PatternMatchingPrimitives(Primitive):
 
         Returns:
             Symbol: The translated value as a Symbol.
-        '''
+        """
+
         @core.translate(language=language, **kwargs)
         def _func(_) -> str:
             pass
 
         return self._to_type(_func(self))
 
-    def choice(self, cases: list[str], default: str, **kwargs) -> 'Symbol':
-        '''
+    def choice(self, cases: list[str], default: str, **kwargs) -> "Symbol":
+        """
         Chooses one of the cases based on the symbol value.
         Uses the @core.case decorator, selects one of the cases based on the symbol's value.
 
@@ -1949,7 +2160,8 @@ class PatternMatchingPrimitives(Primitive):
 
         Returns:
             Symbol: The chosen case as a Symbol.
-        '''
+        """
+
         @core.case(enum=cases, default=default, **kwargs)
         def _func(_) -> str:
             pass
@@ -1958,12 +2170,19 @@ class PatternMatchingPrimitives(Primitive):
 
 
 class QueryHandlingPrimitives(Primitive):
-    '''
+    """
     This mixin helps in transforming, preparing, and executing queries, and it is designed to be extendable as new ways of handling queries are developed.
     Future methods could potentially include query optimization, enhanced query formatting, multi-level query execution, query error handling, etc.
-    '''
-    def query(self, context: str, prompt: str | None = None, examples: list[Prompt] | None = None, **kwargs) -> 'Symbol':
-        '''
+    """
+
+    def query(
+        self,
+        context: str,
+        prompt: str | None = None,
+        examples: list[Prompt] | None = None,
+        **kwargs,
+    ) -> "Symbol":
+        """
         Queries the symbol value based on a specified context.
         Uses the @core.query decorator, queries based on the context, prompt, and examples.
 
@@ -1975,15 +2194,16 @@ class QueryHandlingPrimitives(Primitive):
 
         Returns:
             Symbol: The result of the query as a Symbol.
-        '''
+        """
+
         @core.query(context=context, prompt=prompt, examples=examples, **kwargs)
         def _func(_) -> str:
             pass
 
         return self._to_type(_func(self))
 
-    def convert(self, format: str, **kwargs) -> 'Symbol':
-        '''
+    def convert(self, format: str, **kwargs) -> "Symbol":
+        """
         Converts the symbol value to the specified format.
         Uses the @core.convert decorator, converts the symbol's value to the specified format.
 
@@ -1993,15 +2213,16 @@ class QueryHandlingPrimitives(Primitive):
 
         Returns:
             Symbol: The converted value as a Symbol.
-        '''
+        """
+
         @core.convert(format=format, **kwargs)
         def _func(_) -> str:
             pass
 
         return self._to_type(_func(self))
 
-    def transcribe(self, modify: str, **kwargs) -> 'Symbol':
-        '''
+    def transcribe(self, modify: str, **kwargs) -> "Symbol":
+        """
         Transcribes the symbol value based on a specified modification.
         Uses the @core.transcribe decorator, modifies the symbol's value based on the modify parameter.
 
@@ -2011,7 +2232,8 @@ class QueryHandlingPrimitives(Primitive):
 
         Returns:
             Symbol: The modified value as a Symbol.
-        '''
+        """
+
         @core.transcribe(modify=modify, **kwargs)
         def _func(_) -> str:
             pass
@@ -2020,12 +2242,13 @@ class QueryHandlingPrimitives(Primitive):
 
 
 class ExecutionControlPrimitives(Primitive):
-    '''
+    """
     This mixin represents the core methods for dealing with symbol execution.
     Possible future methods could potentially include async execution, pipeline chaining, execution profiling, improved error handling, version management, embedding more complex execution control structures etc.
-    '''
-    def analyze(self, exception: Exception, query: str | None = '', **kwargs) -> 'Symbol':
-        '''Uses the @core.analyze decorator, analyzes an exception and returns a symbol.
+    """
+
+    def analyze(self, exception: Exception, query: str | None = "", **kwargs) -> "Symbol":
+        """Uses the @core.analyze decorator, analyzes an exception and returns a symbol.
 
         Args:
             exception (Exception): The exception to be analyzed.
@@ -2034,15 +2257,16 @@ class ExecutionControlPrimitives(Primitive):
 
         Returns:
             Symbol: The analyzed result as a Symbol.
-        '''
+        """
+
         @core.analyze(exception=exception, query=query, **kwargs)
         def _func(_) -> str:
             pass
 
         return self._to_type(_func(self))
 
-    def execute(self, **kwargs) -> 'Symbol':
-        '''
+    def execute(self, **kwargs) -> "Symbol":
+        """
         Executes the symbol's expression using the @core.execute decorator.
 
         Args:
@@ -2050,15 +2274,16 @@ class ExecutionControlPrimitives(Primitive):
 
         Returns:
             Symbol: The result of the executed expression as a Symbol.
-        '''
+        """
+
         @core.execute(**kwargs)
         def _func(_):
             pass
 
         return _func(self)
 
-    def fexecute(self, **kwargs) -> 'Symbol':
-        '''
+    def fexecute(self, **kwargs) -> "Symbol":
+        """
         Executes the symbol's expression using the fallback execute method (ftry).
 
         Args:
@@ -2066,14 +2291,15 @@ class ExecutionControlPrimitives(Primitive):
 
         Returns:
             Symbol: The result of the executed expression as a Symbol.
-        '''
-        def _func(sym: 'Symbol', **kargs):
+        """
+
+        def _func(sym: "Symbol", **kargs):
             return sym.execute(**kargs)
 
         return self.ftry(_func, **kwargs)
 
-    def simulate(self, **kwargs) -> 'Symbol':
-        '''
+    def simulate(self, **kwargs) -> "Symbol":
+        """
         Uses the @core.simulate decorator, simulates the value of the symbol. Used for hypothesis testing or code simulation.
 
         Args:
@@ -2081,15 +2307,16 @@ class ExecutionControlPrimitives(Primitive):
 
         Returns:
             Symbol: The simulated value as a Symbol.
-        '''
+        """
+
         @core.simulate(**kwargs)
         def _func(_):
             pass
 
         return self._to_type(_func(self))
 
-    def sufficient(self, query: str, **kwargs) -> 'Symbol':
-        '''
+    def sufficient(self, query: str, **kwargs) -> "Symbol":
+        """
         Uses the @core.sufficient decorator and checks if the symbol's value is sufficient based on the query.
 
         Args:
@@ -2098,15 +2325,18 @@ class ExecutionControlPrimitives(Primitive):
 
         Returns:
             Symbol: The sufficiency result as a Symbol.
-        '''
+        """
+
         @core.sufficient(query=query, **kwargs)
         def _func(_) -> bool:
             pass
 
         return self._to_type(_func(self))
 
-    def list(self, condition: str, **kwargs) -> 'Symbol':  #@TODO: can't filter directly handle this case?
-        '''
+    def list(
+        self, condition: str, **kwargs
+    ) -> "Symbol":  # @TODO: can't filter directly handle this case?
+        """
         Uses the @core.listing decorator and lists elements based on the condition.
 
         Args:
@@ -2115,15 +2345,16 @@ class ExecutionControlPrimitives(Primitive):
 
         Returns:
             Symbol: The filtered list as a Symbol.
-        '''
+        """
+
         @core.listing(condition=condition, **kwargs)
         def _func(_) -> list:
             pass
 
         return self._to_type(_func(self))
 
-    def foreach(self, condition: str, apply: str, **kwargs) -> 'Symbol':
-        '''
+    def foreach(self, condition: str, apply: str, **kwargs) -> "Symbol":
+        """
         Uses the @core.foreach decorator, iterates through the symbol's value, and applies the provided functionality.
 
         Args:
@@ -2133,15 +2364,16 @@ class ExecutionControlPrimitives(Primitive):
 
         Returns:
             Symbol: The result of the iterative application of the function as a Symbol.
-        '''
+        """
+
         @core.foreach(condition=condition, apply=apply, **kwargs)
         def _func(_):
             pass
 
         return self._to_type(_func(self))
 
-    def stream(self, expr: 'Expression', token_ratio: float | None = 0.6, **kwargs) -> 'Symbol':
-        '''
+    def stream(self, expr: "Expression", token_ratio: float | None = 0.6, **kwargs) -> "Symbol":
+        """
         Streams the Symbol's value through an Expression object.
         This method divides the Symbol's value into chunks and processes each chunk through the given Expression object.
         It is useful for processing large strings in smaller parts.
@@ -2156,9 +2388,11 @@ class ExecutionControlPrimitives(Primitive):
 
         Raises:
             ValueError: If the Expression object exceeds the maximum allowed tokens.
-        '''
-        @core_ext.bind(engine='neurosymbolic', property='max_context_tokens')
-        def _max_tokens(_): pass
+        """
+
+        @core_ext.bind(engine="neurosymbolic", property="max_context_tokens")
+        def _max_tokens(_):
+            pass
 
         max_ctxt_tokens = int(_max_tokens(self) * token_ratio)
         prev = expr(self, preview=True, **kwargs)
@@ -2168,7 +2402,7 @@ class ExecutionControlPrimitives(Primitive):
             n_splits = (len(prev) // max_ctxt_tokens) + 1
 
             for i in range(n_splits):
-                tokens_sliced = self.tokens[i * max_ctxt_tokens: (i + 1) * max_ctxt_tokens]
+                tokens_sliced = self.tokens[i * max_ctxt_tokens : (i + 1) * max_ctxt_tokens]
                 r = self._to_type(self.tokenizer().decode(tokens_sliced))
 
                 yield expr(r, **kwargs)
@@ -2176,9 +2410,9 @@ class ExecutionControlPrimitives(Primitive):
         else:
             yield expr(self, **kwargs)
 
-    def ftry(self, expr: 'Expression', retries: int | None = 1, **kwargs) -> 'Symbol':
+    def ftry(self, expr: "Expression", retries: int | None = 1, **kwargs) -> "Symbol":
         # TODO: find a way to pass on the constraints and behavior from the self.expr to the corrected code
-        '''
+        """
         Tries to evaluate a Symbol using a given Expression.
         This method evaluates a Symbol using a given Expression.
         If it fails, it retries the evaluation a specified number of times.
@@ -2193,23 +2427,23 @@ class ExecutionControlPrimitives(Primitive):
 
         Raises:
             Exception: If the evaluation fails after all retries.
-        '''
-        prompt = {'out_msg': ''}
+        """
+        prompt = {"out_msg": ""}
 
         def output_handler(input_):
-            prompt['out_msg'] = input_
+            prompt["out_msg"] = input_
 
-        kwargs['output_handler'] = output_handler
+        kwargs["output_handler"] = output_handler
         retry_cnt: int = 0
-        code = self # original input
+        code = self  # original input
 
-        if hasattr(expr, 'prompt'):
-            prompt['prompt_instruction'] = expr.prompt
+        if hasattr(expr, "prompt"):
+            prompt["prompt_instruction"] = expr.prompt
 
-        sym = self # used for getting passed from one iteration to the next
+        sym = self  # used for getting passed from one iteration to the next
         while True:
             try:
-                sym = expr(sym, **kwargs) # run the expression
+                sym = expr(sym, **kwargs)  # run the expression
                 retry_cnt = 0
 
                 return sym
@@ -2219,40 +2453,51 @@ class ExecutionControlPrimitives(Primitive):
                 if retry_cnt > retries:
                     raise e
                 # analyze the error
-                payload = f'[ORIGINAL_USER_PROMPT]\n{prompt["prompt_instruction"]}\n\n' if 'prompt_instruction' in prompt else ''
-                payload = payload + f'[ORIGINAL_USER_DATA]\n{code}\n\n[ORIGINAL_GENERATED_OUTPUT]\n{prompt["out_msg"]}'
-                probe   = sym.analyze(query="What is the issue in this expression?", payload=payload, exception=e)
+                payload = (
+                    f"[ORIGINAL_USER_PROMPT]\n{prompt['prompt_instruction']}\n\n"
+                    if "prompt_instruction" in prompt
+                    else ""
+                )
+                payload = (
+                    payload
+                    + f"[ORIGINAL_USER_DATA]\n{code}\n\n[ORIGINAL_GENERATED_OUTPUT]\n{prompt['out_msg']}"
+                )
+                probe = sym.analyze(
+                    query="What is the issue in this expression?", payload=payload, exception=e
+                )
                 # attempt to correct the error
-                payload = f'[ORIGINAL_USER_PROMPT]\n{prompt["prompt_instruction"]}\n\n' if 'prompt_instruction' in prompt else ''
-                payload = payload + f'[ANALYSIS]\n{probe}\n\n'
-                context = f'Try to correct the error of the original user request based on the analysis above: \n [GENERATED_OUTPUT]\n{prompt["out_msg"]}\n\n'
-                constraints = expr.constraints if hasattr(expr, 'constraints') else []
-
-                if hasattr(expr, 'post_processor'):
+                payload = (
+                    f"[ORIGINAL_USER_PROMPT]\n{prompt['prompt_instruction']}\n\n"
+                    if "prompt_instruction" in prompt
+                    else ""
+                )
+                payload = payload + f"[ANALYSIS]\n{probe}\n\n"
+                context = f"Try to correct the error of the original user request based on the analysis above: \n [GENERATED_OUTPUT]\n{prompt['out_msg']}\n\n"
+                constraints = expr.constraints if hasattr(expr, "constraints") else []
+
+                if hasattr(expr, "post_processor"):
                     post_processor = expr.post_processor
                     sym = code.correct(
                         context=context,
                         exception=e,
                         payload=payload,
                         constraints=constraints,
-                        post_processor=post_processor
+                        post_processor=post_processor,
                     )
                 else:
                     sym = code.correct(
-                        context=context,
-                        exception=e,
-                        payload=payload,
-                        constraints=constraints
+                        context=context, exception=e, payload=payload, constraints=constraints
                     )
 
 
 class DictHandlingPrimitives(Primitive):
-    '''
+    """
     This mixin hosts functions that deal with dictionary operations on symbol values.
     It can be extended in the future with more advanced dictionary methods and operations.
-    '''
-    def dict(self, context: str, **kwargs) -> 'Symbol':
-        '''
+    """
+
+    def dict(self, context: str, **kwargs) -> "Symbol":
+        """
         Maps related content together under a common abstract topic as a dictionary of the Symbol value.
         This method uses the @core.dictionary decorator to apply the given context to the Symbol.
         It is useful for applying additional context to the symbol.
@@ -2263,7 +2508,8 @@ class DictHandlingPrimitives(Primitive):
 
         Returns:
             Symbol: A Symbol object with a dictionary applied.
-        '''
+        """
+
         @core.dictionary(context=context, **kwargs)
         def _func(_):
             pass
@@ -2272,12 +2518,15 @@ class DictHandlingPrimitives(Primitive):
 
 
 class TemplateStylingPrimitives(Primitive):
-    '''
+    """
     This mixin includes functionalities for stylizing symbols and applying templates.
     Future functionalities might include a variety of new stylizing methods, application of more complex templates, etc.
-    '''
-    def template(that, template: str, placeholder: str | None = '{{placeholder}}', **_kwargs) -> 'Symbol':
-        '''
+    """
+
+    def template(
+        that, template: str, placeholder: str | None = "{{placeholder}}", **_kwargs
+    ) -> "Symbol":
+        """
         Applies a template to the Symbol.
         This method uses the @core.template decorator to apply the given template and placeholder to the Symbol.
         It is useful for providing structure to the Symbol's value.
@@ -2289,15 +2538,16 @@ class TemplateStylingPrimitives(Primitive):
 
         Returns:
             Symbol: A Symbol object with a template applied.
-        '''
+        """
+
         def _func(self):
             res = template.replace(placeholder, str(self))
             return that._to_type(res)
 
         return _func(that)
 
-    def style(self, description: str, libraries: list | None = None, **kwargs) -> 'Symbol':
-        '''
+    def style(self, description: str, libraries: list | None = None, **kwargs) -> "Symbol":
+        """
         Applies a style to the Symbol.
         This method uses the @core.style decorator to apply the given style description, libraries, and placeholder to the Symbol.
         It is useful for providing structure and style to the Symbol's value.
@@ -2309,9 +2559,10 @@ class TemplateStylingPrimitives(Primitive):
 
         Returns:
             Symbol: A Symbol object with the style applied.
-        '''
+        """
         if libraries is None:
             libraries = []
+
         @core.style(description=description, libraries=libraries, **kwargs)
         def _func(_):
             pass
@@ -2320,12 +2571,13 @@ class TemplateStylingPrimitives(Primitive):
 
 
 class DataClusteringPrimitives(Primitive):
-    '''
+    """
     This mixin contains functionalities that deal with clustering symbol values or generating embeddings.
     New functionalities in this mixin might include different types of clustering and embedding methods, dimensionality reduction techniques, etc.
-    '''
-    def cluster(self, **kwargs) -> 'Symbol':
-        '''
+    """
+
+    def cluster(self, **kwargs) -> "Symbol":
+        """
         Creates a cluster from the Symbol's value.
         This method uses the @core.cluster decorator to create a cluster from the Symbol's value.
         It is useful for grouping values in the Symbol.
@@ -2335,7 +2587,8 @@ class DataClusteringPrimitives(Primitive):
 
         Returns:
             Symbol: A Symbol object with its value clustered.
-        '''
+        """
+
         @core.cluster(entries=self.value, **kwargs)
         def _func(_, error=None, stack_trace=None):
             pass
@@ -2344,12 +2597,13 @@ class DataClusteringPrimitives(Primitive):
 
 
 class EmbeddingPrimitives(Primitive):
-    '''
+    """
     This mixin contains functionalities that deal with embedding symbol values.
     New functionalities in this mixin might include different types of embedding methods, similarity and distance measures etc.
-    '''
-    def embed(self, **kwargs) -> 'Symbol':
-        '''
+    """
+
+    def embed(self, **kwargs) -> "Symbol":
+        """
         Generates embeddings for the Symbol's value.
         This method uses the @core.embed decorator to generate embeddings for the Symbol's value.
         If the value is not a list, it is converted to a list.
@@ -2359,7 +2613,7 @@ class EmbeddingPrimitives(Primitive):
 
         Returns:
             Symbol: A Symbol object with its value embedded.
-        '''
+        """
         value = self.value
         if not isinstance(value, list):
             # must convert to list of str for embedding
@@ -2375,25 +2629,29 @@ class EmbeddingPrimitives(Primitive):
 
     @property
     def embedding(self) -> np.array:
-        '''
+        """
         Get the embedding as a numpy array.
 
         Returns:
             Any: The embedding of the symbol.
-        '''
+        """
         # if the embedding is not yet computed, compute it
         if self._metadata.embedding is None:
-            if (isinstance(self.value, (list, tuple)) and all(isinstance(x, (int, float, bool)) for x in self.value)) \
-                or isinstance(self.value, np.ndarray):
+            if (
+                isinstance(self.value, (list, tuple))
+                and all(isinstance(x, (int, float, bool)) for x in self.value)
+            ) or isinstance(self.value, np.ndarray):
                 if isinstance(self.value, (list, tuple)):
-                    assert len(self.value) > 0, 'Cannot compute embedding of empty list'
+                    assert len(self.value) > 0, "Cannot compute embedding of empty list"
                     symbol_type = self._symbol_type
                     if isinstance(self.value[0], symbol_type):
                         # convert each element to numpy array
                         self._metadata.embedding = np.asarray([x.embedding for x in self.value])
                     elif isinstance(self.value[0], str):
                         # embed each string
-                        self._metadata.embedding = np.asarray([symbol_type(x).embedding for x in self.value])
+                        self._metadata.embedding = np.asarray(
+                            [symbol_type(x).embedding for x in self.value]
+                        )
                     else:
                         # convert to numpy array
                         self._metadata.embedding = np.asarray(self.value)
@@ -2413,9 +2671,11 @@ class EmbeddingPrimitives(Primitive):
     def _ensure_numpy_format(self, x, cast=False):
         # if it is a Symbol, get its value
         if not isinstance(x, (np.ndarray, torch.Tensor, list)):
-            if not isinstance(x, self._symbol_type): #@NOTE: enforce Symbol to avoid circular import
+            if not isinstance(
+                x, self._symbol_type
+            ):  # @NOTE: enforce Symbol to avoid circular import
                 if not cast:
-                    msg = f'Cannot compute similarity with type {type(x)}'
+                    msg = f"Cannot compute similarity with type {type(x)}"
                     UserMessage(msg)
                     raise TypeError(msg)
                 x = self._symbol_type(x)
@@ -2423,7 +2683,7 @@ class EmbeddingPrimitives(Primitive):
             x = x.embedding
         # if it is a list, convert it to numpy
         if isinstance(x, (list, tuple)):
-            assert len(x) > 0, 'Cannot compute similarity with empty list'
+            assert len(x) > 0, "Cannot compute similarity with empty list"
             x = np.asarray(x)
         # if it is a tensor, convert it to numpy
         elif isinstance(x, torch.Tensor):
@@ -2441,9 +2701,7 @@ class EmbeddingPrimitives(Primitive):
         if isinstance(operand, (list, tuple)):
             if self._is_numeric_sequence(operand):
                 return self._ensure_numpy_format(operand, cast=True)
-            formatted = [
-                self._ensure_numpy_format(item, cast=True) for item in operand
-            ]
+            formatted = [self._ensure_numpy_format(item, cast=True) for item in operand]
             return np.concatenate(formatted, axis=1)
         return self._ensure_numpy_format(operand, cast=True)
 
@@ -2458,38 +2716,44 @@ class EmbeddingPrimitives(Primitive):
 
     def _get_similarity_handler(self, metric, eps, kwargs):
         def _cosine_similarity(lhs, rhs):
-            return lhs.T@rhs / (np.sqrt(lhs.T@lhs) * np.sqrt(rhs.T@rhs) + eps)
+            return lhs.T @ rhs / (np.sqrt(lhs.T @ lhs) * np.sqrt(rhs.T @ rhs) + eps)
 
         def _angular_cosine_similarity(lhs, rhs):
-            c = kwargs.get('c', 1)
-            return 1 - (c * np.arccos(lhs.T@rhs / (np.sqrt(lhs.T@lhs) * np.sqrt(rhs.T@rhs) + eps)) / np.pi)
+            c = kwargs.get("c", 1)
+            return 1 - (
+                c
+                * np.arccos(lhs.T @ rhs / (np.sqrt(lhs.T @ lhs) * np.sqrt(rhs.T @ rhs) + eps))
+                / np.pi
+            )
 
         def _product_similarity(lhs, rhs):
-            return lhs.T@rhs
+            return lhs.T @ rhs
 
         def _manhattan_similarity(lhs, rhs):
             return np.abs(lhs - rhs).sum(axis=0, keepdims=True)
 
         def _euclidean_similarity(lhs, rhs):
-            return np.sqrt(np.sum((lhs - rhs)**2, axis=0, keepdims=True))
+            return np.sqrt(np.sum((lhs - rhs) ** 2, axis=0, keepdims=True))
 
         def _minkowski_similarity(lhs, rhs):
-            p = kwargs.get('p', 3)
-            return np.sum(np.abs(lhs - rhs)**p, axis=0, keepdims=True)**(1/p)
+            p = kwargs.get("p", 3)
+            return np.sum(np.abs(lhs - rhs) ** p, axis=0, keepdims=True) ** (1 / p)
 
         def _jaccard_similarity(lhs, rhs):
             intersection = np.minimum(lhs, rhs)
             union = np.maximum(lhs, rhs)
-            return np.sum(intersection, axis=0, keepdims=True) / (np.sum(union, axis=0, keepdims=True) + eps)
+            return np.sum(intersection, axis=0, keepdims=True) / (
+                np.sum(union, axis=0, keepdims=True) + eps
+            )
 
         metric_handlers = {
-            'cosine': _cosine_similarity,
-            'angular-cosine': _angular_cosine_similarity,
-            'product': _product_similarity,
-            'manhattan': _manhattan_similarity,
-            'euclidean': _euclidean_similarity,
-            'minkowski': _minkowski_similarity,
-            'jaccard': _jaccard_similarity,
+            "cosine": _cosine_similarity,
+            "angular-cosine": _angular_cosine_similarity,
+            "product": _product_similarity,
+            "manhattan": _manhattan_similarity,
+            "euclidean": _euclidean_similarity,
+            "minkowski": _minkowski_similarity,
+            "jaccard": _jaccard_similarity,
         }
 
         handler = metric_handlers.get(metric)
@@ -2504,19 +2768,19 @@ class EmbeddingPrimitives(Primitive):
 
     def _get_kernel_handler(self, kernel):
         kernel_handlers = {
-            'gaussian': self._kernel_gaussian,
-            'rbf': self._kernel_rbf,
-            'laplacian': self._kernel_laplacian,
-            'polynomial': self._kernel_polynomial,
-            'sigmoid': self._kernel_sigmoid,
-            'linear': self._kernel_linear,
-            'cauchy': self._kernel_cauchy,
-            't-distribution': self._kernel_t_distribution,
-            'inverse-multiquadric': self._kernel_inverse_multiquadric,
-            'cosine': self._kernel_cosine,
-            'angular-cosine': self._kernel_angular_cosine,
-            'frechet': self._kernel_frechet,
-            'mmd': self._kernel_mmd,
+            "gaussian": self._kernel_gaussian,
+            "rbf": self._kernel_rbf,
+            "laplacian": self._kernel_laplacian,
+            "polynomial": self._kernel_polynomial,
+            "sigmoid": self._kernel_sigmoid,
+            "linear": self._kernel_linear,
+            "cauchy": self._kernel_cauchy,
+            "t-distribution": self._kernel_t_distribution,
+            "inverse-multiquadric": self._kernel_inverse_multiquadric,
+            "cosine": self._kernel_cosine,
+            "angular-cosine": self._kernel_angular_cosine,
+            "frechet": self._kernel_frechet,
+            "mmd": self._kernel_mmd,
         }
 
         handler = kernel_handlers.get(kernel)
@@ -2527,13 +2791,13 @@ class EmbeddingPrimitives(Primitive):
         return handler
 
     def _kernel_gaussian(self, lhs, rhs, _eps, kwargs):
-        gamma = kwargs.get('gamma', 1)
-        return np.exp(-gamma * np.sum((lhs - rhs)**2, axis=0))
+        gamma = kwargs.get("gamma", 1)
+        return np.exp(-gamma * np.sum((lhs - rhs) ** 2, axis=0))
 
     def _kernel_rbf(self, lhs, rhs, _eps, kwargs):
-        bandwidth = kwargs.get('bandwidth')
-        gamma = kwargs.get('gamma', 1)
-        distance_sq = np.sum((lhs - rhs)**2, axis=0)
+        bandwidth = kwargs.get("bandwidth")
+        gamma = kwargs.get("gamma", 1)
+        distance_sq = np.sum((lhs - rhs) ** 2, axis=0)
         if bandwidth is not None:
             val = 0
             for a in bandwidth:
@@ -2543,35 +2807,35 @@ class EmbeddingPrimitives(Primitive):
         return np.exp(-gamma * distance_sq)
 
     def _kernel_laplacian(self, lhs, rhs, _eps, kwargs):
-        gamma = kwargs.get('gamma', 1)
+        gamma = kwargs.get("gamma", 1)
         return np.exp(-gamma * np.sum(np.abs(lhs - rhs), axis=0))
 
     def _kernel_polynomial(self, lhs, rhs, _eps, kwargs):
-        gamma = kwargs.get('gamma', 1)
-        degree = kwargs.get('degree', 3)
-        coef = kwargs.get('coef', 1)
-        return (gamma * np.sum((lhs * rhs), axis=0) + coef)**degree
+        gamma = kwargs.get("gamma", 1)
+        degree = kwargs.get("degree", 3)
+        coef = kwargs.get("coef", 1)
+        return (gamma * np.sum((lhs * rhs), axis=0) + coef) ** degree
 
     def _kernel_sigmoid(self, lhs, rhs, _eps, kwargs):
-        gamma = kwargs.get('gamma', 1)
-        coef = kwargs.get('coef', 1)
+        gamma = kwargs.get("gamma", 1)
+        coef = kwargs.get("coef", 1)
         return np.tanh(gamma * np.sum((lhs * rhs), axis=0) + coef)
 
     def _kernel_linear(self, lhs, rhs, _eps, _kwargs):
         return np.sum((lhs * rhs), axis=0)
 
     def _kernel_cauchy(self, lhs, rhs, _eps, kwargs):
-        gamma = kwargs.get('gamma', 1)
-        return 1 / (1 + np.sum((lhs - rhs)**2, axis=0) / gamma)
+        gamma = kwargs.get("gamma", 1)
+        return 1 / (1 + np.sum((lhs - rhs) ** 2, axis=0) / gamma)
 
     def _kernel_t_distribution(self, lhs, rhs, _eps, kwargs):
-        gamma = kwargs.get('gamma', 1)
-        degree = kwargs.get('degree', 1)
-        return 1 / (1 + (np.sum((lhs - rhs)**2, axis=0) / (gamma * degree))**(degree + 1) / 2)
+        gamma = kwargs.get("gamma", 1)
+        degree = kwargs.get("degree", 1)
+        return 1 / (1 + (np.sum((lhs - rhs) ** 2, axis=0) / (gamma * degree)) ** (degree + 1) / 2)
 
     def _kernel_inverse_multiquadric(self, lhs, rhs, _eps, kwargs):
-        gamma = kwargs.get('gamma', 1)
-        return 1 / np.sqrt(np.sum((lhs - rhs)**2, axis=0) / gamma**2 + 1)
+        gamma = kwargs.get("gamma", 1)
+        return 1 / np.sqrt(np.sum((lhs - rhs) ** 2, axis=0) / gamma**2 + 1)
 
     def _kernel_cosine(self, lhs, rhs, eps, _kwargs):
         numerator = np.sum(lhs * rhs, axis=0)
@@ -2579,15 +2843,17 @@ class EmbeddingPrimitives(Primitive):
         return 1 - (numerator / denominator)
 
     def _kernel_angular_cosine(self, lhs, rhs, eps, kwargs):
-        c = kwargs.get('c', 1)
+        c = kwargs.get("c", 1)
         numerator = np.sum(lhs * rhs, axis=0)
         denominator = np.sqrt(np.sum(lhs**2, axis=0)) * np.sqrt(np.sum(rhs**2, axis=0)) + eps
         return c * np.arccos(numerator / denominator) / np.pi
 
     def _kernel_frechet(self, lhs, rhs, eps, kwargs):
-        sigma1 = kwargs.get('sigma1')
-        sigma2 = kwargs.get('sigma2')
-        assert sigma1 is not None and sigma2 is not None, 'Frechet distance requires covariance matrices for both inputs'
+        sigma1 = kwargs.get("sigma1")
+        sigma2 = kwargs.get("sigma2")
+        assert sigma1 is not None and sigma2 is not None, (
+            "Frechet distance requires covariance matrices for both inputs"
+        )
         return calculate_frechet_distance(lhs.T, sigma1, rhs.T, sigma2, eps)
 
     def _kernel_mmd(self, lhs, rhs, eps, _kwargs):
@@ -2595,13 +2861,15 @@ class EmbeddingPrimitives(Primitive):
 
     def similarity(
         self,
-        other: Union['Symbol', list, np.ndarray, torch.Tensor],
-        metric: Literal['cosine', 'angular-cosine', 'product', 'manhattan', 'euclidean', 'minkowski', 'jaccard'] = 'cosine',
+        other: Union["Symbol", list, np.ndarray, torch.Tensor],
+        metric: Literal[
+            "cosine", "angular-cosine", "product", "manhattan", "euclidean", "minkowski", "jaccard"
+        ] = "cosine",
         eps: float = 1e-8,
         normalize: Callable | None = None,
         **kwargs,
     ) -> float:
-        '''
+        """
         Calculates the similarity between two Symbol objects using a specified metric.
         This method compares the values of two Symbol objects and calculates their similarity according to the specified metric.
         It supports the 'cosine' metric, and raises a NotImplementedError for other metrics.
@@ -2619,7 +2887,7 @@ class EmbeddingPrimitives(Primitive):
         Raises:
             TypeError: If any of the Symbol objects is not of type np.ndarray or Symbol.
             NotImplementedError: If the given metric is not supported.
-        '''
+        """
         v = self._ensure_numpy_format(self)
         o = self._prepare_embedding_operand(other)
         handler = self._get_similarity_handler(metric, eps, kwargs)
@@ -2638,13 +2906,27 @@ class EmbeddingPrimitives(Primitive):
 
     def distance(
         self,
-        other: Union['Symbol', list, np.ndarray, torch.Tensor],
-        kernel: Literal['gaussian', 'rbf', 'laplacian', 'polynomial', 'sigmoid', 'linear', 'cauchy', 't-distribution', 'inverse-multiquadric', 'cosine', 'angular-cosine', 'frechet', 'mmd'] = 'gaussian',
+        other: Union["Symbol", list, np.ndarray, torch.Tensor],
+        kernel: Literal[
+            "gaussian",
+            "rbf",
+            "laplacian",
+            "polynomial",
+            "sigmoid",
+            "linear",
+            "cauchy",
+            "t-distribution",
+            "inverse-multiquadric",
+            "cosine",
+            "angular-cosine",
+            "frechet",
+            "mmd",
+        ] = "gaussian",
         eps: float = 1e-8,
         normalize: Callable | None = None,
         **kwargs,
     ) -> float:
-        '''
+        """
         Calculates the kernel between two Symbol objects.
 
         Args:
@@ -2659,7 +2941,7 @@ class EmbeddingPrimitives(Primitive):
         Raises:
             TypeError: If any of the Symbol objects is not of type np.ndarray or Symbol.
             NotImplementedError: If the given kernel is not supported.
-        '''
+        """
         v = self._ensure_numpy_format(self)
         o = self._prepare_embedding_operand(other)
         handler = self._get_kernel_handler(kernel)
@@ -2673,7 +2955,7 @@ class EmbeddingPrimitives(Primitive):
         return val
 
     def zip(self, **kwargs) -> list[tuple[str, list, dict]]:
-        '''
+        """
         Zips the Symbol's value with its embeddings and a query containing the value.
         This method zips the Symbol's value along with its embeddings and a query containing the value.
 
@@ -2685,19 +2967,19 @@ class EmbeddingPrimitives(Primitive):
 
         Raises:
             ValueError: If the Symbol's value is not a string or list of strings.
-        '''
+        """
         if isinstance(self.value, str):
             self._value = [self.value]
         elif isinstance(self.value, list):
             pass
         else:
-            msg = f'Expected id to be a string, got {type(self.value)}'
+            msg = f"Expected id to be a string, got {type(self.value)}"
             UserMessage(msg)
             raise ValueError(msg)
 
         embeds = self.embed(**kwargs).value
-        idx    = [str(uuid.uuid4()) for _ in range(len(self.value))]
-        query  = [{'text': str(self.value[i])} for i in range(len(self.value))]
+        idx = [str(uuid.uuid4()) for _ in range(len(self.value))]
+        query = [{"text": str(self.value[i])} for i in range(len(self.value))]
 
         # convert embeds to list if it is a tensor or numpy array
         if isinstance(embeds, np.ndarray):
@@ -2709,11 +2991,12 @@ class EmbeddingPrimitives(Primitive):
 
 
 class IOHandlingPrimitives(Primitive):
-    '''
+    """
     This mixin contains functionalities related to input/output operations.
-    '''
-    def input(self, message: str = 'Please add more information', **kwargs) -> 'Symbol':
-        '''
+    """
+
+    def input(self, message: str = "Please add more information", **kwargs) -> "Symbol":
+        """
         Request user input and return a Symbol containing the user input.
 
         Args:
@@ -2734,7 +3017,8 @@ class IOHandlingPrimitives(Primitive):
         >>> [output: 'I was born in 1990'] # if Symbol has a <str> value inputs will be concatenated
 
         # Works identically for the `Expression` class
-        '''
+        """
+
         @core.userinput(**kwargs)
         def _func(_, message) -> str:
             pass
@@ -2742,12 +3026,12 @@ class IOHandlingPrimitives(Primitive):
         res = _func(self, message)
         condition = self.value is not None and isinstance(self.value, str)
 
-        if hasattr(self, 'sym_return_type'):
-            return self.sym_return_type(self.value if condition else '') | res
-        return self._to_type(self.value if condition else '') | self._to_type(res)
+        if hasattr(self, "sym_return_type"):
+            return self.sym_return_type(self.value if condition else "") | res
+        return self._to_type(self.value if condition else "") | self._to_type(res)
 
-    def open(self, path: str | None = None, **kwargs) -> 'Symbol':
-        '''
+    def open(self, path: str | None = None, **kwargs) -> "Symbol":
+        """
         Open a file and store its content in an Expression object as a string.
 
         Args:
@@ -2766,11 +3050,11 @@ class IOHandlingPrimitives(Primitive):
         >>> s = s.open()
 
         # Works identically for the `Expression` class
-        '''
+        """
 
         path = path if path is not None else self.value
         if path is None:
-            msg = 'Path is not provided; either provide a path or set the value of the Symbol to the path'
+            msg = "Path is not provided; either provide a path or set the value of the Symbol to the path"
             UserMessage(msg)
             raise ValueError(msg)
 
@@ -2778,45 +3062,53 @@ class IOHandlingPrimitives(Primitive):
         def _func(_):
             pass
 
-        if hasattr(self, 'sym_return_type'):
+        if hasattr(self, "sym_return_type"):
             return self.sym_return_type(_func(self))
         return self._to_type(_func(self))
 
 
-#@TODO: add tests
+# @TODO: add tests
 class IndexingPrimitives(Primitive):
-    '''
+    """
     This mixin contains functionalities related to indexing symbols locally.
-    '''
-    def config(self, path: str, index_name: str, **kwargs) -> 'Symbol':
-        '''Execute a configuration operation on the index.'''
-        @core.index(prompt=path, index_name=index_name, operation='config', **kwargs)
+    """
+
+    def config(self, path: str, index_name: str, **kwargs) -> "Symbol":
+        """Execute a configuration operation on the index."""
+
+        @core.index(prompt=path, index_name=index_name, operation="config", **kwargs)
         def _func(_):
             pass
+
         return _func(self)
 
-    def add(self, doc: list[str], index_name: str, **kwargs) -> 'Symbol':
-        '''Add an entry to the existing index.'''
-        @core.index(prompt=doc, index_name=index_name, operation='add', **kwargs)
+    def add(self, doc: list[str], index_name: str, **kwargs) -> "Symbol":
+        """Add an entry to the existing index."""
+
+        @core.index(prompt=doc, index_name=index_name, operation="add", **kwargs)
         def _func(_):
             pass
+
         return _func(self)
 
-    def get(self, query: list[str], index_name: str, **kwargs) -> 'Symbol':
-        '''Search the index based on the provided query.'''
-        @core.index(prompt=query, index_name=index_name, operation='search', **kwargs)
+    def get(self, query: list[str], index_name: str, **kwargs) -> "Symbol":
+        """Search the index based on the provided query."""
+
+        @core.index(prompt=query, index_name=index_name, operation="search", **kwargs)
         def _func(_):
             pass
+
         return _func(self)
 
 
 class PersistencePrimitives(Primitive):
-    '''
+    """
     This mixin contains functionalities related to expanding symbols and saving/loading symbols to/from disk.
     Future functionalities in this mixin might include different ways of serialization and deserialization, or more complex expansion techniques etc.
-    '''
+    """
+
     def expand(self, *args, **kwargs) -> str:
-        '''
+        """
         Expand the current Symbol and create a new sub-component.
         The function writes a self-contained function (with all imports) to solve a specific user problem task.
         This method uses the `@core.expand` decorator with a maximum token limit of 2048, and allows additional keyword
@@ -2828,24 +3120,26 @@ class PersistencePrimitives(Primitive):
 
         Returns:
             Symbol: The name of the newly created sub-component.
-        '''
+        """
+
         @core.expand(**kwargs)
-        def _func(_, *args): pass
+        def _func(_, *args):
+            pass
 
         _tmp_llm_func = self._to_type(_func(self, *args))
-        func_name = str(_tmp_llm_func.extract('function name'))
+        func_name = str(_tmp_llm_func.extract("function name"))
 
         def _llm_func(*args, **kwargs):
             res = _tmp_llm_func.fexecute(*args, **kwargs)
 
-            return res['locals'][func_name]()
+            return res["locals"][func_name]()
 
         setattr(self, func_name, _llm_func)
 
         return func_name
 
     def save(self, path: str, replace: bool | None = False, serialize: bool | None = True) -> None:
-        '''
+        """
         Save the current Symbol to a file.
 
         Args:
@@ -2855,29 +3149,29 @@ class PersistencePrimitives(Primitive):
 
         Returns:
             Symbol: The current Symbol.
-        '''
+        """
         file_path = Path(path)
 
         if not replace:
             cnt = 0
             candidate = file_path
             while candidate.exists():
-                candidate = candidate.with_name(f'{file_path.stem}_{cnt}{file_path.suffix}')
+                candidate = candidate.with_name(f"{file_path.stem}_{cnt}{file_path.suffix}")
                 cnt += 1
             file_path = candidate
 
         if serialize:
             # serialize the object via pickle instead of writing the string
             path_str = str(file_path)
-            pickle_path = Path(path_str if path_str.endswith('.pkl') else f'{path_str}.pkl')
-            with pickle_path.open('wb') as f:
+            pickle_path = Path(path_str if path_str.endswith(".pkl") else f"{path_str}.pkl")
+            with pickle_path.open("wb") as f:
                 pickle.dump(self, file=f)
         else:
-            with file_path.open('w') as f:
+            with file_path.open("w") as f:
                 f.write(str(self))
 
     def load(self, path: str) -> Any:
-        '''
+        """
         Load a Symbol from a file.
 
         Args:
@@ -2885,18 +3179,18 @@ class PersistencePrimitives(Primitive):
 
         Returns:
             Symbol: The loaded Symbol.
-        '''
-        with Path(path).open('rb') as f:
+        """
+        with Path(path).open("rb") as f:
             return pickle.load(f)
 
 
 class OutputHandlingPrimitives(Primitive):
-    '''
+    """
     This mixin include functionalities related to outputting symbols. It can be expanded in the future to include different types of output methods or complex output formatting, etc.
-    '''
+    """
 
-    def output(self, *args, **kwargs) -> 'Symbol':
-        '''
+    def output(self, *args, **kwargs) -> "Symbol":
+        """
         Output the current Symbol to an output handler.
         This method uses the `@core.output` decorator and allows additional keyword arguments to be passed to the decorator.
 
@@ -2906,7 +3200,8 @@ class OutputHandlingPrimitives(Primitive):
 
         Returns:
             Symbol: The resulting Symbol after the output operation.
-        '''
+        """
+
         @core.output(**kwargs)
         def _func(_, *_func_args, **_func_kwargs):
             return self.value
@@ -2914,13 +3209,14 @@ class OutputHandlingPrimitives(Primitive):
         return self._to_type(_func(self, self.value, *args))
 
 
-#@TODO: add tests
+# @TODO: add tests
 class FineTuningPrimitives(Primitive):
-    '''
+    """
     This mixin contains functionalities related to fine tuning models.
-    '''
-    def tune(self, operation: str = 'create', **kwargs) -> 'Symbol':
-        '''
+    """
+
+    def tune(self, operation: str = "create", **kwargs) -> "Symbol":
+        """
         Fine tune a base model.
 
         Args:
@@ -2929,20 +3225,22 @@ class FineTuningPrimitives(Primitive):
 
         Returns:
             Symbol: The resulting Symbol containing the fine tuned model ID.
-        '''
+        """
+
         @core.tune(operation=operation, **kwargs)
         def _func(_, *args, **kwargs) -> str:
             pass
+
         return self.sym_return_type(_func(self))
 
     @property
     def data(self) -> torch.Tensor:
-        '''
+        """
         Get the data as a Pytorch tensor.
 
         Returns:
             Any: The data of the symbol.
-        '''
+        """
         # if the data is not yet computed, compute it
         if self._metadata.data is None:
             # compute the data and store as numpy array
@@ -2956,16 +3254,16 @@ class FineTuningPrimitives(Primitive):
             # convert to tensor
             self._metadata.data = torch.from_numpy(self._metadata.data)
             return self._metadata.data
-        msg = f'Expected data to be a tensor or numpy array, got {type(self._metadata.data)}'
+        msg = f"Expected data to be a tensor or numpy array, got {type(self._metadata.data)}"
         UserMessage(msg)
         raise TypeError(msg)
 
     @data.setter
     def data(self, data: torch.Tensor) -> None:
-        '''
+        """
         Set the data of the symbol.
 
         Args:
             data (torch.Tensor): The data to set.
-        '''
+        """
         self._metadata.data = data