semantic-kernel 0.3.7.dev0__tar.gz → 0.3.8.dev0__tar.gz

{semantic_kernel-0.3.7.dev0 → semantic_kernel-0.3.8.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: semantic-kernel
-Version: 0.3.7.dev0
+Version: 0.3.8.dev0
 Summary: 
 Author: Microsoft
 Author-email: SK-Support@microsoft.com

{semantic_kernel-0.3.7.dev0 → semantic_kernel-0.3.8.dev0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "semantic-kernel"
-version = "0.3.7.dev"
+version = "0.3.8.dev"
 description = ""
 authors = ["Microsoft <SK-Support@microsoft.com>"]
 readme = "pip/README.md"
@@ -22,7 +22,7 @@ pre-commit = "3.3.3"
 black = {version = "23.7.0", allow-prereleases = true}
 ipykernel = "^6.21.1"
 pytest = "7.4.0"
-ruff = "0.0.282"
+ruff = "0.0.283"
 pytest-asyncio = "0.21.1"
 
 [tool.poetry.group.hugging_face.dependencies]

{semantic_kernel-0.3.7.dev0 → semantic_kernel-0.3.8.dev0}/semantic_kernel/planning/plan.py

@@ -410,7 +410,7 @@ class Plan(SKFunctionBase):
 
             expanded_value = self.expand_from_variables(variables, param_var)
             if expanded_value.lower() == param_var.lower():
-                step_variables.set(param_var, expanded_value)
+                step_variables.set(param_var, step.parameters._variables[param_var])
             elif variables.contains_key(param_var):
                 step_variables.set(param_var, variables[param_var])
             elif self._state.contains_key(param_var):

semantic_kernel-0.3.8.dev0/semantic_kernel/skill_definition/constants.py

@@ -0,0 +1,3 @@
+import typing as t
+
+GLOBAL_SKILL: t.Final[str] = "_GLOBAL_FUNCTIONS_"

{semantic_kernel-0.3.7.dev0 → semantic_kernel-0.3.8.dev0}/semantic_kernel/skill_definition/read_only_skill_collection.py

@@ -1,39 +1,38 @@
 # Copyright (c) Microsoft. All rights reserved.
 
 from logging import Logger
-from typing import TYPE_CHECKING, Dict, Generic, Literal, Optional, Tuple, TypeVar
+from typing import TYPE_CHECKING, ClassVar, Dict, Optional, Tuple
 
 import pydantic as pdt
 
 from semantic_kernel.kernel_exception import KernelException
-from semantic_kernel.sk_pydantic import SKGenericModel
+from semantic_kernel.orchestration.sk_function import SKFunction
+from semantic_kernel.sk_pydantic import SKBaseModel
+from semantic_kernel.skill_definition import constants
 from semantic_kernel.skill_definition.functions_view import FunctionsView
 from semantic_kernel.skill_definition.read_only_skill_collection_base import (
     ReadOnlySkillCollectionBase,
 )
 from semantic_kernel.utils.null_logger import NullLogger
-from semantic_kernel.utils.static_property import static_property
 
 if TYPE_CHECKING:
     from semantic_kernel.orchestration.sk_function_base import SKFunctionBase
 
 
-SKFunctionT = TypeVar("SKFunctionT", bound="SKFunctionBase")
-
-
-class ReadOnlySkillCollection(
-    SKGenericModel, ReadOnlySkillCollectionBase, Generic[SKFunctionT]
-):
-    data: Dict[str, Dict[str, SKFunctionT]]
+class ReadOnlySkillCollection(SKBaseModel, ReadOnlySkillCollectionBase):
+    GLOBAL_SKILL: ClassVar[str] = constants.GLOBAL_SKILL
+    data: Dict[str, Dict[str, SKFunction]] = pdt.Field(default_factory=dict)
     _log: Logger = pdt.PrivateAttr()
 
     class Config:
         allow_mutation = False
 
     def __init__(
-        self, data: Dict[str, Dict[str, SKFunctionT]], log: Optional[Logger] = None
+        self,
+        data: Dict[str, Dict[str, SKFunction]] = None,
+        log: Optional[Logger] = None,
     ) -> None:
-        super().__init__(data=data)
+        super().__init__(data=data or {})
         self._log = log or NullLogger()
 
     def has_function(self, skill_name: Optional[str], function_name: str) -> bool:
@@ -126,7 +125,3 @@ class ReadOnlySkillCollection(
 
         s_name, f_name = s_name.lower(), f_name.lower()
         return s_name, f_name
-
-    @static_property
-    def GLOBAL_SKILL() -> Literal["_GLOBAL_FUNCTIONS_"]:
-        return "_GLOBAL_FUNCTIONS_"

{semantic_kernel-0.3.7.dev0 → semantic_kernel-0.3.8.dev0}/semantic_kernel/skill_definition/skill_collection.py

@@ -3,16 +3,17 @@
 from logging import Logger
 from typing import (
     TYPE_CHECKING,
+    ClassVar,
     Dict,
-    Generic,
     Optional,
-    TypeVar,
     Union,
 )
 
 import pydantic as pdt
 
+from semantic_kernel.orchestration.sk_function import SKFunction
 from semantic_kernel.sk_pydantic import SKGenericModel
+from semantic_kernel.skill_definition import constants
 from semantic_kernel.skill_definition.functions_view import FunctionsView
 from semantic_kernel.skill_definition.read_only_skill_collection import (
     ReadOnlySkillCollection,
@@ -22,15 +23,13 @@ from semantic_kernel.skill_definition.read_only_skill_collection_base import (
 )
 from semantic_kernel.skill_definition.skill_collection_base import SkillCollectionBase
 from semantic_kernel.utils.null_logger import NullLogger
-from semantic_kernel.utils.static_property import static_property
 
 if TYPE_CHECKING:
     from semantic_kernel.orchestration.sk_function_base import SKFunctionBase
 
-SKFunctionT = TypeVar("SKFunctionT", bound="SKFunctionBase")
 
-
-class SkillCollection(SKGenericModel, SkillCollectionBase, Generic[SKFunctionT]):
+class SkillCollection(SKGenericModel, SkillCollectionBase):
+    GLOBAL_SKILL: ClassVar[str] = constants.GLOBAL_SKILL
     read_only_skill_collection_: ReadOnlySkillCollection = pdt.Field(
         alias="read_only_skill_collection"
     )
@@ -39,7 +38,7 @@ class SkillCollection(SKGenericModel, SkillCollectionBase, Generic[SKFunctionT])
     def __init__(
         self,
         log: Optional[Logger] = None,
-        skill_collection: Union[Dict[str, Dict[str, SKFunctionT]], None] = None,
+        skill_collection: Union[Dict[str, Dict[str, SKFunction]], None] = None,
         read_only_skill_collection_: Optional[ReadOnlySkillCollection] = None,
     ) -> None:
         if skill_collection and read_only_skill_collection_:
@@ -71,10 +70,7 @@ class SkillCollection(SKGenericModel, SkillCollectionBase, Generic[SKFunctionT])
         s_name, f_name = function.skill_name, function.name
         s_name, f_name = s_name.lower(), f_name.lower()
 
-        if s_name not in self.skill_collection:
-            self.skill_collection[s_name] = {}
-
-        self.skill_collection[s_name][f_name] = function
+        self.skill_collection.setdefault(s_name, {})[f_name] = function
 
     def add_native_function(self, function: "SKFunctionBase") -> None:
         if function is None:
@@ -84,10 +80,8 @@ class SkillCollection(SKGenericModel, SkillCollectionBase, Generic[SKFunctionT])
         s_name, f_name = self.read_only_skill_collection_._normalize_names(
             s_name, f_name, True
         )
-        if s_name not in self.skill_collection:
-            self.skill_collection[s_name] = {}
 
-        self.skill_collection[s_name][f_name] = function
+        self.skill_collection.setdefault(s_name, {})[f_name] = function
 
     def has_function(self, skill_name: Optional[str], function_name: str) -> bool:
         return self.read_only_skill_collection_.has_function(skill_name, function_name)
@@ -131,7 +125,3 @@ class SkillCollection(SKGenericModel, SkillCollectionBase, Generic[SKFunctionT])
         self, skill_name: Optional[str], function_name: str
     ) -> "SKFunctionBase":
         return self.read_only_skill_collection_.get_function(skill_name, function_name)
-
-    @static_property
-    def GLOBAL_SKILL():
-        return ReadOnlySkillCollection.GLOBAL_SKILL