semantic-kernel 1.8.3__zip

semantic_kernel-1.8.3/semantic_kernel/data/vector_store_record_utils.py

@@ -0,0 +1,83 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+
+from collections.abc import Callable
+from typing import TYPE_CHECKING, TypeVar
+
+from semantic_kernel.data.vector_store_record_fields import VectorStoreRecordDataField, VectorStoreRecordVectorField
+from semantic_kernel.exceptions.memory_connector_exceptions import VectorStoreModelException
+from semantic_kernel.kernel_types import OneOrMany
+
+if TYPE_CHECKING:
+    from semantic_kernel.connectors.ai.prompt_execution_settings import PromptExecutionSettings
+    from semantic_kernel.data.vector_store_model_definition import VectorStoreRecordDefinition
+    from semantic_kernel.kernel import Kernel
+
+TModel = TypeVar("TModel", bound=object)
+
+
+class VectorStoreRecordUtils:
+    """Helper class to easily add embeddings to a (set of) vector store record."""
+
+    def __init__(self, kernel: "Kernel"):
+        """Initializes the VectorStoreRecordUtils with a kernel."""
+        self.kernel = kernel
+
+    async def add_vector_to_records(
+        self,
+        records: OneOrMany[TModel],
+        data_model_type: type[TModel] | None = None,
+        data_model_definition: "VectorStoreRecordDefinition | None" = None,
+        **kwargs,
+    ) -> OneOrMany[TModel]:
+        """Vectorize the vector record.
+
+        This function can be passed to upsert or upsert batch of a VectorStoreRecordCollection.
+
+        Loops through the fields of the data model definition,
+        looks at data fields, if they have a vector field,
+        looks up that vector field and checks if is a local embedding.
+
+        If so adds that to a list of embeddings to make.
+
+        Finally calls Kernel add_embedding_to_object with the list of embeddings to make.
+
+        Optional arguments are passed onto the Kernel add_embedding_to_object call.
+        """
+        # dict of embedding_field.name and tuple of record, settings, field_name
+        embeddings_to_make: list[tuple[str, str, dict[str, "PromptExecutionSettings"], Callable | None]] = []
+        if not data_model_definition:
+            data_model_definition = getattr(data_model_type, "__kernel_vectorstoremodel_definition__", None)
+        if not data_model_definition:
+            raise VectorStoreModelException(
+                "Data model definition is required, either directly or from the data model type."
+            )
+        for name, field in data_model_definition.fields.items():  # type: ignore
+            if (
+                not isinstance(field, VectorStoreRecordDataField)
+                or not field.has_embedding
+                or not field.embedding_property_name
+            ):
+                continue
+            embedding_field = data_model_definition.fields.get(field.embedding_property_name)
+            if not isinstance(embedding_field, VectorStoreRecordVectorField):
+                raise VectorStoreModelException("Embedding field must be a VectorStoreRecordVectorField")
+            if embedding_field.local_embedding:
+                embeddings_to_make.append((
+                    name,
+                    field.embedding_property_name,
+                    embedding_field.embedding_settings,
+                    embedding_field.deserialize_function,
+                ))
+
+        for field_to_embed, field_to_store, settings, cast_callable in embeddings_to_make:
+            await self.kernel.add_embedding_to_object(
+                inputs=records,
+                field_to_embed=field_to_embed,
+                field_to_store=field_to_store,
+                execution_settings=settings,
+                container_mode=data_model_definition.container_mode,
+                cast_function=cast_callable,
+                **kwargs,
+            )
+        return records

semantic_kernel-1.8.3/semantic_kernel/exceptions/__init__.py

@@ -0,0 +1,10 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+from semantic_kernel.exceptions.agent_exceptions import *  # noqa: F403
+from semantic_kernel.exceptions.content_exceptions import *  # noqa: F403
+from semantic_kernel.exceptions.function_exceptions import *  # noqa: F403
+from semantic_kernel.exceptions.kernel_exceptions import *  # noqa: F403
+from semantic_kernel.exceptions.memory_connector_exceptions import *  # noqa: F403
+from semantic_kernel.exceptions.planner_exceptions import *  # noqa: F403
+from semantic_kernel.exceptions.service_exceptions import *  # noqa: F403
+from semantic_kernel.exceptions.template_engine_exceptions import *  # noqa: F403

semantic_kernel-1.8.3/semantic_kernel/exceptions/agent_exceptions.py

@@ -0,0 +1,40 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+
+from semantic_kernel.exceptions.kernel_exceptions import KernelException
+
+
+class AgentException(KernelException):
+    """Base class for all agent exceptions."""
+
+    pass
+
+
+class AgentFileNotFoundException(AgentException):
+    """The requested file was not found."""
+
+    pass
+
+
+class AgentInitializationException(AgentException):
+    """An error occurred while initializing the agent."""
+
+    pass
+
+
+class AgentExecutionException(AgentException):
+    """An error occurred while executing the agent."""
+
+    pass
+
+
+class AgentInvokeException(AgentException):
+    """An error occurred while invoking the agent."""
+
+    pass
+
+
+class AgentChatException(AgentException):
+    """An error occurred while invoking the agent chat."""
+
+    pass

semantic_kernel-1.8.3/semantic_kernel/exceptions/content_exceptions.py

@@ -0,0 +1,49 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+from semantic_kernel.exceptions.kernel_exceptions import KernelException
+
+
+class ContentException(KernelException):
+    """Base class for all content exceptions."""
+
+    pass
+
+
+class ContentInitializationError(ContentException):
+    """An error occurred while initializing the content."""
+
+    pass
+
+
+class ContentSerializationError(ContentException):
+    """An error occurred while serializing the content."""
+
+    pass
+
+
+class ContentAdditionException(ContentException):
+    """An error occurred while adding content."""
+
+    pass
+
+
+class FunctionCallInvalidNameException(ContentException):
+    """An error occurred while validating the function name."""
+
+    pass
+
+
+class FunctionCallInvalidArgumentsException(ContentException):
+    """An error occurred while validating the function arguments."""
+
+    pass
+
+
+__all__ = [
+    "ContentAdditionException",
+    "ContentException",
+    "ContentInitializationError",
+    "ContentSerializationError",
+    "FunctionCallInvalidArgumentsException",
+    "FunctionCallInvalidNameException",
+]

semantic_kernel-1.8.3/semantic_kernel/exceptions/function_exceptions.py

@@ -0,0 +1,91 @@
+# Copyright (c) Microsoft. All rights reserved.
+from semantic_kernel.exceptions.kernel_exceptions import KernelException
+
+
+class FunctionException(KernelException):
+    """Base class for all function exceptions."""
+
+    pass
+
+
+class FunctionSyntaxError(FunctionException):
+    """Base class for all function syntax exceptions."""
+
+    pass
+
+
+class FunctionInitializationError(FunctionException):
+    """An error occurred while initializing the function."""
+
+    def __init__(self, message: str):
+        """Adds the context of the error to the generic message."""
+        super().__init__("KernelFunction failed to initialize: " + message)
+
+
+class PluginInitializationError(FunctionException):
+    """An error occurred while initializing the plugin."""
+
+    pass
+
+
+class PluginInvalidNameError(FunctionSyntaxError):
+    """An error occurred while validating the plugin name."""
+
+    pass
+
+
+class FunctionInvalidNameError(FunctionSyntaxError):
+    """An error occurred while validating the function name."""
+
+    pass
+
+
+class FunctionInvalidParamNameError(FunctionSyntaxError):
+    """An error occurred while validating the function parameter name."""
+
+    pass
+
+
+class FunctionNameNotUniqueError(FunctionSyntaxError):
+    """An error occurred while validating the function name."""
+
+    pass
+
+
+class FunctionExecutionException(FunctionException):
+    """Base class for all function execution exceptions."""
+
+    pass
+
+
+class FunctionResultError(FunctionException):
+    """An error occurred while validating the function result."""
+
+    pass
+
+
+class FunctionInvalidParameterConfiguration(FunctionException):
+    """An error occurred while validating the function parameter configuration."""
+
+    pass
+
+
+class PromptRenderingException(FunctionException):
+    """An error occurred while rendering a prompt."""
+
+    pass
+
+
+__all__ = [
+    "FunctionException",
+    "FunctionExecutionException",
+    "FunctionInitializationError",
+    "FunctionInvalidNameError",
+    "FunctionInvalidParamNameError",
+    "FunctionNameNotUniqueError",
+    "FunctionResultError",
+    "FunctionSyntaxError",
+    "PluginInitializationError",
+    "PluginInvalidNameError",
+    "PromptRenderingException",
+]

semantic_kernel-1.8.3/semantic_kernel/exceptions/kernel_exceptions.py

@@ -0,0 +1,70 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+
+# Even though there is no strict separation between errors and exceptions in Python, it is a good practice to use:
+# - Exceptions for exceptional conditions that a reasonable application may wish to catch.
+# - Errors for exceptional conditions that are not reasonable to catch.
+# for instance syntax errors in a template should be called ...Error,
+# while rendering of the same template should raise an ...Exception.
+# every error should derive from KernelException (including errors)
+# all raised exceptions should use the raise ... from exc syntax to preserve the original traceback
+
+
+class KernelException(Exception):
+    """The base class for all Semantic Kernel exceptions."""
+
+    pass
+
+
+class KernelServiceNotFoundError(KernelException):
+    """Raised when a service is not found in the kernel."""
+
+    pass
+
+
+class KernelPluginNotFoundError(KernelException):
+    """Raised when a plugin is not found in the kernel."""
+
+    pass
+
+
+class KernelPluginInvalidConfigurationError(KernelException):
+    """Raised when a plugin configuration is invalid."""
+
+    pass
+
+
+class KernelFunctionNotFoundError(KernelException):
+    """Raised when a function is not found in the kernel."""
+
+    pass
+
+
+class KernelFunctionAlreadyExistsError(KernelException):
+    """Raised when a function is already registered in the kernel."""
+
+    pass
+
+
+class KernelInvokeException(KernelException):
+    """Raised when an error occurs while invoking a function in the kernel."""
+
+    pass
+
+
+class OperationCancelledException(KernelException):
+    """Raised when an operation is cancelled."""
+
+    pass
+
+
+__all__ = [
+    "KernelException",
+    "KernelFunctionAlreadyExistsError",
+    "KernelFunctionNotFoundError",
+    "KernelInvokeException",
+    "KernelPluginInvalidConfigurationError",
+    "KernelPluginNotFoundError",
+    "KernelServiceNotFoundError",
+    "OperationCancelledException",
+]

semantic_kernel-1.8.3/semantic_kernel/exceptions/memory_connector_exceptions.py

@@ -0,0 +1,57 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+
+from semantic_kernel.exceptions.kernel_exceptions import KernelException
+
+
+class MemoryConnectorException(KernelException):
+    """Base class for all memory connector exceptions."""
+
+    pass
+
+
+class VectorStoreModelException(MemoryConnectorException):
+    """Base class for all vector store model exceptions."""
+
+    pass
+
+
+class VectorStoreModelSerializationException(VectorStoreModelException):
+    """An error occurred while serializing the vector store model."""
+
+    pass
+
+
+class VectorStoreModelDeserializationException(VectorStoreModelException):
+    """An error occurred while deserializing the vector store model."""
+
+    pass
+
+
+class MemoryConnectorInitializationError(MemoryConnectorException):
+    """An error occurred while initializing the memory connector."""
+
+    pass
+
+
+class MemoryConnectorResourceNotFound(MemoryConnectorException):
+    """The requested resource was not found in the memory connector."""
+
+    pass
+
+
+class VectorStoreModelValidationError(VectorStoreModelException):
+    """An error occurred while validating the vector store model."""
+
+    pass
+
+
+__all__ = [
+    "MemoryConnectorException",
+    "MemoryConnectorInitializationError",
+    "MemoryConnectorResourceNotFound",
+    "VectorStoreModelDeserializationException",
+    "VectorStoreModelException",
+    "VectorStoreModelSerializationException",
+    "VectorStoreModelValidationError",
+]

semantic_kernel-1.8.3/semantic_kernel/exceptions/planner_exceptions.py

@@ -0,0 +1,50 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+
+from semantic_kernel.exceptions.kernel_exceptions import KernelException
+
+
+class PlannerException(KernelException):
+    """Base class for all planner exceptions."""
+
+    pass
+
+
+class PlannerExecutionException(PlannerException):
+    """Base class for all planner execution exceptions."""
+
+    pass
+
+
+class PlannerInvalidGoalError(PlannerException):
+    """An error occurred while validating the goal."""
+
+    pass
+
+
+class PlannerInvalidPlanError(PlannerException):
+    """An error occurred while validating the plan."""
+
+    pass
+
+
+class PlannerInvalidConfigurationError(PlannerException):
+    """An error occurred while validating the configuration."""
+
+    pass
+
+
+class PlannerCreatePlanError(PlannerException):
+    """An error occurred while creating the plan."""
+
+    pass
+
+
+__all__ = [
+    "PlannerCreatePlanError",
+    "PlannerException",
+    "PlannerExecutionException",
+    "PlannerInvalidConfigurationError",
+    "PlannerInvalidGoalError",
+    "PlannerInvalidPlanError",
+]

semantic_kernel-1.8.3/semantic_kernel/exceptions/service_exceptions.py

@@ -0,0 +1,78 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+
+from semantic_kernel.exceptions.kernel_exceptions import KernelException
+
+
+class ServiceException(KernelException):
+    """Base class for all service exceptions."""
+
+    pass
+
+
+class ServiceInitializationError(ServiceException):
+    """An error occurred while initializing the service."""
+
+    pass
+
+
+class ServiceResponseException(ServiceException):
+    """Base class for all service response exceptions."""
+
+    pass
+
+
+class ServiceInvalidAuthError(ServiceException):
+    """An error occurred while authenticating the service."""
+
+    pass
+
+
+class ServiceInvalidTypeError(ServiceResponseException):
+    """An error occurred while validating the type of the service request."""
+
+    pass
+
+
+class ServiceInvalidRequestError(ServiceResponseException):
+    """An error occurred while validating the request to the service."""
+
+    pass
+
+
+class ServiceInvalidResponseError(ServiceResponseException):
+    """An error occurred while validating the response from the service."""
+
+    pass
+
+
+class ServiceInvalidExecutionSettingsError(ServiceResponseException):
+    """An error occurred while validating the execution settings of the service."""
+
+    pass
+
+
+class ServiceContentFilterException(ServiceResponseException):
+    """An error was raised by the content filter of the service."""
+
+    pass
+
+
+class ServiceResourceNotFoundError(ServiceException):
+    """The request service could not be found."""
+
+    pass
+
+
+__all__ = [
+    "ServiceContentFilterException",
+    "ServiceException",
+    "ServiceInitializationError",
+    "ServiceInvalidAuthError",
+    "ServiceInvalidExecutionSettingsError",
+    "ServiceInvalidRequestError",
+    "ServiceInvalidResponseError",
+    "ServiceInvalidTypeError",
+    "ServiceResourceNotFoundError",
+    "ServiceResponseException",
+]

semantic_kernel-1.8.3/semantic_kernel/exceptions/template_engine_exceptions.py

@@ -0,0 +1,154 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+
+from semantic_kernel.exceptions.kernel_exceptions import KernelException
+
+
+class BlockException(KernelException):
+    """Base class for all block exceptions."""
+
+    pass
+
+
+class BlockSyntaxError(BlockException):
+    """A invalid block syntax was found."""
+
+    pass
+
+
+class BlockRenderException(BlockException):
+    """An error occurred while rendering a block."""
+
+    pass
+
+
+class VarBlockSyntaxError(BlockSyntaxError):
+    """A invalid VarBlock syntax was found."""
+
+    def __init__(self, content: str) -> None:
+        """Adds the context of the error to the generic message."""
+        super().__init__(
+            f"A VarBlock starts with a '$' followed by at least one letter, \
+number or underscore, anything else is invalid. \
+The content provided was: {content}",
+        )
+
+
+class VarBlockRenderError(BlockRenderException):
+    """An error occurred while rendering a VarBlock."""
+
+    pass
+
+
+class ValBlockSyntaxError(BlockSyntaxError):
+    """A invalid ValBlock syntax was found."""
+
+    def __init__(self, content: str) -> None:
+        """Adds the context of the error to the generic message."""
+        super().__init__(
+            f"A ValBlock starts with a single or double quote followed by at least one letter, \
+finishing with the same type of quote as the first one. \
+The content provided was: {content}",
+        )
+
+
+class NamedArgBlockSyntaxError(BlockSyntaxError):
+    """A invalid NamedArgBlock syntax was found."""
+
+    def __init__(self, content: str) -> None:
+        """Adds the context of the error to the generic message."""
+        super().__init__(
+            f"A NamedArgBlock starts with a name (letters, numbers or underscore) \
+followed by a single equal sign, then the value of the argument, \
+which can either be a VarBlock (starting with '$') \
+or a ValBlock (text surrounded by quotes). \
+The content provided was: {content}",
+        )
+
+
+class FunctionIdBlockSyntaxError(BlockSyntaxError):
+    """A invalid FunctionIdBlock syntax was found."""
+
+    def __init__(self, content: str) -> None:
+        """Adds the context of the error to the generic message."""
+        super().__init__(
+            f"A FunctionIdBlock is composed of either a plugin name and \
+function name separated by a single dot, or just a function name. \
+Both plugin and function names can only contain letters, numbers and underscores. \
+The content provided was: {content}",
+        )
+
+
+class CodeBlockSyntaxError(BlockSyntaxError):
+    """A invalid CodeBlock syntax was found."""
+
+    pass
+
+
+class CodeBlockTokenError(BlockException):
+    """An error occurred while tokenizing a CodeBlock."""
+
+    pass
+
+
+class CodeBlockRenderException(BlockRenderException):
+    """An error occurred while rendering a CodeBlock."""
+
+    pass
+
+
+class TemplateSyntaxError(BlockSyntaxError):
+    """A invalid Template syntax was found."""
+
+    pass
+
+
+class TemplateRenderException(BlockRenderException):
+    """An error occurred while rendering a Template."""
+
+    pass
+
+
+class HandlebarsTemplateSyntaxError(BlockSyntaxError):
+    """A invalid HandlebarsTemplate syntax was found."""
+
+    pass
+
+
+class HandlebarsTemplateRenderException(BlockRenderException):
+    """An error occurred while rendering a HandlebarsTemplate."""
+
+    pass
+
+
+class Jinja2TemplateSyntaxError(BlockSyntaxError):
+    """A invalid Jinja2Template syntax was found."""
+
+    pass
+
+
+class Jinja2TemplateRenderException(BlockRenderException):
+    """An error occurred while rendering a Jinja2Template."""
+
+    pass
+
+
+__all__ = [
+    "BlockException",
+    "BlockRenderException",
+    "BlockSyntaxError",
+    "CodeBlockRenderException",
+    "CodeBlockSyntaxError",
+    "CodeBlockTokenError",
+    "FunctionIdBlockSyntaxError",
+    "HandlebarsTemplateRenderException",
+    "HandlebarsTemplateSyntaxError",
+    "Jinja2TemplateRenderException",
+    "Jinja2TemplateSyntaxError",
+    "NamedArgBlockSyntaxError",
+    "TemplateRenderException",
+    "TemplateSyntaxError",
+    "ValBlockSyntaxError",
+    "VarBlockRenderError",
+    "VarBlockSyntaxError",
+]