genesis-flow 1.0.0__py3-none-any.whl

mlflow/models/display_utils.py

@@ -0,0 +1,158 @@
+import html
+from pathlib import Path
+
+from mlflow.models.model import ModelInfo
+from mlflow.models.signature import ModelSignature
+from mlflow.types import schema
+from mlflow.utils import databricks_utils
+
+
+def _is_input_string(inputs: schema.Schema) -> bool:
+    return (
+        not inputs.has_input_names()
+        and len(inputs.input_types()) == 1
+        and inputs.input_types()[0] == schema.DataType.string
+    )
+
+
+def _is_input_agent_compatible(inputs: schema.Schema) -> bool:
+    if _is_input_string(inputs):
+        return True
+    if not inputs.has_input_names():
+        return False
+    messages = inputs.input_dict().get("messages")
+    if not messages:
+        return False
+    if not isinstance(messages.type, schema.Array):
+        return False
+    items = messages.type.dtype
+    if not isinstance(items, schema.Object):
+        return False
+    properties = items.properties
+    content = next(filter(lambda prop: prop.name == "content", properties), None)
+    role = next(filter(lambda prop: prop.name == "role", properties), None)
+    return (
+        content
+        and content.dtype == schema.DataType.string
+        and role
+        and role.dtype == schema.DataType.string
+    )
+
+
+def _is_output_string_response(outputs: schema.Schema) -> bool:
+    if not outputs.has_input_names():
+        return False
+    content = outputs.input_dict().get("content")
+    if not content:
+        return False
+    return content.type == schema.DataType.string
+
+
+def _is_output_string(outputs: schema.Schema) -> bool:
+    return (
+        not outputs.has_input_names()
+        and len(outputs.input_types()) == 1
+        and outputs.input_types()[0] == schema.DataType.string
+    )
+
+
+def _is_output_chat_completion_response(outputs: schema.Schema) -> bool:
+    if not outputs.has_input_names():
+        return False
+    choices = outputs.input_dict().get("choices")
+    if not choices:
+        return False
+    if not isinstance(choices.type, schema.Array):
+        return False
+    items = choices.type.dtype
+    if not isinstance(items, schema.Object):
+        return False
+    properties = items.properties
+    message = next(filter(lambda prop: prop.name == "message", properties), None)
+    if not message:
+        return False
+    if not isinstance(message.dtype, schema.Object):
+        return False
+    message_properties = message.dtype.properties
+    content = next(filter(lambda prop: prop.name == "content", message_properties), None)
+    role = next(filter(lambda prop: prop.name == "role", message_properties), None)
+    return (
+        content
+        and content.dtype == schema.DataType.string
+        and role
+        and role.dtype == schema.DataType.string
+    )
+
+
+def _is_output_agent_compatible(outputs: schema.Schema) -> bool:
+    return (
+        _is_output_string_response(outputs)
+        or _is_output_string(outputs)
+        or _is_output_chat_completion_response(outputs)
+    )
+
+
+def _is_signature_agent_compatible(signature: ModelSignature) -> bool:
+    """Determines whether the given signature is compatible with the agent eval schema.
+
+    See https://docs.databricks.com/en/generative-ai/agent-evaluation/evaluation-schema.html.
+    The schema accepts the OpenAI spec, as well as simpler formats such as vanilla string response
+    and `StringResponse`.
+    """
+    return _is_input_agent_compatible(signature.inputs) and _is_output_agent_compatible(
+        signature.outputs
+    )
+
+
+def _should_render_agent_eval_template(signature: ModelSignature) -> bool:
+    if not databricks_utils.is_in_databricks_runtime():
+        return False
+    from IPython import get_ipython
+
+    if get_ipython() is None:
+        return False
+    return _is_signature_agent_compatible(signature)
+
+
+def _generate_agent_eval_recipe(model_uri: str) -> str:
+    resources_dir = Path(__file__).parent / "notebook_resources"
+    pip_install_command = """%pip install -U databricks-agents
+dbutils.library.restartPython()
+## Run the above in a separate cell ##"""
+    eval_with_synthetic_code = (
+        (resources_dir / "eval_with_synthetic_example.py")
+        .read_text()
+        .replace("{{pipInstall}}", pip_install_command)
+        .replace("{{modelUri}}", model_uri)
+    )
+    eval_with_dataset_code = (
+        (resources_dir / "eval_with_dataset_example.py")
+        .read_text()
+        .replace("{{pipInstall}}", pip_install_command)
+        .replace("{{modelUri}}", model_uri)
+    )
+
+    # Remove the ruff noqa comments.
+    ruff_line = "# ruff: noqa: F821, I001\n"
+    eval_with_synthetic_code = eval_with_synthetic_code.replace(ruff_line, "")
+    eval_with_dataset_code = eval_with_dataset_code.replace(ruff_line, "")
+
+    return (
+        (resources_dir / "agent_evaluation_template.html")
+        .read_text()
+        .replace("{{eval_with_synthetic_code}}", html.escape(eval_with_synthetic_code))
+        .replace("{{eval_with_dataset_code}}", html.escape(eval_with_dataset_code))
+    )
+
+
+def maybe_render_agent_eval_recipe(model_info: ModelInfo) -> None:
+    # For safety, we wrap in try/catch to make sure we don't break `mlflow.*.log_model`.
+    try:
+        if not _should_render_agent_eval_template(model_info.signature):
+            return
+
+        from IPython.display import HTML, display
+
+        display(HTML(_generate_agent_eval_recipe(model_info.model_uri)))
+    except Exception:
+        pass

mlflow/models/docker_utils.py

@@ -0,0 +1,211 @@
+import logging
+import os
+from subprocess import Popen
+from typing import Optional, Union
+from urllib.parse import urlparse
+
+from mlflow.environment_variables import MLFLOW_DOCKER_OPENJDK_VERSION
+from mlflow.utils import env_manager as em
+from mlflow.utils.file_utils import _copy_project
+from mlflow.version import VERSION
+
+_logger = logging.getLogger(__name__)
+
+UBUNTU_BASE_IMAGE = "ubuntu:20.04"
+PYTHON_SLIM_BASE_IMAGE = "python:{version}-slim"
+
+
+SETUP_PYENV_AND_VIRTUALENV = r"""# Setup pyenv
+RUN DEBIAN_FRONTEND=noninteractive TZ=Etc/UTC apt-get -y install tzdata \
+    libssl-dev zlib1g-dev libbz2-dev libreadline-dev libsqlite3-dev wget curl llvm \
+    libncursesw5-dev xz-utils tk-dev libxml2-dev libxmlsec1-dev libffi-dev liblzma-dev
+RUN git clone \
+    --depth 1 \
+    --branch $(git ls-remote --tags --sort=v:refname https://github.com/pyenv/pyenv.git | grep -o -E 'v[1-9]+(\.[1-9]+)+$' | tail -1) \
+    https://github.com/pyenv/pyenv.git /root/.pyenv
+ENV PYENV_ROOT="/root/.pyenv"
+ENV PATH="$PYENV_ROOT/bin:$PATH"
+RUN apt install -y software-properties-common \
+    && apt update \
+    && add-apt-repository -y ppa:deadsnakes/ppa \
+    && apt update \
+    && apt install -y python3.10 python3.10-distutils \
+    && ln -s -f $(which python3.10) /usr/bin/python \
+    && wget https://bootstrap.pypa.io/get-pip.py -O /tmp/get-pip.py \
+    && python /tmp/get-pip.py
+RUN pip install virtualenv
+"""  # noqa: E501
+
+_DOCKERFILE_TEMPLATE = """# Build an image that can serve mlflow models.
+FROM {base_image}
+
+{setup_python_venv}
+
+{setup_java}
+
+WORKDIR /opt/mlflow
+
+{install_mlflow}
+
+{install_model_and_deps}
+
+ENV MLFLOW_DISABLE_ENV_CREATION={disable_env_creation}
+ENV ENABLE_MLSERVER={enable_mlserver}
+
+# granting read/write access and conditional execution authority to all child directories
+# and files to allow for deployment to AWS Sagemaker Serverless Endpoints
+# (see https://docs.aws.amazon.com/sagemaker/latest/dg/serverless-endpoints.html)
+RUN chmod o+rwX /opt/mlflow/
+
+# clean up apt cache to reduce image size
+RUN rm -rf /var/lib/apt/lists/*
+
+ENTRYPOINT ["python", "-c", "{entrypoint}"]
+"""
+
+
+SETUP_MINICONDA = """# Setup miniconda
+RUN curl --fail -L https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh > miniconda.sh
+RUN bash ./miniconda.sh -b -p /miniconda && rm ./miniconda.sh
+ENV PATH="/miniconda/bin:$PATH"
+"""  # noqa: E501
+
+
+def generate_dockerfile(
+    output_dir: str,
+    base_image: str,
+    model_install_steps: Optional[str],
+    entrypoint: str,
+    env_manager: Union[em.CONDA, em.LOCAL, em.VIRTUALENV],
+    mlflow_home: Optional[str] = None,
+    enable_mlserver: bool = False,
+    disable_env_creation_at_runtime: bool = True,
+    install_java: Optional[bool] = None,
+):
+    """
+    Generates a Dockerfile that can be used to build a docker image, that serves ML model
+    stored and tracked in MLflow.
+    """
+
+    setup_java_steps = ""
+    setup_python_venv_steps = ""
+    install_mlflow_steps = _pip_mlflow_install_step(output_dir, mlflow_home)
+
+    if base_image.startswith("python:"):
+        if install_java:
+            _logger.warning(
+                "`install_java` option is not supported when using python base image, "
+                "switch to UBUNTU_BASE_IMAGE to enable java installation."
+            )
+        setup_python_venv_steps = (
+            "RUN apt-get -y update && apt-get install -y --no-install-recommends nginx"
+        )
+
+    elif base_image == UBUNTU_BASE_IMAGE:
+        setup_python_venv_steps = (
+            "RUN apt-get -y update && DEBIAN_FRONTEND=noninteractive TZ=Etc/UTC apt-get install -y "
+            "--no-install-recommends wget curl nginx ca-certificates bzip2 build-essential cmake "
+            "git-core\n\n"
+        )
+        setup_python_venv_steps += (
+            SETUP_MINICONDA if env_manager == em.CONDA else SETUP_PYENV_AND_VIRTUALENV
+        )
+        if install_java is not False:
+            jdk_ver = MLFLOW_DOCKER_OPENJDK_VERSION.get()
+            setup_java_steps = (
+                "# Setup Java\n"
+                f"RUN apt-get install -y --no-install-recommends openjdk-{jdk_ver}-jdk maven\n"
+                f"ENV JAVA_HOME=/usr/lib/jvm/java-{jdk_ver}-openjdk-amd64"
+            )
+
+    with open(os.path.join(output_dir, "Dockerfile"), "w") as f:
+        f.write(
+            _DOCKERFILE_TEMPLATE.format(
+                base_image=base_image,
+                setup_python_venv=setup_python_venv_steps,
+                setup_java=setup_java_steps,
+                install_mlflow=install_mlflow_steps,
+                install_model_and_deps=model_install_steps,
+                entrypoint=entrypoint,
+                enable_mlserver=enable_mlserver,
+                disable_env_creation=disable_env_creation_at_runtime,
+            )
+        )
+
+
+def _get_maven_proxy():
+    http_proxy = os.getenv("http_proxy")
+    https_proxy = os.getenv("https_proxy")
+    if not http_proxy or not https_proxy:
+        return ""
+
+    # Expects proxies as either PROTOCOL://{USER}:{PASSWORD}@HOSTNAME:PORT
+    # or PROTOCOL://HOSTNAME:PORT
+    parsed_http_proxy = urlparse(http_proxy)
+    assert parsed_http_proxy.hostname is not None, "Invalid `http_proxy` hostname."
+    assert parsed_http_proxy.port is not None, f"Invalid proxy port: {parsed_http_proxy.port}"
+
+    parsed_https_proxy = urlparse(https_proxy)
+    assert parsed_https_proxy.hostname is not None, "Invalid `https_proxy` hostname."
+    assert parsed_https_proxy.port is not None, f"Invalid proxy port: {parsed_https_proxy.port}"
+
+    maven_proxy_options = (
+        "-DproxySet=true",
+        f"-Dhttp.proxyHost={parsed_http_proxy.hostname}",
+        f"-Dhttp.proxyPort={parsed_http_proxy.port}",
+        f"-Dhttps.proxyHost={parsed_https_proxy.hostname}",
+        f"-Dhttps.proxyPort={parsed_https_proxy.port}",
+        "-Dhttps.nonProxyHosts=repo.maven.apache.org",
+    )
+
+    if parsed_http_proxy.username is None or parsed_http_proxy.password is None:
+        return " ".join(maven_proxy_options)
+
+    return " ".join(
+        (
+            *maven_proxy_options,
+            f"-Dhttp.proxyUser={parsed_http_proxy.username}",
+            f"-Dhttp.proxyPassword={parsed_http_proxy.password}",
+        )
+    )
+
+
+def _pip_mlflow_install_step(dockerfile_context_dir, mlflow_home):
+    """
+    Get docker build commands for installing MLflow given a Docker context dir and optional source
+    directory
+    """
+    if mlflow_home:
+        mlflow_dir = _copy_project(
+            src_path=os.path.abspath(mlflow_home), dst_path=dockerfile_context_dir
+        )
+        return (
+            "# Install MLflow from local source\n"
+            f"COPY {mlflow_dir} /opt/mlflow\n"
+            "RUN pip install /opt/mlflow"
+        )
+    else:
+        return f"# Install MLflow\nRUN pip install mlflow=={VERSION}"
+
+
+def build_image_from_context(context_dir: str, image_name: str):
+    import docker
+
+    client = docker.from_env()
+    # In Docker < 19, `docker build` doesn't support the `--platform` option
+    is_platform_supported = int(client.version()["Version"].split(".")[0]) >= 19
+    # Enforcing the AMD64 architecture build for Apple M1 users
+    platform_option = ["--platform", "linux/amd64"] if is_platform_supported else []
+    commands = [
+        "docker",
+        "build",
+        "-t",
+        image_name,
+        "-f",
+        "Dockerfile",
+        *platform_option,
+        ".",
+    ]
+    proc = Popen(commands, cwd=context_dir)
+    if proc.wait():
+        raise RuntimeError("Docker build failed.")

mlflow/models/evaluation/__init__.py

@@ -0,0 +1,23 @@
+from mlflow.data.evaluation_dataset import EvaluationDataset
+from mlflow.models.evaluation.base import (
+    EvaluationArtifact,
+    EvaluationMetric,
+    EvaluationResult,
+    ModelEvaluator,
+    evaluate,
+    list_evaluators,
+    make_metric,
+)
+from mlflow.models.evaluation.validation import MetricThreshold
+
+__all__ = [
+    "ModelEvaluator",
+    "EvaluationDataset",
+    "EvaluationResult",
+    "EvaluationMetric",
+    "EvaluationArtifact",
+    "make_metric",
+    "evaluate",
+    "list_evaluators",
+    "MetricThreshold",
+]

mlflow/models/evaluation/_shap_patch.py

@@ -0,0 +1,64 @@
+import pickle
+
+import numpy as np
+import shap
+from shap._serializable import Deserializer, Serializable, Serializer
+
+
+class _PatchedKernelExplainer(shap.KernelExplainer):
+    @staticmethod
+    def not_equal(i, j):
+        # `shap.KernelExplainer.not_equal` method fails on some special types such as
+        # timestamp, this breaks the kernel explainer routine.
+        # `PatchedKernelExplainer` fixes this issue.
+        # See https://github.com/slundberg/shap/pull/2586
+        number_types = (int, float, np.number)
+        if isinstance(i, number_types) and isinstance(j, number_types):
+            return 0 if np.isclose(i, j, equal_nan=True) else 1
+        else:
+            return 0 if i == j else 1
+
+    def save(self, out_file, model_saver=None, masker_saver=None):
+        """
+        This patched `save` method fix `KernelExplainer.save`.
+        Issues in original `KernelExplainer.save`:
+         - It saves model by calling model.save, but shap.utils._legacy.Model has no save method
+         - It tries to save "masker", but there's no "masker" in KernelExplainer
+         - It does not save "KernelExplainer.data" attribute, the attribute is required when
+           loading back
+        Note: `model_saver` and `masker_saver` are meaningless argument for `KernelExplainer.save`,
+        the model in "KernelExplainer" is an instance of `shap.utils._legacy.Model`
+        (it wraps the predict function), we can only use pickle to dump it.
+        and no `masker` for KernelExplainer so `masker_saver` is meaningless.
+        but I preserve the 2 argument for overridden API compatibility.
+        """
+        pickle.dump(type(self), out_file)
+        with Serializer(out_file, "shap.Explainer", version=0) as s:
+            s.save("model", self.model)
+            s.save("link", self.link)
+            s.save("data", self.data)
+
+    @classmethod
+    def load(cls, in_file, model_loader=None, masker_loader=None, instantiate=True):
+        """
+        This patched `load` method fix `KernelExplainer.load`.
+        Issues in original KernelExplainer.load:
+         - Use mismatched model loader to load model
+         - Try to load non-existent "masker" attribute
+         - Does not load "data" attribute and then cause calling " KernelExplainer"
+           constructor lack of "data" argument.
+        Note: `model_loader` and `masker_loader` are meaningless argument for
+        `KernelExplainer.save`, because the `model` object is saved by pickle dump,
+        we must use pickle load to load it.
+        and no `masker` for KernelExplainer so `masker_loader` is meaningless.
+        but I preserve the 2 argument for overridden API compatibility.
+        """
+        if instantiate:
+            return cls._instantiated_load(in_file, model_loader=None, masker_loader=None)
+
+        kwargs = Serializable.load(in_file, instantiate=False)
+        with Deserializer(in_file, "shap.Explainer", min_version=0, max_version=0) as s:
+            kwargs["model"] = s.load("model")
+            kwargs["link"] = s.load("link")
+            kwargs["data"] = s.load("data")
+        return kwargs

mlflow/models/evaluation/artifacts.py

@@ -0,0 +1,194 @@
+import json
+import pathlib
+import pickle
+from collections import namedtuple
+from json import JSONDecodeError
+
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+
+from mlflow.exceptions import MlflowException
+from mlflow.models.evaluation.base import EvaluationArtifact
+from mlflow.utils.annotations import developer_stable
+from mlflow.utils.proto_json_utils import NumpyEncoder
+
+
+@developer_stable
+class ImageEvaluationArtifact(EvaluationArtifact):
+    def _save(self, output_artifact_path):
+        self._content.save(output_artifact_path)
+
+    def _load_content_from_file(self, local_artifact_path):
+        from PIL.Image import open as open_image
+
+        self._content = open_image(local_artifact_path)
+        self._content.load()  # Load image and close the file descriptor.
+        return self._content
+
+
+@developer_stable
+class CsvEvaluationArtifact(EvaluationArtifact):
+    def _save(self, output_artifact_path):
+        self._content.to_csv(output_artifact_path, index=False)
+
+    def _load_content_from_file(self, local_artifact_path):
+        self._content = pd.read_csv(local_artifact_path)
+        return self._content
+
+
+@developer_stable
+class ParquetEvaluationArtifact(EvaluationArtifact):
+    def _save(self, output_artifact_path):
+        self._content.to_parquet(output_artifact_path, compression="brotli")
+
+    def _load_content_from_file(self, local_artifact_path):
+        self._content = pd.read_parquet(local_artifact_path)
+        return self._content
+
+
+@developer_stable
+class NumpyEvaluationArtifact(EvaluationArtifact):
+    def _save(self, output_artifact_path):
+        np.save(output_artifact_path, self._content, allow_pickle=False)
+
+    def _load_content_from_file(self, local_artifact_path):
+        self._content = np.load(local_artifact_path, allow_pickle=False)
+        return self._content
+
+
+@developer_stable
+class JsonEvaluationArtifact(EvaluationArtifact):
+    def _save(self, output_artifact_path):
+        with open(output_artifact_path, "w") as f:
+            json.dump(self._content, f)
+
+    def _load_content_from_file(self, local_artifact_path):
+        with open(local_artifact_path) as f:
+            self._content = json.load(f)
+        return self._content
+
+
+@developer_stable
+class TextEvaluationArtifact(EvaluationArtifact):
+    def _save(self, output_artifact_path):
+        with open(output_artifact_path, "w") as f:
+            f.write(self._content)
+
+    def _load_content_from_file(self, local_artifact_path):
+        with open(local_artifact_path) as f:
+            self._content = f.read()
+        return self._content
+
+
+@developer_stable
+class PickleEvaluationArtifact(EvaluationArtifact):
+    def _save(self, output_artifact_path):
+        with open(output_artifact_path, "wb") as f:
+            pickle.dump(self._content, f)
+
+    def _load_content_from_file(self, local_artifact_path):
+        with open(local_artifact_path, "rb") as f:
+            self._content = pickle.load(f)
+        return self._content
+
+
+_EXT_TO_ARTIFACT_MAP = {
+    ".png": ImageEvaluationArtifact,
+    ".jpg": ImageEvaluationArtifact,
+    ".jpeg": ImageEvaluationArtifact,
+    ".json": JsonEvaluationArtifact,
+    ".npy": NumpyEvaluationArtifact,
+    ".csv": CsvEvaluationArtifact,
+    ".parquet": ParquetEvaluationArtifact,
+    ".txt": TextEvaluationArtifact,
+}
+
+_TYPE_TO_EXT_MAP = {
+    pd.DataFrame: ".csv",
+    np.ndarray: ".npy",
+    plt.Figure: ".png",
+}
+
+_TYPE_TO_ARTIFACT_MAP = {
+    pd.DataFrame: CsvEvaluationArtifact,
+    np.ndarray: NumpyEvaluationArtifact,
+    plt.Figure: ImageEvaluationArtifact,
+}
+
+_InferredArtifactProperties = namedtuple(
+    "_InferredArtifactProperties", ["from_path", "type", "ext"]
+)
+
+
+def _infer_artifact_type_and_ext(artifact_name, raw_artifact, custom_metric_tuple):
+    """
+    This function performs type and file extension inference on the provided artifact
+
+    Args:
+        artifact_name: The name of the provided artifact
+        raw_artifact: The artifact object
+        custom_metric_tuple: Containing a user provided function and its index in the
+            ``custom_metrics`` parameter of ``mlflow.evaluate``
+
+    Returns:
+        InferredArtifactProperties namedtuple
+    """
+
+    exception_header = (
+        f"Custom metric function '{custom_metric_tuple.name}' at index "
+        f"{custom_metric_tuple.index} in the `custom_metrics` parameter produced an "
+        f"artifact '{artifact_name}'"
+    )
+
+    # Given a string, first see if it is a path. Otherwise, check if it is a JsonEvaluationArtifact
+    if isinstance(raw_artifact, str):
+        potential_path = pathlib.Path(raw_artifact)
+        if potential_path.exists():
+            raw_artifact = potential_path
+        else:
+            try:
+                json.loads(raw_artifact)
+                return _InferredArtifactProperties(
+                    from_path=False, type=JsonEvaluationArtifact, ext=".json"
+                )
+            except JSONDecodeError:
+                raise MlflowException(
+                    f"{exception_header} with string representation '{raw_artifact}' that is "
+                    f"neither a valid path to a file nor a JSON string."
+                )
+
+    # Type inference based on the file extension
+    if isinstance(raw_artifact, pathlib.Path):
+        if not raw_artifact.exists():
+            raise MlflowException(f"{exception_header} with path '{raw_artifact}' does not exist.")
+        if not raw_artifact.is_file():
+            raise MlflowException(f"{exception_header} with path '{raw_artifact}' is not a file.")
+        if raw_artifact.suffix not in _EXT_TO_ARTIFACT_MAP:
+            raise MlflowException(
+                f"{exception_header} with path '{raw_artifact}' does not match any of the supported"
+                f" file extensions: {', '.join(_EXT_TO_ARTIFACT_MAP.keys())}."
+            )
+        return _InferredArtifactProperties(
+            from_path=True, type=_EXT_TO_ARTIFACT_MAP[raw_artifact.suffix], ext=raw_artifact.suffix
+        )
+
+    # Type inference based on object type
+    if type(raw_artifact) in _TYPE_TO_ARTIFACT_MAP:
+        return _InferredArtifactProperties(
+            from_path=False,
+            type=_TYPE_TO_ARTIFACT_MAP[type(raw_artifact)],
+            ext=_TYPE_TO_EXT_MAP[type(raw_artifact)],
+        )
+
+    # Given as other python object, we first attempt to infer as JsonEvaluationArtifact. If that
+    # fails, we store it as PickleEvaluationArtifact
+    try:
+        json.dumps(raw_artifact, cls=NumpyEncoder)
+        return _InferredArtifactProperties(
+            from_path=False, type=JsonEvaluationArtifact, ext=".json"
+        )
+    except TypeError:
+        return _InferredArtifactProperties(
+            from_path=False, type=PickleEvaluationArtifact, ext=".pickle"
+        )