truefoundry 0.5.0rc7__py3-none-any.whl → 0.5.1rc2__py3-none-any.whl

truefoundry/ml/mlfoundry_api.py

@@ -1,7 +1,8 @@
 import os
 import time
 import uuid
-from pathlib import Path
+import zipfile
+from io import BytesIO
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -15,9 +16,8 @@ from typing import (
 )
 
 import coolname
-import pandas as pd
 
-from truefoundry.common.utils import relogin_error_message
+from truefoundry.common.utils import ContextualDirectoryManager, relogin_error_message
 from truefoundry.ml import ModelVersionEnvironment, constants
 from truefoundry.ml.autogen.client import (  # type: ignore[attr-defined]
     ArtifactDto,
@@ -27,12 +27,14 @@ from truefoundry.ml.autogen.client import (  # type: ignore[attr-defined]
     CreateRunRequestDto,
     DatasetDto,
     ExperimentsApi,
+    ExportDeploymentFilesRequestDto,
     ListArtifactsRequestDto,
     ListArtifactVersionsRequestDto,
     ListDatasetsRequestDto,
     ListModelVersionsRequestDto,
     MlfoundryArtifactsApi,
     ModelDto,
+    ModelServer,
     RunsApi,
     RunTagDto,
     SearchRunsRequestDto,
@@ -75,7 +77,7 @@ if TYPE_CHECKING:
     from truefoundry.ml import ModelFrameworkType
 
 _SEARCH_MAX_RESULTS_DEFAULT = 1000
-
+_ML_FOUNDRY_API_REQUEST_TIMEOUT = 10
 _INTERNAL_ENV_VARS = [
     "TFY_INTERNAL_APPLICATION_ID",
     "TFY_INTERNAL_JOB_RUN_NAME",
@@ -476,43 +478,6 @@ class MlFoundry:
         )
         return mlfoundry_run
 
-    def get_all_runs(
-        self,
-        ml_repo: str,
-    ) -> pd.DataFrame:
-        """Returns all the run name and id present under a ML Repo.
-
-        The user must have `READ` access to the ML Repo.
-
-        Args:
-            ml_repo (str): Name of the ML Repo.
-        Returns:
-            pd.DataFrame: dataframe with two columns- run_id and run_name
-
-        Examples:
-
-            ### get all the runs from a ml_repo
-            ```python
-            from truefoundry.ml import get_client
-
-            client = get_client()
-
-            run = client.get_all_runs(ml_repo='my-repo')
-            ```
-        """
-        runs = []
-        for run in self.search_runs(ml_repo=ml_repo):
-            runs.append((run.run_id, run.run_name))
-
-        if len(runs) == 0:
-            return pd.DataFrame(
-                columns=[constants.RUN_ID_COL_NAME, constants.RUN_NAME_COL_NAME]
-            )
-
-        return pd.DataFrame(
-            runs, columns=[constants.RUN_ID_COL_NAME, constants.RUN_NAME_COL_NAME]
-        )
-
     def search_runs(
         self,
         ml_repo: str,
@@ -658,6 +623,74 @@ class MlFoundry:
         """
         return self._tracking_uri
 
+    def _initialize_model_server(
+        self,
+        name: str,
+        model_version_fqn: str,
+        workspace_fqn: str,
+        model_server: ModelServer,
+        output_dir: Optional[str] = None,
+    ) -> str:
+        """
+        Initialize the model server for deployment.
+
+        Args:
+            name (str): Name of the application.
+            model_version_fqn (str): Fully Qualified Name of the model version.
+            workspace_fqn (str): Fully Qualified Name of the workspace.
+            model_server (ModelServer): Server type for deployment (e.g., TRITON).
+            output_dir (Optional[str]): Directory where the model files will be extracted.
+                                        Defaults to the current working directory.
+
+        Returns:
+            str: Path to the directory where the model files are extracted.
+
+        Raises:
+            MlFoundryException: If an error occurs during API calls, directory creation, or file extraction.
+        """
+
+        # Using get_with_http_info to get the response object and extract the raw data
+        try:
+            export_deployment_files_request_dto = ExportDeploymentFilesRequestDto(
+                model_version_fqn=model_version_fqn,
+                workspace_fqn=workspace_fqn,
+                service_name=name,
+                model_server=model_server,
+            )
+            response = self._mlfoundry_artifacts_api.export_deployment_files_by_fqn_post_with_http_info(
+                export_deployment_files_request_dto=export_deployment_files_request_dto,
+                _preload_content=False,
+                _request_timeout=_ML_FOUNDRY_API_REQUEST_TIMEOUT,
+            )
+        except ApiException as e:
+            err_msg = (
+                f"Failed to fetch deployment files for name={name}, "
+                f"model_version_fqn={model_version_fqn}, workspace_fqn={workspace_fqn}. "
+                f"Error: {e}"
+            )
+            raise MlFoundryException(err_msg) from e
+
+        output_dir = os.path.abspath(output_dir or os.getcwd())
+        codegen_dir = os.path.join(output_dir, name)
+        if codegen_dir == output_dir:
+            raise ValueError("Name cannot be empty, please provide a valid name")
+
+        try:
+            with ContextualDirectoryManager(dir_path=codegen_dir) as dir_path:
+                with zipfile.ZipFile(BytesIO(response.raw_data), mode="r") as zip_file:
+                    zip_file.extractall(dir_path)
+        except FileExistsError as e:
+            err_msg = (
+                f"Deployment directory {codegen_dir!r} already exists. "
+                "Please choose a different deployment name or delete the existing directory."
+            )
+            raise MlFoundryException(err_msg) from e
+        except zipfile.BadZipFile as e:
+            raise MlFoundryException(
+                f"Failed to extract model files. Error: {e}"
+            ) from e
+        return codegen_dir
+
     def get_model_version(
         self,
         ml_repo: str,
@@ -1227,7 +1260,6 @@ class MlFoundry:
         ml_repo: str,
         name: str,
         model_file_or_folder: Union[str, BlobStorageDirectory],
-        additional_files: Sequence[Tuple[Union[str, Path], Optional[str]]] = (),
         description: Optional[str] = None,
         metadata: Optional[Dict[str, Any]] = None,
         progress: Optional[bool] = None,
@@ -1263,41 +1295,6 @@ class MlFoundry:
                 Can also be `None` if the framework is not known or not supported.
                 **Deprecated**: Prefer `ModelFrameworkType` over `enums.ModelFramework`.
 
-            additional_files (Sequence[Tuple[Union[str, Path], Optional[str]]], optional): A list of pairs
-                of (source path, destination path) to add additional files and folders
-                to the model version contents. The first member of the pair should be a file or directory path
-                and the second member should be the path inside the model versions contents to upload to.
-                The model version contents are arranged like follows
-                .
-                └── model/
-                    └── # model files are serialized here
-                └── # any additional files and folders can be added here.
-
-                You can also add additional files to model/ subdirectory by specifying the destination path as model/
-
-                ```python
-                from truefoundry.ml import TensorFlowFramework
-
-                run.log_model(
-                    name="xyz",
-                    model_file_or_folder="clf.joblib",
-                    framework=TensorFlowFramework(),
-                    additional_files=[("foo.txt", "foo/bar/foo.txt"), ("tokenizer/", "foo/tokenizer/")]
-                )
-                ```
-
-                would result in
-
-                ```
-                .
-                ├── model/
-                │   └── clf.joblib # if `model_file_or_folder` is a folder, contents will be added here
-                └── foo/
-                    ├── bar/
-                    │   └── foo.txt
-                    └── tokenizer/
-                        └── # contents of tokenizer/ directory will be uploaded here
-                ```
             description (Optional[str], optional): arbitrary text upto 1024 characters to store as description.
                 This field can be updated at any time after logging. Defaults to `None`
             metadata (Optional[Dict[str, Any]], optional): arbitrary json serializable dictionary to store metadata.
@@ -1387,7 +1384,6 @@ class MlFoundry:
             ml_repo_id=ml_repo_id,
             name=name,
             model_file_or_folder=model_file_or_folder,
-            additional_files=additional_files,
             description=description,
             metadata=metadata,
             step=None,

truefoundry/ml/mlfoundry_run.py

@@ -3,7 +3,6 @@ import os
 import platform
 import re
 import time
-from pathlib import Path
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -12,7 +11,6 @@ from typing import (
     Iterator,
     List,
     Optional,
-    Sequence,
     Tuple,
     Union,
 )
@@ -930,7 +928,6 @@ class MlFoundryRun:
         *,
         name: str,
         model_file_or_folder: Union[str, BlobStorageDirectory],
-        additional_files: Sequence[Tuple[Union[str, Path], Optional[str]]] = (),
         description: Optional[str] = None,
         metadata: Optional[Dict[str, Any]] = None,
         step: int = 0,
@@ -965,33 +962,7 @@ class MlFoundryRun:
                 Supported frameworks can be found in `truefoundry.ml.enums.ModelFramework`.
                 Can also be `None` if the framework is not known or not supported.
                 **Deprecated**: Prefer `ModelFrameworkType` over `enums.ModelFramework`.
-            additional_files (Sequence[Tuple[Union[str, Path], Optional[str]]], optional): A list of pairs
-                of (source path, destination path) to add additional files and folders
-                to the model version contents. The first member of the pair should be a file or directory path
-                and the second member should be the path inside the model versions contents to upload to.
-                The model version contents are arranged like follows
-                .
-                └── model/
-                    └── # model files are serialized here
-                └── # any additional files and folders can be added here.
-
-                You can also add additional files to model/ subdirectory by specifying the destination path as model/
 
-                ```
-                E.g. >>> run.log_model(
-                     ...     name="xyz", model_file_or_folder="clf.joblib", framework="sklearn",
-                     ...     additional_files=[("foo.txt", "foo/bar/foo.txt"), ("tokenizer/", "foo/tokenizer/")]
-                     ... )
-                would result in
-                .
-                ├── model/
-                │   └── clf.joblib  # if `model_file_or_folder` is a folder, contents will be added here
-                └── foo/
-                    ├── bar/
-                    │   └── foo.txt
-                    └── tokenizer/
-                        └── # contents of tokenizer/ directory will be uploaded here
-                ```
             description (Optional[str], optional): arbitrary text upto 1024 characters to store as description.
                 This field can be updated at any time after logging. Defaults to `None`
             metadata (Optional[Dict[str, Any]], optional): arbitrary json serializable dictionary to store metadata.
@@ -1084,7 +1055,6 @@ class MlFoundryRun:
             run=self,
             name=name,
             model_file_or_folder=model_file_or_folder,
-            additional_files=additional_files,
             description=description,
             metadata=metadata,
             step=step,

truefoundry/ml/model_framework.py

@@ -1,10 +1,63 @@
+import os
 import warnings
-from typing import Any, Dict, Literal, Optional, Union, get_args
-
-from truefoundry.ml import ModelFramework
+from collections import OrderedDict
+from pickle import load as pickle_load
+from typing import Any, Callable, Dict, List, Literal, Optional, Type, Union, get_args
+
+from truefoundry.common.utils import (
+    get_python_version_major_minor,
+    list_pip_packages_installed,
+)
+from truefoundry.ml.autogen.client import SerializationFormat
 from truefoundry.ml.autogen.entities import artifacts as autogen_artifacts
+from truefoundry.ml.enums import ModelFramework
+from truefoundry.ml.log_types.artifacts.utils import (
+    get_single_file_path_if_only_one_in_directory,
+    to_unix_path,
+)
 from truefoundry.pydantic_v1 import BaseModel, Field
 
+# Map serialization format to corresponding pip packages
+SERIALIZATION_FORMAT_TO_PACKAGES_NAME_MAP = {
+    SerializationFormat.JOBLIB: ["joblib"],
+    SerializationFormat.CLOUDPICKLE: ["cloudpickle"],
+}
+
+
+class _SerializationFormatLoaderRegistry:
+    def __init__(self):
+        # An OrderedDict is used to maintain the order of loaders based on priority
+        # The loaders are added in the following order:
+        #     1. joblib (if available)
+        #     2. cloudpickle (if available)
+        #     3. pickle (default fallback)
+        # This ensures that when looking up a loader, it follows the correct loading priority.
+        self._loader_map: Dict[SerializationFormat, Callable[[bytes], object]] = (
+            OrderedDict()
+        )
+        try:
+            from joblib import load as joblib_load
+
+            self._loader_map[SerializationFormat.JOBLIB] = joblib_load
+        except ImportError:
+            pass
+
+        try:
+            from cloudpickle import load as cloudpickle_load
+
+            self._loader_map[SerializationFormat.CLOUDPICKLE] = cloudpickle_load
+        except ImportError:
+            pass
+
+        # Add pickle loader as a fallback
+        self._loader_map[SerializationFormat.PICKLE] = pickle_load
+
+    def get_loader_map(self) -> Dict[SerializationFormat, Callable[[bytes], object]]:
+        return self._loader_map
+
+
+_serialization_format_loader_registry = _SerializationFormatLoaderRegistry()
+
 
 class FastAIFramework(autogen_artifacts.FastAIFramework):
     """FastAI model Framework"""
@@ -167,3 +220,204 @@ class _ModelFramework(BaseModel):
             return None
 
         return cls.parse_obj(obj).__root__
+
+
+# Mapping of model frameworks to pip packages
+_MODEL_FRAMEWORK_TO_PIP_PACKAGES: Dict[Type[ModelFrameworkType], List[str]] = {
+    SklearnFramework: ["scikit-learn", "numpy", "pandas"],
+    XGBoostFramework: ["xgboost", "numpy", "pandas"],
+}
+
+
+def _get_required_framework_pip_packages(framework: "ModelFrameworkType") -> List[str]:
+    """
+    Fetches the pip packages required for a given model framework.
+
+    Args:
+        framework ("ModelFrameworkType"): The model framework for which to fetch the pip packages.
+
+    Returns:
+        List[str]: The list of pip packages required for the given model framework.
+                  If no packages are found for the framework type, returns an empty list.
+    """
+    return _MODEL_FRAMEWORK_TO_PIP_PACKAGES.get(framework.__class__, [])
+
+
+def _detect_model_serialization_format(
+    model_file_path: str,
+) -> Optional[SerializationFormat]:
+    """
+    The function will attempt to load the model using each framework's loader and return the first successful one.
+
+    Args:
+        model_file_path (str): The path to the file to be loaded.
+
+    Returns:
+        Optional[SerializationFormat]: The serialization format if successfully loaded, None otherwise.
+    """
+    # Attempt to load the model using each framework
+    for (
+        serialization_format,
+        loader,
+    ) in _serialization_format_loader_registry.get_loader_map().items():
+        try:
+            with open(model_file_path, "rb") as f:
+                loader(f)
+            return serialization_format
+        except Exception:
+            continue
+    return None
+
+
+def _fetch_framework_specific_pip_packages(
+    framework: "ModelFrameworkType",
+) -> List[str]:
+    """
+    Fetch the pip packages required for the given framework, including any dependencies
+    related to the framework's serialization format.
+
+    Args:
+        framework: The framework object (e.g., SklearnFramework, XGBoostFramework).
+
+    Returns:
+        List[str]: A list of pip packages for the given framework and environment,
+                   including any dependencies based on the serialization format
+                   (e.g., ['numpy==1.19.5', ...]).
+    """
+    framework_package_names = _get_required_framework_pip_packages(framework=framework)
+
+    # Add serialization format dependencies if applicable
+    if isinstance(framework, (SklearnFramework, XGBoostFramework)):
+        framework_package_names.extend(
+            SERIALIZATION_FORMAT_TO_PACKAGES_NAME_MAP.get(
+                framework.serialization_format, []
+            )
+        )
+    return [
+        f"{package.name}=={package.version}"
+        for package in list_pip_packages_installed(
+            filter_package_names=framework_package_names
+        )
+    ]
+
+
+def auto_update_environment_details(
+    environment: autogen_artifacts.ModelVersionEnvironment,
+    framework: Optional[ModelFrameworkType],
+):
+    """
+    Auto fetch the environment details if not provided, based on the provided environment and framework.
+
+    Args:
+        environment: The environment object that holds environment details like python_version and pip_packages.
+        framework: The framework object (e.g., SklearnFramework, XGBoostFramework) that may affect pip_package fetching.
+    """
+    # Auto fetch python_version if not provided
+    if not environment.python_version:
+        environment.python_version = get_python_version_major_minor()
+
+    # Framework-specific pip_package handling
+    if framework and not environment.pip_packages:
+        environment.pip_packages = _fetch_framework_specific_pip_packages(framework)
+
+
+def _validate_and_get_absolute_model_filepath(
+    model_file_or_folder: str,
+    model_filepath: Optional[str] = None,
+) -> Optional[str]:
+    # If no model_filepath is set, resolve it from the directory
+    if not model_filepath:
+        # If model_filepath is not set, resolve it based on these cases:
+        #    - Case 1: model_file_or_folder/model.joblib -> model.joblib
+        #    - Case 2: model_file_or_folder/folder/model.joblib -> folder/model.joblib
+        #    - Case 3: model_file_or_folder/folder/model.joblib, model_file_or_folder/config.json -> None
+        return get_single_file_path_if_only_one_in_directory(model_file_or_folder)
+
+    # If model_filepath is already set, validate and resolve it:
+    #    - Case 1: Resolve the absolute file path of the model file relative to the provided directory.
+    #        Example: If model_file_or_folder is '/root/models' and model_filepath is 'model.joblib',
+    #                 the resolved model file path would be '/root/models/model.joblib'. Validate it.
+    #
+    #    - Case 2: If model_filepath is a relative path, resolve it to an absolute path based on the provided directory.
+    #        Example: If model_file_or_folder is '/root/models' and model_filepath is 'subfolder/model.joblib',
+    #                 the resolved path would be '/root/models/subfolder/model.joblib'. Validate it.
+    #
+    #    - Case 3: Verify that the resolved model file exists and is a valid file.
+    #        Example: If the resolved path is '/root/models/model.joblib', check if the file exists.
+    #                 If it does not exist, raise a FileNotFoundError.
+    #
+    #    - Case 4: Ensure the resolved model file is located within the specified directory or is the directory itself.
+    #        Example: If the resolved path is '/root/models/model.joblib' and model_file_or_folder is '/root/models',
+    #                 the resolved path is valid. If the file lies outside '/root/models', raise a ValueError.
+    #
+
+    # If model_filepath is set, Resolve the absolute path of the model file (It can be a relative path or absolute path)
+    model_dir = (
+        os.path.dirname(model_file_or_folder)
+        if os.path.isfile(model_file_or_folder)
+        else model_file_or_folder
+    )
+    absolute_model_filepath = os.path.abspath(os.path.join(model_dir, model_filepath))
+
+    # Validate if resolve valid is within the provided directory or is the same as it
+    if not (
+        absolute_model_filepath == model_file_or_folder
+        or absolute_model_filepath.startswith(model_file_or_folder + os.sep)
+    ):
+        raise ValueError(
+            f"model_filepath '{model_filepath}' must be relative to "
+            f"{model_file_or_folder}. Resolved path '{absolute_model_filepath}' is invalid."
+        )
+
+    if not os.path.isfile(absolute_model_filepath):
+        raise FileNotFoundError(f"Model file not found: {absolute_model_filepath}")
+
+    return absolute_model_filepath
+
+
+def _validate_and_resolve_model_filepath(
+    model_file_or_folder: str,
+    model_filepath: Optional[str] = None,
+) -> Optional[str]:
+    absolute_model_filepath = _validate_and_get_absolute_model_filepath(
+        model_file_or_folder=model_file_or_folder, model_filepath=model_filepath
+    )
+    if absolute_model_filepath:
+        return to_unix_path(
+            os.path.relpath(absolute_model_filepath, model_file_or_folder)
+            if os.path.isdir(model_file_or_folder)
+            else os.path.basename(absolute_model_filepath)
+        )
+
+
+def auto_update_model_framework_details(
+    framework: "ModelFrameworkType", model_file_or_folder: str
+):
+    """
+    Auto update the model framework details based on the provided model file or folder path.
+
+    Args:
+        framework: The framework object (e.g., SklearnFramework, XGBoostFramework) to update.
+        model_file_or_folder: The path to the model file or folder.
+    """
+
+    # Ensure the model file or folder path is an absolute path
+    model_file_or_folder = os.path.abspath(model_file_or_folder)
+
+    if isinstance(framework, (SklearnFramework, XGBoostFramework)):
+        framework.model_filepath = _validate_and_resolve_model_filepath(
+            model_file_or_folder=model_file_or_folder,
+            model_filepath=framework.model_filepath,
+        )
+        if framework.model_filepath:
+            absolute_model_filepath = (
+                model_file_or_folder
+                if os.path.isfile(model_file_or_folder)
+                else os.path.join(model_file_or_folder, framework.model_filepath)
+            )
+            framework.serialization_format = (
+                framework.serialization_format
+                or _detect_model_serialization_format(
+                    model_file_path=absolute_model_filepath
+                )
+            )

truefoundry/ml/validation_utils.py

@@ -29,6 +29,8 @@ _ML_REPO_NAME_REGEX = re.compile(r"^[a-zA-Z][a-zA-Z0-9\-]{1,98}[a-zA-Z0-9]$")
 _RUN_NAME_REGEX = re.compile(r"^[a-zA-Z0-9-]*$")
 _RUN_LOG_LOG_TYPE_REGEX = re.compile(r"^[a-zA-Z0-9-/]*$")
 _RUN_LOG_KEY_REGEX = re.compile(r"^[a-zA-Z0-9-_]*$")
+_APP_NAME_REGEX = re.compile(r"^[a-z][a-z0-9\\-]{1,30}[a-z0-9]$")
+
 
 MAX_PARAMS_TAGS_PER_BATCH = 100
 MAX_METRICS_PER_BATCH = 1000

{truefoundry-0.5.0rc7.dist-info → truefoundry-0.5.1rc2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: truefoundry
-Version: 0.5.0rc7
+Version: 0.5.1rc2
 Summary: Truefoundry CLI
 Author: Abhishek Choudhary
 Author-email: abhishek@truefoundry.com
@@ -19,7 +19,6 @@ Requires-Dist: aenum (>=3.0.0,<4.0.0)
 Requires-Dist: click (>=7.0.0,<9.0.0)
 Requires-Dist: coolname (>=1.1.0,<2.0.0)
 Requires-Dist: docker (>=6.1.2,<8.0.0)
-Requires-Dist: fastapi (>=0.56.0,<0.200.0)
 Requires-Dist: filelock (>=3.8.0,<4.0.0)
 Requires-Dist: flytekit (==1.13.13) ; extra == "workflow"
 Requires-Dist: gitignorefile (>=1.1.2,<2.0.0)
@@ -29,8 +28,6 @@ Requires-Dist: numpy (>=1.23.0,<2.0.0) ; python_version < "3.12"
 Requires-Dist: numpy (>=1.26.0,<2.0.0) ; python_version >= "3.12"
 Requires-Dist: openai (>=1.16.2,<2.0.0)
 Requires-Dist: packaging (>=20.0,<25.0)
-Requires-Dist: pandas (>=1.0.0,<3.0.0) ; python_version < "3.10"
-Requires-Dist: pandas (>=1.4.0,<3.0.0) ; python_version >= "3.10"
 Requires-Dist: pydantic (>=1.8.2,<3.0.0)
 Requires-Dist: pygments (>=2.12.0,<3.0.0)
 Requires-Dist: python-dateutil (>=2.8.2,<3.0.0)
@@ -46,7 +43,6 @@ Requires-Dist: scipy (>=1.5.0,<2.0.0) ; python_version < "3.12"
 Requires-Dist: tqdm (>=4.0.0,<5.0.0)
 Requires-Dist: typing-extensions (>=4.0)
 Requires-Dist: urllib3 (>=1.26.18,<3)
-Requires-Dist: uvicorn (>=0.13.0,<1.0.0)
 Requires-Dist: yq (>=3.1.0,<4.0.0)
 Description-Content-Type: text/markdown