mlrun 1.6.0rc6__py3-none-any.whl → 1.6.0rc8__py3-none-any.whl

mlrun/package/packager.py

@@ -12,9 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-import pathlib
-import tempfile
-from abc import ABC, ABCMeta, abstractmethod
+from abc import ABC, abstractmethod
 from pathlib import Path
 from typing import Any, List, Tuple, Type, Union
 
@@ -24,53 +22,9 @@ from mlrun.datastore import DataItem
 from .utils import TypeHintUtils
 
 
-# TODO: When 3.7 is no longer supported, add "Packager" as reference type hint to cls (cls: Type["Packager"]) and other.
-class _PackagerMeta(ABCMeta):
+class Packager(ABC):
     """
-    Metaclass for `Packager` to override type class methods.
-    """
-
-    def __lt__(cls, other) -> bool:
-        """
-        A less than implementation to compare by priority in order to be able to sort the packagers by it.
-
-        :param other: The compared packager.
-
-        :return: True if priority is lower (means better) and False otherwise.
-        """
-        return cls.PRIORITY < other.PRIORITY
-
-    def __repr__(cls) -> str:
-        """
-        Get the string representation of a packager in the following format:
-        <packager name>(type=<handled type>, artifact_types=[<all supported artifact types>], priority=<priority>)
-
-        :return: The string representation of e packager.
-        """
-        # Get the packager info into variables:
-        packager_name = cls.__name__
-        handled_type = (
-            (
-                # Types have __name__ attribute but typing's types do not.
-                cls.PACKABLE_OBJECT_TYPE.__name__
-                if hasattr(cls.PACKABLE_OBJECT_TYPE, "__name__")
-                else str(cls.PACKABLE_OBJECT_TYPE)
-            )
-            if cls.PACKABLE_OBJECT_TYPE is not ...
-            else "Any"
-        )
-        supported_artifact_types = cls.get_supported_artifact_types()
-
-        # Return the string representation in the format noted above:
-        return (
-            f"{packager_name}(packable_type={handled_type}, artifact_types={supported_artifact_types}, "
-            f"priority={cls.PRIORITY})"
-        )
-
-
-class Packager(ABC, metaclass=_PackagerMeta):
-    """
-    The abstract base class for a packager. A packager is a static class that has two main duties:
+    The abstract base class for a packager. Packager has two main duties:
 
     1. **Packing** - get an object that was returned from a function and log it to MLRun. The user can specify packing
        configurations to the packager using log hints. The packed object can be an artifact or a result.
@@ -134,7 +88,7 @@ class Packager(ABC, metaclass=_PackagerMeta):
         with open("./some_file.txt", "w") as file:
             file.write("Pack me")
         artifact = Artifact(key="my_artifact")
-        cls.add_future_clearing_path(path="./some_file.txt")
+        self.add_future_clearing_path(path="./some_file.txt")
         return artifact, None
     """
 
@@ -144,12 +98,16 @@ class Packager(ABC, metaclass=_PackagerMeta):
     #: The priority of this packager in the packagers collection of the manager (lower is better).
     PRIORITY: int = ...
 
-    # List of all paths to be deleted by the manager of this packager after logging the packages:
-    _CLEARING_PATH_LIST: List[str] = []
+    def __init__(self):
+        # Assign the packager's priority (notice that if it is equal to `...` then it will bbe overriden by the packager
+        # manager when collected):
+        self._priority = Packager.PRIORITY
+
+        # List of all paths to be deleted by the manager of this packager after logging the packages:
+        self._future_clearing_path_list: List[str] = []
 
-    @classmethod
     @abstractmethod
-    def get_default_packing_artifact_type(cls, obj: Any) -> str:
+    def get_default_packing_artifact_type(self, obj: Any) -> str:
         """
         Get the default artifact type used for packing. The method is used when an object is sent for packing
         without an artifact type noted by the user.
@@ -160,9 +118,8 @@ class Packager(ABC, metaclass=_PackagerMeta):
         """
         pass
 
-    @classmethod
     @abstractmethod
-    def get_default_unpacking_artifact_type(cls, data_item: DataItem) -> str:
+    def get_default_unpacking_artifact_type(self, data_item: DataItem) -> str:
         """
         Get the default artifact type used for unpacking a data item holding an object of this packager. The method
         is used when a data item is sent for unpacking without it being a package, but is a simple url or an old
@@ -174,9 +131,8 @@ class Packager(ABC, metaclass=_PackagerMeta):
         """
         pass
 
-    @classmethod
     @abstractmethod
-    def get_supported_artifact_types(cls) -> List[str]:
+    def get_supported_artifact_types(self) -> List[str]:
         """
         Get all the supported artifact types on this packager.
 
@@ -184,10 +140,9 @@ class Packager(ABC, metaclass=_PackagerMeta):
         """
         pass
 
-    @classmethod
     @abstractmethod
     def pack(
-        cls,
+        self,
         obj: Any,
         key: str = None,
         artifact_type: str = None,
@@ -206,10 +161,9 @@ class Packager(ABC, metaclass=_PackagerMeta):
         """
         pass
 
-    @classmethod
     @abstractmethod
     def unpack(
-        cls,
+        self,
         data_item: DataItem,
         artifact_type: str = None,
         instructions: dict = None,
@@ -225,9 +179,8 @@ class Packager(ABC, metaclass=_PackagerMeta):
         """
         pass
 
-    @classmethod
     def is_packable(
-        cls, obj: Any, artifact_type: str = None, configurations: dict = None
+        self, obj: Any, artifact_type: str = None, configurations: dict = None
     ) -> bool:
         """
         Check if this packager can pack an object of the provided type as the provided artifact type.
@@ -247,20 +200,19 @@ class Packager(ABC, metaclass=_PackagerMeta):
 
         # Validate the object type (ellipses means any type):
         if (
-            cls.PACKABLE_OBJECT_TYPE is not ...
-            and object_type != cls.PACKABLE_OBJECT_TYPE
+            self.PACKABLE_OBJECT_TYPE is not ...
+            and object_type != self.PACKABLE_OBJECT_TYPE
         ):
             return False
 
         # Validate the artifact type (if given):
-        if artifact_type and artifact_type not in cls.get_supported_artifact_types():
+        if artifact_type and artifact_type not in self.get_supported_artifact_types():
             return False
 
         return True
 
-    @classmethod
     def is_unpackable(
-        cls, data_item: DataItem, type_hint: Type, artifact_type: str = None
+        self, data_item: DataItem, type_hint: Type, artifact_type: str = None
     ) -> bool:
         """
         Check if this packager can unpack an input according to the user-given type hint and the provided artifact type.
@@ -275,44 +227,118 @@ class Packager(ABC, metaclass=_PackagerMeta):
         :return: True if unpackable and False otherwise.
         """
         # Check type (ellipses means any type):
-        if cls.PACKABLE_OBJECT_TYPE is not ...:
+        if self.PACKABLE_OBJECT_TYPE is not ...:
             if not TypeHintUtils.is_matching(
                 object_type=type_hint,  # The type hint is the expected object type the MLRun function wants.
-                type_hint=cls.PACKABLE_OBJECT_TYPE,
+                type_hint=self.PACKABLE_OBJECT_TYPE,
                 reduce_type_hint=False,
             ):
                 return False
 
         # Check the artifact type:
-        if artifact_type and artifact_type not in cls.get_supported_artifact_types():
+        if artifact_type and artifact_type not in self.get_supported_artifact_types():
             return False
 
         # Unpackable:
         return True
 
-    @classmethod
-    def add_future_clearing_path(
-        cls, path: Union[str, Path], add_temp_paths_only: bool = True
-    ):
+    def add_future_clearing_path(self, path: Union[str, Path]):
         """
         Mark a path to be cleared by this packager's manager after logging the packaged artifacts.
 
-        :param path:                The path to clear.
-        :param add_temp_paths_only: Whether to add only temporary files. When running locally on local files
-                                    ``DataItem.local()`` returns the local given path, which should not be deleted.
-                                    This flag helps to avoid deleting files in that scenario.
+        :param path: The path to clear post logging the artifacts.
+        """
+        self._future_clearing_path_list.append(str(path))
+
+    @property
+    def priority(self) -> int:
+        """
+        Get the packager's priority.
+
+        :return: The packager's priority.
+        """
+        return self._priority
+
+    @priority.setter
+    def priority(self, priority: int):
         """
-        if add_temp_paths_only:
-            if pathlib.Path(path).is_relative_to(tempfile.gettempdir()):
-                cls._CLEARING_PATH_LIST.append(str(path))
-            return
-        cls._CLEARING_PATH_LIST.append(str(path))
-
-    @classmethod
-    def get_future_clearing_path_list(cls) -> List[str]:
+        Set the packager's priority.
+
+        :param priority: The priority to set.
+        """
+        self._priority = priority
+
+    @property
+    def future_clearing_path_list(self) -> List[str]:
         """
         Get the packager's future clearing path list.
 
         :return: The clearing path list.
         """
-        return cls._CLEARING_PATH_LIST
+        return self._future_clearing_path_list
+
+    def __lt__(self, other: "Packager") -> bool:
+        """
+        A less than implementation to compare by priority in order to be able to sort the packagers by it.
+
+        :param other: The compared packager.
+
+        :return: True if priority is lower (means better) and False otherwise.
+        """
+        return self.priority < other.priority
+
+    def __repr__(self) -> str:
+        """
+        Get the string representation of a packager in the following format:
+        <packager name>(type=<handled type>, artifact_types=[<all supported artifact types>], priority=<priority>)
+
+        :return: The string representation of e packager.
+        """
+        # Get the packager info into variables:
+        packager_name = self.__class__.__name__
+        handled_type = (
+            (
+                # Types have __name__ attribute but typing's types do not.
+                self.PACKABLE_OBJECT_TYPE.__name__
+                if hasattr(self.PACKABLE_OBJECT_TYPE, "__name__")
+                else str(self.PACKABLE_OBJECT_TYPE)
+            )
+            if self.PACKABLE_OBJECT_TYPE is not ...
+            else "Any"
+        )
+        supported_artifact_types = self.get_supported_artifact_types()
+
+        # Return the string representation in the format noted above:
+        return (
+            f"{packager_name}(packable_type={handled_type}, artifact_types={supported_artifact_types}, "
+            f"priority={self.priority})"
+        )
+
+    def get_data_item_local_path(
+        self, data_item: DataItem, add_to_future_clearing_path: bool = None
+    ) -> str:
+        """
+        Get the local path to the item handled by the data item provided. The local path can be the same as the data
+        item in case the data item points to a local path, or will be downloaded to a temporary directory and return
+        this newly created temporary local path.
+
+        :param data_item:                   The data item to get its item local path.
+        :param add_to_future_clearing_path: Whether to add the local path to the future clearing paths list. If None, it
+                                            will add the path to the list only if the data item is not of kind 'file',
+                                            meaning it represents a local file and hence we don't want to delete it post
+                                            running automatically. We wish to delete it only if the local path is
+                                            temporary (and that will be in case kind is not 'file', so it is being
+                                            downloaded to a temporary directory).
+
+        :return: The data item local path.
+        """
+        # Get the local path to the item handled by the data item (download it to temporary if not local already):
+        local_path = data_item.local()
+
+        # Check if needed to add to the future clear list:
+        if add_to_future_clearing_path or (
+            add_to_future_clearing_path is None and data_item.kind != "file"
+        ):
+            self.add_future_clearing_path(path=local_path)
+
+        return local_path

mlrun/package/packagers/default_packager.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 #
 import inspect
+from abc import ABCMeta
 from types import MethodType
 from typing import Any, List, Tuple, Type, Union
 
@@ -23,11 +24,11 @@ from mlrun.datastore import DataItem
 from mlrun.utils import logger
 
 from ..errors import MLRunPackagePackingError, MLRunPackageUnpackingError
-from ..packager import Packager, _PackagerMeta
+from ..packager import Packager
 from ..utils import DEFAULT_PICKLE_MODULE, ArtifactType, Pickler, TypeHintUtils
 
 
-class _DefaultPackagerMeta(_PackagerMeta):
+class _DefaultPackagerMeta(ABCMeta):
     """
     Metaclass for `DefaultPackager` to override `__doc__` attribute into a class property. This way sphinx will get a
     dynamically generated docstring that will include a summary of the packager.
@@ -50,7 +51,7 @@ class _DefaultPackagerMeta(_PackagerMeta):
         return super().__new__(mcls, name, bases, namespace, **kwargs)
 
     @property
-    def __doc__(cls) -> str:
+    def __doc__(cls: Type["DefaultPackager"]) -> str:
         """
         Override the `__doc__` attribute of a `DefaultPackager` to be a property in order to auto-summarize the
         packager's class docstring. The summary is concatenated after the original class doc string.
@@ -86,6 +87,13 @@ class _DefaultPackagerMeta(_PackagerMeta):
 
         :returns: The original docstring with the generated packager summary.
         """
+        # Create a packager instance:
+        packager = cls()
+
+        # Get the packager's name and module:
+        packager_name = packager.__class__.__name__
+        packager_module = packager.__module__
+
         # Get the original packager class doc string:
         packager_doc_string = cls._packager_doc.split("\n")
         packager_doc_string = "\n".join(line[4:] for line in packager_doc_string)
@@ -93,21 +101,23 @@ class _DefaultPackagerMeta(_PackagerMeta):
         # Parse the packable type section:
         type_name = (
             "Any type"
-            if cls.PACKABLE_OBJECT_TYPE is ...
+            if packager.PACKABLE_OBJECT_TYPE is ...
             else (
-                f"``{str(cls.PACKABLE_OBJECT_TYPE)}``"
-                if TypeHintUtils.is_typing_type(type_hint=cls.PACKABLE_OBJECT_TYPE)
-                else f"``{cls.PACKABLE_OBJECT_TYPE.__module__}.{cls.PACKABLE_OBJECT_TYPE.__name__}``"
+                f"``{str(packager.PACKABLE_OBJECT_TYPE)}``"
+                if TypeHintUtils.is_typing_type(type_hint=packager.PACKABLE_OBJECT_TYPE)
+                else f"``{packager.PACKABLE_OBJECT_TYPE.__module__}.{packager.PACKABLE_OBJECT_TYPE.__name__}``"
             )
         )
         packing_type = f"**Packing Type**: {type_name}"
 
         # Subclasses support section:
-        packing_sub_classes = f"**Packing Sub-Classes**: {cls.PACK_SUBCLASSES}"
+        packing_sub_classes = f"**Packing Sub-Classes**: {packager.PACK_SUBCLASSES}"
 
         # Priority section:
         priority_value = (
-            cls.PRIORITY if cls.PRIORITY is not ... else "Default priority (5)"
+            packager.priority
+            if packager.priority is not ...
+            else "Default priority (5)"
         )
         priority = f"**Priority**: {priority_value}"
 
@@ -117,9 +127,13 @@ class _DefaultPackagerMeta(_PackagerMeta):
             method_name = f"get_{pack_or_unpack}"
             argument_name = pack_or_unpack.upper()
             return (
-                getattr(cls, argument_name)
-                if cls.__name__ == "DefaultPackager" or method_name not in cls.__dict__
-                else f"Refer to the packager's :py:meth:`~{cls.__module__}.{cls.__name__}.{method_name}` method."
+                getattr(packager, argument_name)
+                if packager_name == "DefaultPackager"
+                or method_name not in packager.__class__.__dict__
+                else (
+                    f"Refer to the packager's "
+                    f":py:meth:`~{packager_module}.{packager_name}.{method_name}` method."
+                )
             )
 
         default_artifact_types = (
@@ -130,17 +144,17 @@ class _DefaultPackagerMeta(_PackagerMeta):
 
         # Artifact types section:
         artifact_types = "**Artifact Types**:"
-        for artifact_type in cls.get_supported_artifact_types():
+        for artifact_type in packager.get_supported_artifact_types():
             # Get the packing method docstring:
             method_doc = docstring_parser.parse(
-                getattr(cls, f"pack_{artifact_type}").__doc__
+                getattr(packager, f"pack_{artifact_type}").__doc__
             )
             # Add the artifact type bullet:
             artifact_type_doc = f"{method_doc.short_description or ''}{method_doc.long_description or ''}".replace(
                 "\n", ""
             )
             artifact_types += (
-                f"\n\n* :py:meth:`{artifact_type}<{cls.__module__}.{cls.__name__}.pack_{artifact_type}>` - "
+                f"\n\n* :py:meth:`{artifact_type}<{packager_module}.{packager_name}.pack_{artifact_type}>` - "
                 + artifact_type_doc
             )
             # Add the artifact type configurations (ignoring the `obj` and `key` parameters):
@@ -189,8 +203,7 @@ class DefaultPackager(Packager, metaclass=_DefaultPackagerMeta):
       the artifact type was not provided, it uses the default). For example: if the artifact type is `x` then
       the class method ``pack_x`` must be implemented. The signature of each pack class method must be::
 
-          @classmethod
-          def pack_x(cls, obj: Any, key: str, ...) -> Union[Tuple[Artifact, dict], dict]:
+          def pack_x(self, obj: Any, key: str, ...) -> Union[Tuple[Artifact, dict], dict]:
               pass
 
       Where 'x' is the artifact type, 'obj' is the object to pack, `key` is the key to name the artifact and `...` are
@@ -205,8 +218,7 @@ class DefaultPackager(Packager, metaclass=_DefaultPackagerMeta):
       For example: if the artifact type stored within the ``DataItem`` is `x` then the class method
       ``unpack_x`` must be implemented. The signature of each unpack class method must be::
 
-          @classmethod
-          def unpack_x(cls, data_item: mlrun.DataItem, ...) -> Any:
+          def unpack_x(self, data_item: mlrun.DataItem, ...) -> Any:
               pass
 
       Where 'x' is the artifact type, 'data_item' is the artifact's data item to unpack, `...` are the instructions that
@@ -255,7 +267,7 @@ class DefaultPackager(Packager, metaclass=_DefaultPackagerMeta):
           with open("./some_file.txt", "w") as file:
               file.write("Pack me")
           artifact = Artifact(key="my_artifact")
-          cls.future_clear(path="./some_file.txt")
+          self.add_future_clearing_path(path="./some_file.txt")
           return artifact, None
 
     """
@@ -272,8 +284,7 @@ class DefaultPackager(Packager, metaclass=_DefaultPackagerMeta):
     #: The default artifact type to unpack from.
     DEFAULT_UNPACKING_ARTIFACT_TYPE = ArtifactType.OBJECT
 
-    @classmethod
-    def get_default_packing_artifact_type(cls, obj: Any) -> str:
+    def get_default_packing_artifact_type(self, obj: Any) -> str:
         """
         Get the default artifact type for packing an object of this packager.
 
@@ -281,10 +292,9 @@ class DefaultPackager(Packager, metaclass=_DefaultPackagerMeta):
 
         :return: The default artifact type.
         """
-        return cls.DEFAULT_PACKING_ARTIFACT_TYPE
+        return self.DEFAULT_PACKING_ARTIFACT_TYPE
 
-    @classmethod
-    def get_default_unpacking_artifact_type(cls, data_item: DataItem) -> str:
+    def get_default_unpacking_artifact_type(self, data_item: DataItem) -> str:
         """
         Get the default artifact type used for unpacking a data item holding an object of this packager. The method
         is used when a data item is sent for unpacking without it being a package, but is a simple url or an old /
@@ -294,10 +304,9 @@ class DefaultPackager(Packager, metaclass=_DefaultPackagerMeta):
 
         :return: The default artifact type.
         """
-        return cls.DEFAULT_UNPACKING_ARTIFACT_TYPE
+        return self.DEFAULT_UNPACKING_ARTIFACT_TYPE
 
-    @classmethod
-    def get_supported_artifact_types(cls) -> List[str]:
+    def get_supported_artifact_types(self) -> List[str]:
         """
         Get all the supported artifact types on this packager.
 
@@ -307,13 +316,12 @@ class DefaultPackager(Packager, metaclass=_DefaultPackagerMeta):
         # unpacked. Result has no unpacking so we add it separately.
         return [
             key[len("pack_") :]
-            for key in dir(cls)
-            if key.startswith("pack_") and f"unpack_{key[len('pack_'):]}" in dir(cls)
+            for key in dir(self)
+            if key.startswith("pack_") and f"unpack_{key[len('pack_'):]}" in dir(self)
         ] + ["result"]
 
-    @classmethod
     def pack(
-        cls,
+        self,
         obj: Any,
         key: str = None,
         artifact_type: str = None,
@@ -332,16 +340,16 @@ class DefaultPackager(Packager, metaclass=_DefaultPackagerMeta):
         """
         # Get default artifact type in case it was not provided:
         if artifact_type is None:
-            artifact_type = cls.get_default_packing_artifact_type(obj=obj)
+            artifact_type = self.get_default_packing_artifact_type(obj=obj)
 
         # Set empty dictionary in case no configurations were given:
         configurations = configurations or {}
 
         # Get the packing method according to the artifact type:
-        pack_method = getattr(cls, f"pack_{artifact_type}")
+        pack_method = getattr(self, f"pack_{artifact_type}")
 
         # Validate correct configurations were passed:
-        cls._validate_method_arguments(
+        self._validate_method_arguments(
             method=pack_method,
             arguments=configurations,
             is_packing=True,
@@ -350,9 +358,8 @@ class DefaultPackager(Packager, metaclass=_DefaultPackagerMeta):
         # Call the packing method and return the package:
         return pack_method(obj=obj, key=key, **configurations)
 
-    @classmethod
     def unpack(
-        cls,
+        self,
         data_item: DataItem,
         artifact_type: str = None,
         instructions: dict = None,
@@ -371,16 +378,18 @@ class DefaultPackager(Packager, metaclass=_DefaultPackagerMeta):
         """
         # Get default artifact type in case it was not provided:
         if artifact_type is None:
-            artifact_type = cls.get_default_unpacking_artifact_type(data_item=data_item)
+            artifact_type = self.get_default_unpacking_artifact_type(
+                data_item=data_item
+            )
 
         # Set empty dictionary in case no instructions were given:
         instructions = instructions or {}
 
         # Get the unpacking method according to the artifact type:
-        unpack_method = getattr(cls, f"unpack_{artifact_type}")
+        unpack_method = getattr(self, f"unpack_{artifact_type}")
 
         # Validate correct instructions were passed:
-        cls._validate_method_arguments(
+        self._validate_method_arguments(
             method=unpack_method,
             arguments=instructions,
             is_packing=False,
@@ -389,9 +398,8 @@ class DefaultPackager(Packager, metaclass=_DefaultPackagerMeta):
         # Call the unpacking method and return the object:
         return unpack_method(data_item, **instructions)
 
-    @classmethod
     def is_packable(
-        cls, obj: Any, artifact_type: str = None, configurations: dict = None
+        self, obj: Any, artifact_type: str = None, configurations: dict = None
     ) -> bool:
         """
         Check if this packager can pack an object of the provided type as the provided artifact type.
@@ -410,11 +418,11 @@ class DefaultPackager(Packager, metaclass=_DefaultPackagerMeta):
         object_type = type(obj)
 
         # Check type (ellipses means any type):
-        if cls.PACKABLE_OBJECT_TYPE is not ...:
+        if self.PACKABLE_OBJECT_TYPE is not ...:
             if not TypeHintUtils.is_matching(
                 object_type=object_type,
-                type_hint=cls.PACKABLE_OBJECT_TYPE,
-                include_subclasses=cls.PACK_SUBCLASSES,
+                type_hint=self.PACKABLE_OBJECT_TYPE,
+                include_subclasses=self.PACK_SUBCLASSES,
                 reduce_type_hint=False,
             ):
                 return False
@@ -422,16 +430,15 @@ class DefaultPackager(Packager, metaclass=_DefaultPackagerMeta):
         # Check the artifact type:
         if (
             artifact_type is not None
-            and artifact_type not in cls.get_supported_artifact_types()
+            and artifact_type not in self.get_supported_artifact_types()
         ):
             return False
 
         # Packable:
         return True
 
-    @classmethod
     def pack_object(
-        cls,
+        self,
         obj: Any,
         key: str,
         pickle_module_name: str = DEFAULT_PICKLE_MODULE,
@@ -454,12 +461,11 @@ class DefaultPackager(Packager, metaclass=_DefaultPackagerMeta):
         artifact = Artifact(key=key, src_path=pickle_path)
 
         # Add the pickle path to the clearing list:
-        cls.add_future_clearing_path(path=pickle_path)
+        self.add_future_clearing_path(path=pickle_path)
 
         return artifact, instructions
 
-    @classmethod
-    def pack_result(cls, obj: Any, key: str) -> dict:
+    def pack_result(self, obj: Any, key: str) -> dict:
         """
         Pack an object as a result.
 
@@ -470,9 +476,8 @@ class DefaultPackager(Packager, metaclass=_DefaultPackagerMeta):
         """
         return {key: obj}
 
-    @classmethod
     def unpack_object(
-        cls,
+        self,
         data_item: DataItem,
         pickle_module_name: str = DEFAULT_PICKLE_MODULE,
         object_module_name: str = None,
@@ -500,10 +505,7 @@ class DefaultPackager(Packager, metaclass=_DefaultPackagerMeta):
         :return: The un-pickled python object.
         """
         # Get the pkl file to local directory:
-        pickle_path = data_item.local()
-
-        # Add the pickle path to the clearing list:
-        cls.add_future_clearing_path(path=pickle_path)
+        pickle_path = self.get_data_item_local_path(data_item=data_item)
 
         # Unpickle and return:
         return Pickler.unpickle(
@@ -515,9 +517,8 @@ class DefaultPackager(Packager, metaclass=_DefaultPackagerMeta):
             object_module_version=object_module_version,
         )
 
-    @classmethod
     def _validate_method_arguments(
-        cls, method: MethodType, arguments: dict, is_packing: bool
+        self, method: MethodType, arguments: dict, is_packing: bool
     ):
         """
         Validate keyword arguments to pass to a method. Used for validating log hint configurations for packing methods
@@ -561,13 +562,13 @@ class DefaultPackager(Packager, metaclass=_DefaultPackagerMeta):
         if missing_arguments:
             if is_packing:
                 raise MLRunPackagePackingError(
-                    f"The packager '{cls.__name__}' could not pack the package due to missing configurations: "
-                    f"{', '.join(missing_arguments)}. Add the missing arguments to the log hint of this object in "
-                    f"order to pack it. Make sure you pass a dictionary log hint and not a string in order to pass "
-                    f"configurations in the log hint."
+                    f"The packager '{self.__class__.__name__}' could not pack the package due to missing "
+                    f"configurations: {', '.join(missing_arguments)}. Add the missing arguments to the log hint of "
+                    f"this object in order to pack it. Make sure you pass a dictionary log hint and not a string in "
+                    f"order to pass configurations in the log hint."
                 )
             raise MLRunPackageUnpackingError(
-                f"The packager '{cls.__name__}' could not unpack the package due to missing instructions: "
+                f"The packager '{self.__class__.__name__}' could not unpack the package due to missing instructions: "
                 f"{', '.join(missing_arguments)}. Missing instructions are likely due to an update in the packager's "
                 f"code that not support the old implementation. This backward compatibility should not occur. To "
                 f"overcome it, try to edit the instructions in the artifact's spec to enable unpacking it again."
@@ -580,7 +581,7 @@ class DefaultPackager(Packager, metaclass=_DefaultPackagerMeta):
         if incorrect_arguments:
             arguments_type = "configurations" if is_packing else "instructions"
             logger.warn(
-                f"Unexpected {arguments_type} given for {cls.__name__}: {', '.join(incorrect_arguments)}. "
+                f"Unexpected {arguments_type} given for {self.__class__.__name__}: {', '.join(incorrect_arguments)}. "
                 f"Possible {arguments_type} are: {', '.join(possible_arguments.keys())}. The packager tries to "
                 f"continue by ignoring the incorrect arguments."
             )