truefoundry 0.3.4__py3-none-any.whl → 0.4.0__py3-none-any.whl

truefoundry/ml/constants.py

@@ -0,0 +1,84 @@
+import datetime
+import os
+import posixpath
+from pathlib import Path
+
+from truefoundry.ml.internal_namespace import NAMESPACE
+
+DEFAULT_TRACKING_URI = "https://app.truefoundry.com"
+RUN_LOGS_DIR = posixpath.join("mlf", "run-logs")
+
+
+# TODO (chiragjn): This should be run specific, otherwise this will only be initialised once per
+#                   interpreter
+MLFOUNDRY_TMP_FOLDER = Path(os.path.abspath("./.mlfoundry"))
+RUN_TMP_FOLDER = Path(
+    os.path.join(MLFOUNDRY_TMP_FOLDER, "logdirs")
+)  # this is the log directory
+
+RUN_PREDICTIONS_FOLDER = Path(
+    os.path.join(RUN_TMP_FOLDER, "predictions")
+)  # path to store predictions
+RUN_DATASET_FOLDER = Path(
+    os.path.join(RUN_TMP_FOLDER, "datasets")
+)  # path to store datasets
+# path to store dataset stats
+RUN_STATS_FOLDER = Path(os.path.join(RUN_TMP_FOLDER, "stats"))
+RUN_METRICS_FOLDER = Path(os.path.join(RUN_TMP_FOLDER, "metrics"))
+
+GET_RUN_TMP_FOLDER = Path(
+    os.path.join(MLFOUNDRY_TMP_FOLDER, "getdirs")
+)  # this is the log directory
+GET_RUN_PREDICTIONS_FOLDER = Path(
+    os.path.join(GET_RUN_TMP_FOLDER, "predictions")
+)  # path to store predictions
+GET_RUN_DATASET_FOLDER = Path(
+    os.path.join(GET_RUN_TMP_FOLDER, "datasets")
+)  # path to store datasets
+
+TIME_LIMIT_THRESHOLD = datetime.timedelta(minutes=1)
+FILE_SIZE_LIMIT_THRESHOLD = pow(10, 7)  # 10MB
+
+MULTI_DIMENSIONAL_METRICS = "multi_dimensional_metrics"  # multi dimensional metrics
+NON_MULTI_DIMENSIONAL_METRICS = (
+    "non_multi_dimensional_metrics"  # non-multi dimensional metrics
+)
+PROB_MULTI_DIMENSIONAL_METRICS = (
+    "prob_multi_dimensional_metrics"  # multi dimensional metrics
+)
+PROB_NON_MULTI_DIMENSIONAL_METRICS = (
+    "prob_non_multi_dimensional_metrics"  # non-multi dimensional metrics
+)
+
+LATEST_ARTIFACT_OR_MODEL_VERSION = "latest"
+
+ACTUAL_PREDICTION_COUNTS = "actuals_predictions_counts"
+MLF_FOLDER_NAME = "mlf"
+MLRUNS_FOLDER = "mlruns"
+MLRUNS_FOLDER_NAME = Path(os.path.join(MLF_FOLDER_NAME, MLRUNS_FOLDER))
+
+
+# Runs Name and DF constants
+RUN_ID_COL_NAME = "run_id"
+RUN_NAME_COL_NAME = "run_name"
+
+TIME_FORMAT = "%Y-%m-%d_%H-%M-%S"
+
+
+GIT_COMMIT_TAG_NAME = NAMESPACE("git.commit_sha")
+GIT_BRANCH_TAG_NAME = NAMESPACE("git.branch_name")
+GIT_REMOTE_URL_NAME = NAMESPACE("git.remote_url")
+GIT_DIRTY_TAG_NAME = NAMESPACE("git.dirty")
+PATCH_FILE_ARTIFACT_DIR = NAMESPACE / "git"
+LOG_DATASET_ARTIFACT_DIR = NAMESPACE / "datasets"
+# without .txt patch file does not load on UI
+PATCH_FILE_NAME = "uncommitted_changes.patch.txt"
+
+PYTHON_VERSION_TAG_NAME = NAMESPACE("python_version")
+MLFOUNDRY_VERSION_TAG_NAME = NAMESPACE("mlfoundry_version")
+TRUEFOUNDRY_VERSION_TAG_NAME = NAMESPACE("truefoundry_version")
+
+
+ALM_SCALAR_METRICS_PATTERN = NAMESPACE("auto_logged_metrics.{data_slice}.{metric_name}")
+ALM_ARTIFACT_PATH = NAMESPACE / "auto_logged_metrics"
+ALM_METRICS_FILE_NAME = "metrics.json"

truefoundry/ml/entities.py

@@ -0,0 +1,62 @@
+from typing import Optional, Union
+
+from truefoundry.ml.autogen.client import (  # type: ignore[attr-defined]
+    FileInfoDto,
+    MetricDto,
+)
+from truefoundry.pydantic_v1 import (
+    BaseModel,
+    Field,
+    StrictBool,
+    StrictFloat,
+    StrictInt,
+    StrictStr,
+)
+
+
+class Metric(BaseModel):
+    key: StrictStr = Field(...)
+    value: Optional[Union[StrictFloat, StrictInt]] = None
+    timestamp: Optional[StrictInt] = None
+    step: Optional[StrictInt] = 0
+
+    @classmethod
+    def from_dto(cls, dto: MetricDto) -> "Metric":
+        return cls(
+            key=dto.key,
+            value=dto.value,
+            timestamp=dto.timestamp,
+            step=dto.step,
+        )
+
+    def to_dto(self) -> MetricDto:
+        return MetricDto(
+            key=self.key,
+            value=self.value,
+            timestamp=self.timestamp,
+            step=self.step,
+        )
+
+
+class FileInfo(BaseModel):
+    path: StrictStr
+    is_dir: StrictBool
+    file_size: Optional[StrictInt] = None
+    signed_url: Optional[StrictStr] = None
+
+    @classmethod
+    def from_dto(cls, dto: FileInfoDto) -> "FileInfo":
+        return cls(
+            path=dto.path,
+            is_dir=dto.is_dir,
+            file_size=dto.file_size,
+            signed_url=dto.signed_url,
+        )
+
+    def to_dto(self) -> FileInfoDto:
+        return FileInfoDto(
+            path=self.path,
+            is_dir=self.is_dir,
+            file_size=self.file_size,
+            signed_url=self.signed_url,
+        )

truefoundry/ml/enums.py

@@ -0,0 +1,70 @@
+import enum
+
+from truefoundry.ml.exceptions import MlFoundryException
+
+
+class EnumMissingMixin:
+    @classmethod
+    def _missing_(cls, value):
+        raise MlFoundryException(
+            "%r is not a valid %s.  Valid types: %s"
+            % (
+                value,
+                cls.__name__,
+                ", ".join([repr(m.value) for m in cls]),  # type: ignore
+            )
+        )
+
+
+class ViewType(str, EnumMissingMixin, enum.Enum):
+    # TODO (chiragjn): This should come from autogen! And also be exported in __init__.py
+    ACTIVE_ONLY = "ACTIVE_ONLY"
+    DELETED_ONLY = "DELETED_ONLY"
+    HARD_DELETED_ONLY = "HARD_DELETED_ONLY"
+    ALL = "ALL"
+
+
+class RunStatus(str, EnumMissingMixin, enum.Enum):
+    # TODO (chiragjn): This should come from autogen! And also be exported in __init__.py
+    RUNNING = "RUNNING"
+    SCHEDULED = "SCHEDULED"
+    FINISHED = "FINISHED"
+    FAILED = "FAILED"
+    KILLED = "KILLED"
+
+
+class FileFormat(EnumMissingMixin, enum.Enum):
+    CSV = "csv"
+    PARQUET = "parquet"
+
+
+class ModelFramework(EnumMissingMixin, enum.Enum):
+    SKLEARN = "sklearn"
+    TENSORFLOW = "tensorflow"
+    PYTORCH = "pytorch"
+    KERAS = "keras"
+    XGBOOST = "xgboost"
+    LIGHTGBM = "lightgbm"
+    FASTAI = "fastai"
+    H2O = "h2o"
+    ONNX = "onnx"
+    SPACY = "spacy"
+    STATSMODELS = "statsmodels"
+    GLUON = "gluon"
+    PADDLE = "paddle"
+    TRANSFORMERS = "transformers"
+    UNKNOWN = "unknown"
+
+
+class DataSlice(EnumMissingMixin, enum.Enum):
+    TRAIN = "train"
+    VALIDATE = "validate"
+    TEST = "test"
+    PREDICTION = "prediction"
+
+
+class ModelType(EnumMissingMixin, enum.Enum):
+    BINARY_CLASSIFICATION = "binary_classification"
+    MULTICLASS_CLASSIFICATION = "multiclass_classification"
+    REGRESSION = "regression"
+    TIMESERIES = "timeseries"

truefoundry/ml/env_vars.py

@@ -0,0 +1,9 @@
+"""
+Define all the env variable names that users can use
+"""
+
+DISABLE_MULTIPART_UPLOAD = "MLF_DISABLE_MULTIPART_UPLOAD"
+INTERNAL_ENV_VARS = [
+    "TFY_INTERNAL_APPLICATION_ID",
+    "TFY_INTERNAL_JOB_RUN_NAME",
+]

truefoundry/ml/exceptions.py

@@ -0,0 +1,8 @@
+from typing import Optional
+
+
+class MlFoundryException(Exception):
+    def __init__(self, message, status_code: Optional[int] = None):
+        self.message = str(message)
+        self.status_code = status_code
+        super().__init__(message)

truefoundry/ml/git_info.py

@@ -0,0 +1,60 @@
+from typing import Optional
+
+from git import Repo
+from git.exc import InvalidGitRepositoryError
+
+from truefoundry.ml.logger import logger
+
+
+class GitInfo:
+    def __init__(self, path: str):
+        try:
+            self.repo: Repo = self.build_repo(path)
+        except InvalidGitRepositoryError as ex:
+            # NOTE: gitpython library does not set proper exception message while raising the
+            # exception. So we are catching and raising the same exception with proper message
+            raise InvalidGitRepositoryError("git repository is not present") from ex
+
+    def build_repo(self, path: str):
+        # https://github.com/gitpython-developers/GitPython/blob/cd29f07b2efda24bdc690626ed557590289d11a6/git/cmd.py#L365
+        # looks like the import itself may fail in case the git executable
+        # is not found
+        # putting the import here so that the caller can handle the exception
+        import git
+
+        repo = git.Repo(path, search_parent_directories=True)
+
+        return repo
+
+    @property
+    def current_commit_sha(self) -> str:
+        return str(self.repo.head.object.hexsha)
+
+    @property
+    def current_branch_name(self) -> str:
+        try:
+            branch_name = self.repo.active_branch.name
+            return branch_name
+        except TypeError as ex:
+            # NOTE: TypeError will be raised here if
+            # head is in detached state.
+            # git checkout commit_sha
+            # in this case returning empty string
+            logger.warning(f"cannot get branch name because of {ex}")
+            return ""
+
+    @property
+    def remote_url(self) -> Optional[str]:
+        remotes = self.repo.remotes
+        if len(remotes) != 1:
+            logger.warning("either more than one or no remote detected")
+            return None
+        return remotes[0].url
+
+    @property
+    def diff_patch(self) -> str:
+        return str(self.repo.git.diff("--patch", "HEAD"))
+
+    @property
+    def is_dirty(self) -> bool:
+        return self.repo.is_dirty()

truefoundry/ml/internal_namespace.py

@@ -0,0 +1,52 @@
+import os
+import typing
+
+from truefoundry.ml.exceptions import MlFoundryException
+
+
+class _InternalNamespace:
+    NAMESPACE = "mlf"
+    DELIMITER = "."
+    NAMESPACE_VIOLATION_MESSAGE = """
+        {name} cannot start with {prefix}
+    """
+
+    def __call__(self, name: str, delimiter: str = DELIMITER):
+        if not name:
+            raise MlFoundryException("name should be a non empty string")
+        return _InternalNamespace.NAMESPACE + delimiter + name
+
+    def __truediv__(self, path: str):
+        return os.path.join(_InternalNamespace.NAMESPACE, path)
+
+    @staticmethod
+    def _validate_name_not_using_namespace(name: typing.Optional[str], delimiter: str):
+        if name and name.startswith(_InternalNamespace.NAMESPACE + delimiter):
+            raise MlFoundryException(
+                _InternalNamespace.NAMESPACE_VIOLATION_MESSAGE.format(
+                    name=name, prefix=_InternalNamespace.NAMESPACE + delimiter
+                )
+            )
+
+    def validate_namespace_not_used(
+        self,
+        names: typing.Optional[typing.Union[str, typing.Iterable[str]]] = None,
+        delimiter: str = DELIMITER,
+        path: typing.Optional[str] = None,
+    ):
+        if isinstance(names, str):
+            names = [names]
+        if names is not None:
+            for name_ in names:
+                self._validate_name_not_using_namespace(name_, delimiter)
+        if path:
+            prefix = os.path.normpath(os.path.join(_InternalNamespace.NAMESPACE, ""))
+            if os.path.normpath(path).startswith(prefix):
+                raise MlFoundryException(
+                    _InternalNamespace.NAMESPACE_VIOLATION_MESSAGE.format(
+                        name=path, prefix=prefix
+                    )
+                )
+
+
+NAMESPACE = _InternalNamespace()

truefoundry/ml/log_types/__init__.py

@@ -0,0 +1,4 @@
+from truefoundry.ml.log_types.image import Image
+from truefoundry.ml.log_types.plot import Plot
+
+__all__ = ["Image", "Plot"]