genesis-flow 1.0.0__py3-none-any.whl

mlflow/rfunc/__init__.py

@@ -0,0 +1,42 @@
+"""Export and import of generic R models.
+
+This module defines generic filesystem format for R models and provides utilities
+for saving and loading to and from this format. The format is self contained in the sense
+that it includes all necessary information for anyone to load it and use it. Dependencies
+are either stored directly with the model or referenced via a Conda environment.
+
+The convention for rfunc models is to have a ``predict`` method or function with the following
+signature::
+
+    predict(data: DataFrame) -> DataFrame
+
+This convention is relied on by other MLflow components.
+
+Rfunc model format is defined as a directory structure containing all required data, code, and
+configuration:
+
+.. code::
+
+    ./dst-path/
+            ./MLmodel: configuration
+
+It must contain MLmodel file in its root with "r_function" format.
+
+Example:
+
+.. code:: shell
+
+  >tree R/mlflow/R/inst/examples/R/lm/model
+  ├── MLmodel
+  └── r_model.bin
+
+  >cat R/mlflow/R/inst/examples/R/lm/model/MLmodel
+  time_created: 1.5337659e+09
+  flavors:
+    r_function:
+      version: 0.1.0
+      model: r_model.bin
+
+"""
+
+FLAVOR_NAME = "crate"

mlflow/rfunc/backend.py

@@ -0,0 +1,134 @@
+import logging
+import os
+import re
+import subprocess
+import sys
+
+from mlflow.exceptions import MlflowException
+from mlflow.models import FlavorBackend
+from mlflow.tracking.artifact_utils import _download_artifact_from_uri
+from mlflow.utils.string_utils import quote
+
+_logger = logging.getLogger(__name__)
+
+
+class RFuncBackend(FlavorBackend):
+    """
+    Flavor backend implementation for the generic R models.
+    Predict and serve locally models with 'crate' flavor.
+    """
+
+    def build_image(
+        self, model_uri, image_name, install_mlflow, mlflow_home, enable_mlserver, base_image=None
+    ):
+        pass
+
+    def generate_dockerfile(
+        self, model_uri, output_path, install_mlflow, mlflow_home, enable_mlserver, base_image=None
+    ):
+        pass
+
+    version_pattern = re.compile(r"version ([0-9]+\.[0-9]+\.[0-9]+)")
+
+    def predict(
+        self,
+        model_uri,
+        input_path,
+        output_path,
+        content_type,
+        pip_requirements_override=None,
+        extra_envs=None,
+    ):
+        """
+        Generate predictions using R model saved with MLflow.
+        Return the prediction results as a JSON.
+        """
+        if pip_requirements_override is not None:
+            raise MlflowException("pip_requirements_override is not supported in the R backend.")
+        model_path = _download_artifact_from_uri(model_uri)
+        str_cmd = (
+            "mlflow:::mlflow_rfunc_predict(model_path = '{0}', input_path = {1}, "
+            "output_path = {2}, content_type = {3})"
+        )
+        command = str_cmd.format(
+            quote(model_path),
+            _str_optional(input_path),
+            _str_optional(output_path),
+            _str_optional(content_type),
+        )
+        _execute(command, extra_envs=extra_envs)
+
+    def serve(
+        self,
+        model_uri,
+        port,
+        host,
+        timeout,
+        enable_mlserver,
+        synchronous=True,
+        stdout=None,
+        stderr=None,
+    ):
+        """
+        Generate R model locally.
+
+        NOTE: The `enable_mlserver` parameter is there to comply with the
+        FlavorBackend interface but is not supported by MLServer yet.
+        https://github.com/SeldonIO/MLServer/issues/183
+        """
+        if enable_mlserver:
+            raise Exception("The MLServer inference server is not yet supported in the R backend.")
+
+        if timeout:
+            _logger.warning("Timeout is not yet supported in the R backend.")
+
+        if not synchronous:
+            raise Exception("RBackend does not support call with synchronous=False")
+
+        if stdout is not None or stderr is not None:
+            raise Exception("RBackend does not support redirect stdout/stderr.")
+
+        model_path = _download_artifact_from_uri(model_uri)
+        command = "mlflow::mlflow_rfunc_serve('{}', port = {}, host = '{}')".format(
+            quote(model_path), port, host
+        )
+        _execute(command)
+
+    def can_score_model(self):
+        # `Rscript --version` writes to stderr in R < 4.2.0 but stdout in R >= 4.2.0.
+        process = subprocess.Popen(
+            ["Rscript", "--version"],
+            close_fds=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+        )
+        stdout, _ = process.communicate()
+        if process.wait() != 0:
+            return False
+
+        version = self.version_pattern.search(stdout.decode("utf-8"))
+        if not version:
+            return False
+        version = [int(x) for x in version.group(1).split(".")]
+        return version[0] > 3 or version[0] == 3 and version[1] >= 3
+
+
+def _execute(command, extra_envs=None):
+    env = os.environ.copy()
+    if extra_envs:
+        env.update(extra_envs)
+
+    process = subprocess.Popen(
+        ["Rscript", "-e", command],
+        env=env,
+        close_fds=False,
+        stdin=sys.stdin,
+        stdout=sys.stdout,
+        stderr=sys.stderr,
+    )
+    if process.wait() != 0:
+        raise Exception("Command returned non zero exit code.")
+
+
+def _str_optional(s):
+    return "NULL" if s is None else f"'{quote(str(s))}'"

mlflow/runs.py

@@ -0,0 +1,89 @@
+"""
+CLI for runs
+"""
+
+import json
+
+import click
+
+from mlflow.entities import ViewType
+from mlflow.environment_variables import MLFLOW_EXPERIMENT_ID
+from mlflow.tracking import _get_store
+from mlflow.utils.string_utils import _create_table
+from mlflow.utils.time import conv_longdate_to_str
+
+RUN_ID = click.option("--run-id", type=click.STRING, required=True)
+
+
+@click.group("runs")
+def commands():
+    """
+    Manage runs. To manage runs of experiments associated with a tracking server, set the
+    MLFLOW_TRACKING_URI environment variable to the URL of the desired server.
+    """
+
+
+@commands.command("list")
+@click.option(
+    "--experiment-id",
+    envvar=MLFLOW_EXPERIMENT_ID.name,
+    type=click.STRING,
+    help="Specify the experiment ID for list of runs.",
+    required=True,
+)
+@click.option(
+    "--view",
+    "-v",
+    default="active_only",
+    help="Select view type for list experiments. Valid view types are "
+    "'active_only' (default), 'deleted_only', and 'all'.",
+)
+def list_run(experiment_id, view):
+    """
+    List all runs of the specified experiment in the configured tracking server.
+    """
+    store = _get_store()
+    view_type = ViewType.from_string(view) if view else ViewType.ACTIVE_ONLY
+    runs = store.search_runs([experiment_id], None, view_type)
+    table = []
+    for run in runs:
+        run_name = run.info.run_name or ""
+        table.append([conv_longdate_to_str(run.info.start_time), run_name, run.info.run_id])
+    click.echo(_create_table(sorted(table, reverse=True), headers=["Date", "Name", "ID"]))
+
+
+@commands.command("delete")
+@RUN_ID
+def delete_run(run_id):
+    """
+    Mark a run for deletion. Return an error if the run does not exist or
+    is already marked. You can restore a marked run with ``restore_run``,
+    or permanently delete a run in the backend store.
+    """
+    store = _get_store()
+    store.delete_run(run_id)
+    click.echo(f"Run with ID {run_id} has been deleted.")
+
+
+@commands.command("restore")
+@RUN_ID
+def restore_run(run_id):
+    """
+    Restore a deleted run.
+    Returns an error if the run is active or has been permanently deleted.
+    """
+    store = _get_store()
+    store.restore_run(run_id)
+    click.echo(f"Run with id {run_id} has been restored.")
+
+
+@commands.command("describe")
+@RUN_ID
+def describe_run(run_id):
+    """
+    All of run details will print to the stdout as JSON format.
+    """
+    store = _get_store()
+    run = store.get_run(run_id)
+    json_run = json.dumps(run.to_dictionary(), indent=4)
+    click.echo(json_run)

mlflow/server/__init__.py

@@ -0,0 +1,302 @@
+import importlib
+import importlib.metadata
+import os
+import shlex
+import sys
+import textwrap
+import types
+
+from flask import Flask, Response, send_from_directory
+from packaging.version import Version
+
+from mlflow.environment_variables import MLFLOW_FLASK_SERVER_SECRET_KEY
+from mlflow.exceptions import MlflowException
+from mlflow.server import handlers
+from mlflow.server.handlers import (
+    STATIC_PREFIX_ENV_VAR,
+    _add_static_prefix,
+    create_promptlab_run_handler,
+    gateway_proxy_handler,
+    get_artifact_handler,
+    get_logged_model_artifact_handler,
+    get_metric_history_bulk_handler,
+    get_metric_history_bulk_interval_handler,
+    get_model_version_artifact_handler,
+    get_trace_artifact_handler,
+    search_datasets_handler,
+    upload_artifact_handler,
+)
+from mlflow.utils.os import is_windows
+from mlflow.utils.plugins import get_entry_points
+from mlflow.utils.process import _exec_cmd
+from mlflow.version import VERSION
+
+# NB: These are internal environment variables used for communication between
+# the cli and the forked gunicorn processes.
+BACKEND_STORE_URI_ENV_VAR = "_MLFLOW_SERVER_FILE_STORE"
+REGISTRY_STORE_URI_ENV_VAR = "_MLFLOW_SERVER_REGISTRY_STORE"
+ARTIFACT_ROOT_ENV_VAR = "_MLFLOW_SERVER_ARTIFACT_ROOT"
+ARTIFACTS_DESTINATION_ENV_VAR = "_MLFLOW_SERVER_ARTIFACT_DESTINATION"
+PROMETHEUS_EXPORTER_ENV_VAR = "prometheus_multiproc_dir"
+SERVE_ARTIFACTS_ENV_VAR = "_MLFLOW_SERVER_SERVE_ARTIFACTS"
+ARTIFACTS_ONLY_ENV_VAR = "_MLFLOW_SERVER_ARTIFACTS_ONLY"
+
+# Genesis-Flow: UI removed, no static directory needed
+REL_STATIC_DIR = None
+
+app = Flask(__name__)
+IS_FLASK_V1 = Version(importlib.metadata.version("flask")) < Version("2.0")
+
+
+for http_path, handler, methods in handlers.get_endpoints():
+    app.add_url_rule(http_path, handler.__name__, handler, methods=methods)
+
+if os.getenv(PROMETHEUS_EXPORTER_ENV_VAR):
+    from mlflow.server.prometheus_exporter import activate_prometheus_exporter
+
+    prometheus_metrics_path = os.getenv(PROMETHEUS_EXPORTER_ENV_VAR)
+    if not os.path.exists(prometheus_metrics_path):
+        os.makedirs(prometheus_metrics_path)
+    activate_prometheus_exporter(app)
+
+
+# Provide a health check endpoint to ensure the application is responsive
+@app.route("/health")
+def health():
+    return "OK", 200
+
+
+# Provide an endpoint to query the version of mlflow running on the server
+@app.route("/version")
+def version():
+    return VERSION, 200
+
+
+# Serve the "get-artifact" route.
+@app.route(_add_static_prefix("/get-artifact"))
+def serve_artifacts():
+    return get_artifact_handler()
+
+
+# Serve the "model-versions/get-artifact" route.
+@app.route(_add_static_prefix("/model-versions/get-artifact"))
+def serve_model_version_artifact():
+    return get_model_version_artifact_handler()
+
+
+# Serve the "metrics/get-history-bulk" route.
+@app.route(_add_static_prefix("/ajax-api/2.0/mlflow/metrics/get-history-bulk"))
+def serve_get_metric_history_bulk():
+    return get_metric_history_bulk_handler()
+
+
+# Serve the "metrics/get-history-bulk-interval" route.
+@app.route(_add_static_prefix("/ajax-api/2.0/mlflow/metrics/get-history-bulk-interval"))
+def serve_get_metric_history_bulk_interval():
+    return get_metric_history_bulk_interval_handler()
+
+
+# Serve the "experiments/search-datasets" route.
+@app.route(_add_static_prefix("/ajax-api/2.0/mlflow/experiments/search-datasets"), methods=["POST"])
+def serve_search_datasets():
+    return search_datasets_handler()
+
+
+# Serve the "runs/create-promptlab-run" route.
+@app.route(_add_static_prefix("/ajax-api/2.0/mlflow/runs/create-promptlab-run"), methods=["POST"])
+def serve_create_promptlab_run():
+    return create_promptlab_run_handler()
+
+
+@app.route(_add_static_prefix("/ajax-api/2.0/mlflow/gateway-proxy"), methods=["POST", "GET"])
+def serve_gateway_proxy():
+    return gateway_proxy_handler()
+
+
+@app.route(_add_static_prefix("/ajax-api/2.0/mlflow/upload-artifact"), methods=["POST"])
+def serve_upload_artifact():
+    return upload_artifact_handler()
+
+
+# Serve the "/get-trace-artifact" route to allow frontend to fetch trace artifacts
+# and render them in the Trace UI. The request body should contain the request_id
+# of the trace.
+@app.route(_add_static_prefix("/ajax-api/2.0/mlflow/get-trace-artifact"), methods=["GET"])
+def serve_get_trace_artifact():
+    return get_trace_artifact_handler()
+
+
+@app.route(
+    _add_static_prefix("/ajax-api/2.0/mlflow/logged-models/<model_id>/artifacts/files"),
+    methods=["GET"],
+)
+def serve_get_logged_model_artifact(model_id: str):
+    return get_logged_model_artifact_handler(model_id)
+
+
+# Genesis-Flow: No static files to serve (UI removed)
+@app.route(_add_static_prefix("/static-files/<path:path>"))
+def serve_static_file(path):
+    return Response("Genesis-Flow: Static files not available (UI removed)", status=404, mimetype="text/plain")
+
+
+# Genesis-Flow: API-only server, no UI
+@app.route(_add_static_prefix("/"))
+def serve():
+    text = textwrap.dedent(
+        """
+    Genesis-Flow API Server
+    
+    This is an API-only MLflow-compatible server without UI components.
+    Access the REST API endpoints at /api/2.0/mlflow/
+    
+    Health check: /health
+    Version: /version
+    """
+    )
+    return Response(text, mimetype="text/plain")
+
+
+def _find_app(app_name: str) -> str:
+    apps = get_entry_points("mlflow.app")
+    for app in apps:
+        if app.name == app_name:
+            return app.value
+
+    raise MlflowException(
+        f"Failed to find app '{app_name}'. Available apps: {[a.name for a in apps]}"
+    )
+
+
+def _is_factory(app: str) -> bool:
+    """
+    Returns True if the given app is a factory function, False otherwise.
+
+    Args:
+        app: The app to check, e.g. "mlflow.server.app:app
+    """
+    module, obj_name = app.rsplit(":", 1)
+    mod = importlib.import_module(module)
+    obj = getattr(mod, obj_name)
+    return isinstance(obj, types.FunctionType)
+
+
+def get_app_client(app_name: str, *args, **kwargs):
+    """
+    Instantiate a client provided by an app.
+
+    Args:
+        app_name: The app name defined in `setup.py`, e.g., "basic-auth".
+        args: Additional arguments passed to the app client constructor.
+        kwargs: Additional keyword arguments passed to the app client constructor.
+
+    Returns:
+        An app client instance.
+    """
+    clients = get_entry_points("mlflow.app.client")
+    for client in clients:
+        if client.name == app_name:
+            cls = client.load()
+            return cls(*args, **kwargs)
+
+    raise MlflowException(
+        f"Failed to find client for '{app_name}'. Available clients: {[c.name for c in clients]}"
+    )
+
+
+def _build_waitress_command(waitress_opts, host, port, app_name, is_factory):
+    opts = shlex.split(waitress_opts) if waitress_opts else []
+    return [
+        sys.executable,
+        "-m",
+        "waitress",
+        *opts,
+        f"--host={host}",
+        f"--port={port}",
+        "--ident=mlflow",
+        *(["--call"] if is_factory else []),
+        app_name,
+    ]
+
+
+def _build_gunicorn_command(gunicorn_opts, host, port, workers, app_name):
+    bind_address = f"{host}:{port}"
+    opts = shlex.split(gunicorn_opts) if gunicorn_opts else []
+    return [
+        sys.executable,
+        "-m",
+        "gunicorn",
+        *opts,
+        "-b",
+        bind_address,
+        "-w",
+        str(workers),
+        app_name,
+    ]
+
+
+def _run_server(  # noqa: D417
+    file_store_path,
+    registry_store_uri,
+    default_artifact_root,
+    serve_artifacts,
+    artifacts_only,
+    artifacts_destination,
+    host,
+    port,
+    static_prefix=None,
+    workers=None,
+    gunicorn_opts=None,
+    waitress_opts=None,
+    expose_prometheus=None,
+    app_name=None,
+):
+    """
+    Run the MLflow server, wrapping it in gunicorn or waitress on windows
+
+    Args:
+        static_prefix: If set, the index.html asset will be served from the path static_prefix.
+                       If left None, the index.html asset will be served from the root path.
+
+    Returns:
+        None
+    """
+    env_map = {}
+    if file_store_path:
+        env_map[BACKEND_STORE_URI_ENV_VAR] = file_store_path
+    if registry_store_uri:
+        env_map[REGISTRY_STORE_URI_ENV_VAR] = registry_store_uri
+    if default_artifact_root:
+        env_map[ARTIFACT_ROOT_ENV_VAR] = default_artifact_root
+    if serve_artifacts:
+        env_map[SERVE_ARTIFACTS_ENV_VAR] = "true"
+    if artifacts_only:
+        env_map[ARTIFACTS_ONLY_ENV_VAR] = "true"
+    if artifacts_destination:
+        env_map[ARTIFACTS_DESTINATION_ENV_VAR] = artifacts_destination
+    if static_prefix:
+        env_map[STATIC_PREFIX_ENV_VAR] = static_prefix
+
+    if expose_prometheus:
+        env_map[PROMETHEUS_EXPORTER_ENV_VAR] = expose_prometheus
+
+    secret_key = MLFLOW_FLASK_SERVER_SECRET_KEY.get()
+    if secret_key:
+        env_map[MLFLOW_FLASK_SERVER_SECRET_KEY.name] = secret_key
+
+    if app_name is None:
+        app = f"{__name__}:app"
+        is_factory = False
+    else:
+        app = _find_app(app_name)
+        is_factory = _is_factory(app)
+        # `waitress` doesn't support `()` syntax for factory functions.
+        # Instead, we need to use the `--call` flag.
+        app = f"{app}()" if (not is_windows() and is_factory) else app
+
+    # TODO: eventually may want waitress on non-win32
+    if sys.platform == "win32":
+        full_command = _build_waitress_command(waitress_opts, host, port, app, is_factory)
+    else:
+        full_command = _build_gunicorn_command(gunicorn_opts, host, port, workers or 4, app)
+    _exec_cmd(full_command, extra_env=env_map, capture_output=False)