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

mlrun/model_monitoring/batch_application.py

@@ -11,25 +11,20 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-#
+
 import concurrent.futures
 import datetime
 import json
 import os
 import re
-from typing import Callable, Tuple
+from typing import Callable, Optional, Tuple
 
-import numpy as np
 import pandas as pd
 
 import mlrun
-import mlrun.common.helpers
-import mlrun.common.model_monitoring.helpers
-import mlrun.common.schemas.model_monitoring
 import mlrun.common.schemas.model_monitoring.constants as mm_constants
 import mlrun.data_types.infer
 import mlrun.feature_store as fstore
-import mlrun.utils.v3io_clients
 from mlrun.datastore import get_stream_pusher
 from mlrun.datastore.targets import ParquetTarget
 from mlrun.model_monitoring.batch import calculate_inputs_statistics
@@ -72,46 +67,39 @@ class BatchApplicationProcessor:
 
         # Get the batch interval range
         self.batch_dict = context.parameters[
-            mlrun.common.schemas.model_monitoring.EventFieldType.BATCH_INTERVALS_DICT
+            mm_constants.EventFieldType.BATCH_INTERVALS_DICT
         ]
 
-        # TODO: This will be removed in 1.5.0 once the job params can be parsed with different types
+        # TODO: This will be removed once the job params can be parsed with different types
         # Convert batch dict string into a dictionary
         if isinstance(self.batch_dict, str):
             self._parse_batch_dict_str()
         # If provided, only model endpoints in that that list will be analyzed
         self.model_endpoints = context.parameters.get(
-            mlrun.common.schemas.model_monitoring.EventFieldType.MODEL_ENDPOINTS, None
-        )
-        self.v3io_access_key = os.environ.get("V3IO_ACCESS_KEY")
-        self.model_monitoring_access_key = (
-            os.environ.get("MODEL_MONITORING_ACCESS_KEY") or self.v3io_access_key
+            mm_constants.EventFieldType.MODEL_ENDPOINTS, None
         )
+        self.model_monitoring_access_key = self._get_model_monitoring_access_key()
         self.parquet_directory = get_monitoring_parquet_path(
             project=project,
-            kind=mlrun.common.schemas.model_monitoring.FileTargetKind.BATCH_CONTROLLER_PARQUET,
+            kind=mm_constants.FileTargetKind.BATCH_CONTROLLER_PARQUET,
         )
         self.storage_options = None
         if not mlrun.mlconf.is_ce_mode():
-            self._initialize_v3io_configurations(
-                model_monitoring_access_key=self.model_monitoring_access_key
-            )
+            self._initialize_v3io_configurations()
         elif self.parquet_directory.startswith("s3://"):
             self.storage_options = mlrun.mlconf.get_s3_storage_options()
 
-    def _initialize_v3io_configurations(
-        self,
-        v3io_access_key: str = None,
-        v3io_framesd: str = None,
-        v3io_api: str = None,
-        model_monitoring_access_key: str = None,
-    ):
-        # Get the V3IO configurations
-        self.v3io_framesd = v3io_framesd or mlrun.mlconf.v3io_framesd
-        self.v3io_api = v3io_api or mlrun.mlconf.v3io_api
-
-        self.v3io_access_key = v3io_access_key or os.environ.get("V3IO_ACCESS_KEY")
-        self.model_monitoring_access_key = model_monitoring_access_key
+    @staticmethod
+    def _get_model_monitoring_access_key() -> Optional[str]:
+        access_key = os.getenv(mm_constants.ProjectSecretKeys.ACCESS_KEY)
+        # allow access key to be empty and don't fetch v3io access key if not needed
+        if access_key is None:
+            access_key = mlrun.mlconf.get_v3io_access_key()
+        return access_key
+
+    def _initialize_v3io_configurations(self) -> None:
+        self.v3io_framesd = mlrun.mlconf.v3io_framesd
+        self.v3io_api = mlrun.mlconf.v3io_api
         self.storage_options = dict(
             v3io_access_key=self.model_monitoring_access_key, v3io_api=self.v3io_api
         )
@@ -126,9 +114,7 @@ class BatchApplicationProcessor:
                 self.project
             ).list_model_monitoring_functions()
             if application:
-                applications_names = np.unique(
-                    [app.metadata.name for app in application]
-                ).tolist()
+                applications_names = list({app.metadata.name for app in application})
             else:
                 logger.info("There are no monitoring application found in this project")
                 applications_names = []
@@ -144,26 +130,18 @@ class BatchApplicationProcessor:
             futures = []
             for endpoint in endpoints:
                 if (
-                    endpoint[
-                        mlrun.common.schemas.model_monitoring.EventFieldType.ACTIVE
-                    ]
-                    and endpoint[
-                        mlrun.common.schemas.model_monitoring.EventFieldType.MONITORING_MODE
-                    ]
-                    == mlrun.common.schemas.model_monitoring.ModelMonitoringMode.enabled.value
+                    endpoint[mm_constants.EventFieldType.ACTIVE]
+                    and endpoint[mm_constants.EventFieldType.MONITORING_MODE]
+                    == mm_constants.ModelMonitoringMode.enabled.value
                 ):
                     # Skip router endpoint:
                     if (
-                        int(
-                            endpoint[
-                                mlrun.common.schemas.model_monitoring.EventFieldType.ENDPOINT_TYPE
-                            ]
-                        )
-                        == mlrun.common.schemas.model_monitoring.EndpointType.ROUTER
+                        int(endpoint[mm_constants.EventFieldType.ENDPOINT_TYPE])
+                        == mm_constants.EndpointType.ROUTER
                     ):
                         # Router endpoint has no feature stats
                         logger.info(
-                            f"{endpoint[mlrun.common.schemas.model_monitoring.EventFieldType.UID]} is router skipping"
+                            f"{endpoint[mm_constants.EventFieldType.UID]} is router skipping"
                         )
                         continue
                     future = pool.submit(
@@ -184,8 +162,9 @@ class BatchApplicationProcessor:
 
             self._delete_old_parquet()
 
-    @staticmethod
+    @classmethod
     def model_endpoint_process(
+        cls,
         endpoint: dict,
         applications_names: list[str],
         bath_dict: dict,
@@ -207,20 +186,14 @@ class BatchApplicationProcessor:
         :param model_monitoring_access_key: (str) Access key to apply the model monitoring process.
 
         """
-        endpoint_id = endpoint[mlrun.common.schemas.model_monitoring.EventFieldType.UID]
+        endpoint_id = endpoint[mm_constants.EventFieldType.UID]
         try:
             # Getting batch interval start time and end time
-            start_time, end_time = BatchApplicationProcessor._get_interval_range(
-                bath_dict
-            )
+            start_time, end_time = cls._get_interval_range(bath_dict)
             m_fs = fstore.get_feature_set(
-                endpoint[
-                    mlrun.common.schemas.model_monitoring.EventFieldType.FEATURE_SET_URI
-                ]
+                endpoint[mm_constants.EventFieldType.FEATURE_SET_URI]
             )
-            labels = endpoint[
-                mlrun.common.schemas.model_monitoring.EventFieldType.LABEL_NAMES
-            ]
+            labels = endpoint[mm_constants.EventFieldType.LABEL_NAMES]
             if labels:
                 if isinstance(labels, str):
                     labels = json.loads(labels)
@@ -232,7 +205,7 @@ class BatchApplicationProcessor:
 
             try:
                 # get sample data
-                df = BatchApplicationProcessor._get_sample_df(
+                df = cls._get_sample_df(
                     m_fs,
                     endpoint_id,
                     end_time,
@@ -245,9 +218,7 @@ class BatchApplicationProcessor:
                     logger.warn(
                         "Not enough model events since the beginning of the batch interval",
                         featureset_name=m_fs.metadata.name,
-                        endpoint=endpoint[
-                            mlrun.common.schemas.model_monitoring.EventFieldType.UID
-                        ],
+                        endpoint=endpoint[mm_constants.EventFieldType.UID],
                         min_rqeuired_events=mlrun.mlconf.model_endpoint_monitoring.parquet_batching_max_events,
                         start_time=start_time,
                         end_time=end_time,
@@ -262,9 +233,7 @@ class BatchApplicationProcessor:
                 logger.warn(
                     "Parquet not found, probably due to not enough model events",
                     # parquet_target=m_fs.status.targets[0].path, TODO:
-                    endpoint=endpoint[
-                        mlrun.common.schemas.model_monitoring.EventFieldType.UID
-                    ],
+                    endpoint=endpoint[mm_constants.EventFieldType.UID],
                     min_rqeuired_events=mlrun.mlconf.model_endpoint_monitoring.parquet_batching_max_events,
                 )
                 return
@@ -280,15 +249,11 @@ class BatchApplicationProcessor:
             m_fs.save()
 
             # Get the timestamp of the latest request:
-            latest_request = df[
-                mlrun.common.schemas.model_monitoring.EventFieldType.TIMESTAMP
-            ].iloc[-1]
+            latest_request = df[mm_constants.EventFieldType.TIMESTAMP].iloc[-1]
 
             # Get the feature stats from the model endpoint for reference data
             feature_stats = json.loads(
-                endpoint[
-                    mlrun.common.schemas.model_monitoring.EventFieldType.FEATURE_STATS
-                ]
+                endpoint[mm_constants.EventFieldType.FEATURE_STATS]
             )
 
             # Get the current stats:
@@ -298,7 +263,7 @@ class BatchApplicationProcessor:
             )
 
             # create and push data to all applications
-            BatchApplicationProcessor._push_to_applications(
+            cls._push_to_applications(
                 current_stats,
                 feature_stats,
                 parquet_directory,
@@ -312,7 +277,7 @@ class BatchApplicationProcessor:
 
         except FileNotFoundError as e:
             logger.error(
-                f"Exception for endpoint {endpoint[mlrun.common.schemas.model_monitoring.EventFieldType.UID]}"
+                f"Exception for endpoint {endpoint[mm_constants.EventFieldType.UID]}"
             )
             return endpoint_id, e
 
@@ -323,9 +288,9 @@ class BatchApplicationProcessor:
     ) -> Tuple[datetime.datetime, datetime.datetime]:
         """Getting batch interval time range"""
         minutes, hours, days = (
-            batch_dict[mlrun.common.schemas.model_monitoring.EventFieldType.MINUTES],
-            batch_dict[mlrun.common.schemas.model_monitoring.EventFieldType.HOURS],
-            batch_dict[mlrun.common.schemas.model_monitoring.EventFieldType.DAYS],
+            batch_dict[mm_constants.EventFieldType.MINUTES],
+            batch_dict[mm_constants.EventFieldType.HOURS],
+            batch_dict[mm_constants.EventFieldType.DAYS],
         )
         end_time = now_func() - datetime.timedelta(
             seconds=mlrun.mlconf.model_endpoint_monitoring.parquet_batching_timeout_secs
@@ -360,7 +325,7 @@ class BatchApplicationProcessor:
             ("minute", "%M"),
         ]:
             schedule_time_str += f"{unit}={schedule_time.strftime(fmt)}/"
-        endpoint_str = f"{mlrun.common.schemas.model_monitoring.EventFieldType.ENDPOINT_ID}={endpoint_id}"
+        endpoint_str = f"{mm_constants.EventFieldType.ENDPOINT_ID}={endpoint_id}"
 
         return f"{parquet_directory}/{schedule_time_str}/{endpoint_str}"
 
@@ -377,7 +342,7 @@ class BatchApplicationProcessor:
 
         base_directory = get_monitoring_parquet_path(
             project=self.project,
-            kind=mlrun.common.schemas.model_monitoring.FileTargetKind.BATCH_CONTROLLER_PARQUET,
+            kind=mm_constants.FileTargetKind.BATCH_CONTROLLER_PARQUET,
         )
         target = ParquetTarget(path=base_directory)
         store, _ = target._get_store_and_path()
@@ -456,7 +421,7 @@ class BatchApplicationProcessor:
             mm_constants.ApplicationEvent.ENDPOINT_ID: endpoint_id,
             mm_constants.ApplicationEvent.OUTPUT_STREAM_URI: get_stream_path(
                 project=project,
-                application_name=mlrun.common.schemas.model_monitoring.constants.MonitoringFunctionNames.WRITER,
+                application_name=mm_constants.MonitoringFunctionNames.WRITER,
             ),
         }
         for app_name in applications_names:
@@ -504,9 +469,7 @@ class BatchApplicationProcessor:
         }  # to avoid exception when the taf is not latest
         entity_rows = pd.DataFrame(
             {
-                mlrun.common.schemas.model_monitoring.EventFieldType.ENDPOINT_ID: [
-                    endpoint_id
-                ],
+                mm_constants.EventFieldType.ENDPOINT_ID: [endpoint_id],
                 "scheduled_time": [end_time],
             }
         )
@@ -516,12 +479,12 @@ class BatchApplicationProcessor:
             entity_timestamp_column="scheduled_time",
             start_time=start_time,
             end_time=end_time,
-            timestamp_for_filtering=mlrun.common.schemas.model_monitoring.EventFieldType.TIMESTAMP,
+            timestamp_for_filtering=mm_constants.EventFieldType.TIMESTAMP,
             target=ParquetTarget(
                 path=parquet_directory,
                 time_partitioning_granularity="minute",
                 partition_cols=[
-                    mlrun.common.schemas.model_monitoring.EventFieldType.ENDPOINT_ID,
+                    mm_constants.EventFieldType.ENDPOINT_ID,
                 ],
                 storage_options=storage_options,
             ),

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