mlflow-tracing 3.0.0__tar.gz

mlflow_tracing-3.0.0/PKG-INFO

@@ -0,0 +1,121 @@
+Metadata-Version: 2.4
+Name: mlflow-tracing
+Version: 3.0.0
+Summary: MLflow Tracing SDK is an open-source, lightweight Python package that only includes the minimum set of dependencies and functionality to instrument your code/models/agents with MLflow Tracing.
+Maintainer-email: Databricks <mlflow-oss-maintainers@googlegroups.com>
+Project-URL: homepage, https://mlflow.org
+Project-URL: issues, https://github.com/mlflow/mlflow/issues
+Project-URL: documentation, https://mlflow.org/docs/latest/index.html
+Project-URL: repository, https://github.com/mlflow/mlflow
+Keywords: mlflow,ai,databricks,observability,monitoring
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Information Technology
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.9
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: cachetools<7,>=5.0.0
+Requires-Dist: databricks-sdk<1,>=0.20.0
+Requires-Dist: opentelemetry-api<3,>=1.9.0
+Requires-Dist: opentelemetry-sdk<3,>=1.9.0
+Requires-Dist: packaging<26
+Requires-Dist: protobuf<7,>=3.12.0
+Requires-Dist: pydantic<3,>=1.10.8
+
+# MLflow Tracing: An Open-Source SDK for Observability and Monitoring GenAI Applications🔍
+
+[![Latest Docs](https://img.shields.io/badge/docs-latest-success.svg?style=for-the-badge)](https://mlflow.org/docs/latest/index.html)
+[![Apache 2 License](https://img.shields.io/badge/license-Apache%202-brightgreen.svg?style=for-the-badge&logo=apache)](https://github.com/mlflow/mlflow/blob/master/LICENSE.txt)
+[![Slack](https://img.shields.io/badge/slack-@mlflow--users-CF0E5B.svg?logo=slack&logoColor=white&labelColor=3F0E40&style=for-the-badge)](https://mlflow.org/community/#slack)
+[![Twitter](https://img.shields.io/twitter/follow/MLflow?style=for-the-badge&labelColor=00ACEE&logo=twitter&logoColor=white)](https://twitter.com/MLflow)
+
+MLflow Tracing (`mlflow-tracing`) is an open-source, lightweight Python package that only includes the minimum set of dependencies and functionality
+to instrument your code/models/agents with [MLflow Tracing Feature](https://mlflow.org/docs/latest/tracing). It is designed to be a perfect fit for production environments where you want:
+
+- **⚡️ Faster Deployment**: The package size and dependencies are significantly smaller than the full MLflow package, allowing for faster deployment times in dynamic environments such as Docker containers, serverless functions, and cloud-based applications.
+- **🔧 Simplified Dependency Management**: A smaller set of dependencies means less work keeping up with dependency updates, security patches, and breaking changes from upstream libraries.
+- **📦 Portability**: With the less number of dependencies, MLflow Tracing can be easily deployed across different environments and platforms, without worrying about compatibility issues.
+- **🔒 Fewer Security Risks**: Each dependency potentially introduces security vulnerabilities. By reducing the number of dependencies, MLflow Tracing minimizes the attack surface and reduces the risk of security breaches.
+
+## ✨ Features
+
+- [Automatic Tracing](https://mlflow.org/docs/latest/tracing/integrations/) for AI libraries (OpenAI, LangChain, DSPy, Anthropic, etc...). Follow the link for the full list of supported libraries.
+- [Manual instrumentation APIs](https://mlflow.org/docs/latest/tracing/api/manual-instrumentation) such as `@trace` decorator.
+- [Production Monitoring](https://mlflow.org/docs/latest/tracing/production)
+- Other tracing APIs such as `mlflow.set_trace_tag`, `mlflow.search_traces`, etc.
+
+## 🌐 Choose Backend
+
+The MLflow Trace package is designed to work with a remote hosted MLflow server as a backend. This allows you to log your traces to a central location, making it easier to manage and analyze your traces. There are several different options for hosting your MLflow server, including:
+
+- [Databricks](https://docs.databricks.com/machine-learning/mlflow/managed-mlflow.html) - Databricks offers a FREE, fully managed MLflow server as a part of their platform. This is the easiest way to get started with MLflow tracing, without having to set up any infrastructure.
+- [Amazon SageMaker](https://aws.amazon.com/sagemaker-ai/experiments/) - MLflow on Amazon SageMaker is a fully managed service offered as part of the SageMaker platform by AWS, including tracing and other MLflow features such as model registry.
+- [Nebius](https://nebius.com/) - Nebius, a cutting-edge cloud platform for GenAI explorers, offers a fully managed MLflow server.
+- [Self-hosting](https://mlflow.org/docs/latest/tracking/#tracking_setup) - MLflow is a fully open-source project, allowing you to self-host your own MLflow server and keep your data private. This is a great option if you want to have full control over your data and infrastructure.
+
+## 🚀 Getting Started
+
+### Installation
+
+To install the MLflow Python package, run the following command:
+
+```bash
+pip install mlflow-tracing
+```
+
+To install from the source code, run the following command:
+
+```bash
+pip install git+https://github.com/mlflow/mlflow.git#subdirectory=packages/tracing
+```
+
+> **NOTE:** It is **not** recommended to co-install this package with the full MLflow package together, as it may cause version mismatches issues.
+
+### Connect to the MLflow Server
+
+To connect to your MLflow server to log your traces, set the `MLFLOW_TRACKING_URI` environment variable or use the `mlflow.set_tracking_uri` function:
+
+```python
+import mlflow
+
+mlflow.set_tracking_uri("databricks")
+# Specify the experiment to log the traces to
+mlflow.set_experiment("/Path/To/Experiment")
+```
+
+### Start Logging Traces
+
+```python
+import openai
+
+client = openai.OpenAI(api_key="<your-api-key>")
+
+# Enable auto-tracing for OpenAI
+mlflow.openai.autolog()
+
+# Call the OpenAI API as usual
+response = client.chat.completions.create(
+    model="gpt-4.1-mini",
+    messages=[{"role": "user", "content": "Hello, how are you?"}],
+)
+```
+
+## 📘 Documentation
+
+Official documentation for MLflow Tracing can be found at [here](https://mlflow.org/docs/latest/tracing).
+
+## 🛑 Features _Not_ Included
+
+The following MLflow features are not included in this package.
+
+- MLflow tracking server and UI.
+- MLflow's other tracking capabilities such as Runs, Model Registry, Projects, etc.
+- Evaluate models/agents and log evaluation results.
+
+To leverage the full feature set of MLflow, install the full package by running `pip install mlflow`.

mlflow_tracing-3.0.0/README.md

@@ -0,0 +1,91 @@
+# MLflow Tracing: An Open-Source SDK for Observability and Monitoring GenAI Applications🔍
+
+[![Latest Docs](https://img.shields.io/badge/docs-latest-success.svg?style=for-the-badge)](https://mlflow.org/docs/latest/index.html)
+[![Apache 2 License](https://img.shields.io/badge/license-Apache%202-brightgreen.svg?style=for-the-badge&logo=apache)](https://github.com/mlflow/mlflow/blob/master/LICENSE.txt)
+[![Slack](https://img.shields.io/badge/slack-@mlflow--users-CF0E5B.svg?logo=slack&logoColor=white&labelColor=3F0E40&style=for-the-badge)](https://mlflow.org/community/#slack)
+[![Twitter](https://img.shields.io/twitter/follow/MLflow?style=for-the-badge&labelColor=00ACEE&logo=twitter&logoColor=white)](https://twitter.com/MLflow)
+
+MLflow Tracing (`mlflow-tracing`) is an open-source, lightweight Python package that only includes the minimum set of dependencies and functionality
+to instrument your code/models/agents with [MLflow Tracing Feature](https://mlflow.org/docs/latest/tracing). It is designed to be a perfect fit for production environments where you want:
+
+- **⚡️ Faster Deployment**: The package size and dependencies are significantly smaller than the full MLflow package, allowing for faster deployment times in dynamic environments such as Docker containers, serverless functions, and cloud-based applications.
+- **🔧 Simplified Dependency Management**: A smaller set of dependencies means less work keeping up with dependency updates, security patches, and breaking changes from upstream libraries.
+- **📦 Portability**: With the less number of dependencies, MLflow Tracing can be easily deployed across different environments and platforms, without worrying about compatibility issues.
+- **🔒 Fewer Security Risks**: Each dependency potentially introduces security vulnerabilities. By reducing the number of dependencies, MLflow Tracing minimizes the attack surface and reduces the risk of security breaches.
+
+## ✨ Features
+
+- [Automatic Tracing](https://mlflow.org/docs/latest/tracing/integrations/) for AI libraries (OpenAI, LangChain, DSPy, Anthropic, etc...). Follow the link for the full list of supported libraries.
+- [Manual instrumentation APIs](https://mlflow.org/docs/latest/tracing/api/manual-instrumentation) such as `@trace` decorator.
+- [Production Monitoring](https://mlflow.org/docs/latest/tracing/production)
+- Other tracing APIs such as `mlflow.set_trace_tag`, `mlflow.search_traces`, etc.
+
+## 🌐 Choose Backend
+
+The MLflow Trace package is designed to work with a remote hosted MLflow server as a backend. This allows you to log your traces to a central location, making it easier to manage and analyze your traces. There are several different options for hosting your MLflow server, including:
+
+- [Databricks](https://docs.databricks.com/machine-learning/mlflow/managed-mlflow.html) - Databricks offers a FREE, fully managed MLflow server as a part of their platform. This is the easiest way to get started with MLflow tracing, without having to set up any infrastructure.
+- [Amazon SageMaker](https://aws.amazon.com/sagemaker-ai/experiments/) - MLflow on Amazon SageMaker is a fully managed service offered as part of the SageMaker platform by AWS, including tracing and other MLflow features such as model registry.
+- [Nebius](https://nebius.com/) - Nebius, a cutting-edge cloud platform for GenAI explorers, offers a fully managed MLflow server.
+- [Self-hosting](https://mlflow.org/docs/latest/tracking/#tracking_setup) - MLflow is a fully open-source project, allowing you to self-host your own MLflow server and keep your data private. This is a great option if you want to have full control over your data and infrastructure.
+
+## 🚀 Getting Started
+
+### Installation
+
+To install the MLflow Python package, run the following command:
+
+```bash
+pip install mlflow-tracing
+```
+
+To install from the source code, run the following command:
+
+```bash
+pip install git+https://github.com/mlflow/mlflow.git#subdirectory=packages/tracing
+```
+
+> **NOTE:** It is **not** recommended to co-install this package with the full MLflow package together, as it may cause version mismatches issues.
+
+### Connect to the MLflow Server
+
+To connect to your MLflow server to log your traces, set the `MLFLOW_TRACKING_URI` environment variable or use the `mlflow.set_tracking_uri` function:
+
+```python
+import mlflow
+
+mlflow.set_tracking_uri("databricks")
+# Specify the experiment to log the traces to
+mlflow.set_experiment("/Path/To/Experiment")
+```
+
+### Start Logging Traces
+
+```python
+import openai
+
+client = openai.OpenAI(api_key="<your-api-key>")
+
+# Enable auto-tracing for OpenAI
+mlflow.openai.autolog()
+
+# Call the OpenAI API as usual
+response = client.chat.completions.create(
+    model="gpt-4.1-mini",
+    messages=[{"role": "user", "content": "Hello, how are you?"}],
+)
+```
+
+## 📘 Documentation
+
+Official documentation for MLflow Tracing can be found at [here](https://mlflow.org/docs/latest/tracing).
+
+## 🛑 Features _Not_ Included
+
+The following MLflow features are not included in this package.
+
+- MLflow tracking server and UI.
+- MLflow's other tracking capabilities such as Runs, Model Registry, Projects, etc.
+- Evaluate models/agents and log evaluation results.
+
+To leverage the full feature set of MLflow, install the full package by running `pip install mlflow`.

mlflow_tracing-3.0.0/mlflow/__init__.py

@@ -0,0 +1,408 @@
+"""
+The ``mlflow`` module provides a high-level "fluent" API for starting and managing MLflow runs.
+For example:
+
+.. code:: python
+
+    import mlflow
+
+    mlflow.start_run()
+    mlflow.log_param("my", "param")
+    mlflow.log_metric("score", 100)
+    mlflow.end_run()
+
+You can also use the context manager syntax like this:
+
+.. code:: python
+
+    with mlflow.start_run() as run:
+        mlflow.log_param("my", "param")
+        mlflow.log_metric("score", 100)
+
+which automatically terminates the run at the end of the ``with`` block.
+
+The fluent tracking API is not currently threadsafe. Any concurrent callers to the tracking API must
+implement mutual exclusion manually.
+
+For a lower level API, see the :py:mod:`mlflow.client` module.
+"""
+
+import contextlib
+from typing import TYPE_CHECKING
+
+from mlflow.version import IS_TRACING_SDK_ONLY, VERSION
+
+__version__ = VERSION
+
+import mlflow.mismatch
+
+# `check_version_mismatch` must be called here before importing any other modules
+with contextlib.suppress(Exception):
+    mlflow.mismatch._check_version_mismatch()
+
+if not IS_TRACING_SDK_ONLY:
+    from mlflow import (
+        artifacts,  # noqa: F401
+        client,  # noqa: F401
+        config,  # noqa: F401
+        data,  # noqa: F401
+        exceptions,  # noqa: F401
+        genai,  # noqa: F401
+        models,  # noqa: F401
+        projects,  # noqa: F401
+        tracking,  # noqa: F401
+    )
+
+from mlflow import tracing  # noqa: F401
+from mlflow.environment_variables import MLFLOW_CONFIGURE_LOGGING
+from mlflow.exceptions import MlflowException
+from mlflow.utils.lazy_load import LazyLoader
+from mlflow.utils.logging_utils import _configure_mlflow_loggers
+
+# Lazily load mlflow flavors to avoid excessive dependencies.
+anthropic = LazyLoader("mlflow.anthropic", globals(), "mlflow.anthropic")
+ag2 = LazyLoader("mlflow.ag2", globals(), "mlflow.ag2")
+autogen = LazyLoader("mlflow.autogen", globals(), "mlflow.autogen")
+bedrock = LazyLoader("mlflow.bedrock", globals(), "mlflow.bedrock")
+catboost = LazyLoader("mlflow.catboost", globals(), "mlflow.catboost")
+crewai = LazyLoader("mlflow.crewai", globals(), "mlflow.crewai")
+diviner = LazyLoader("mlflow.diviner", globals(), "mlflow.diviner")
+dspy = LazyLoader("mlflow.dspy", globals(), "mlflow.dspy")
+gemini = LazyLoader("mlflow.gemini", globals(), "mlflow.gemini")
+groq = LazyLoader("mlflow.groq", globals(), "mlflow.groq")
+h2o = LazyLoader("mlflow.h2o", globals(), "mlflow.h2o")
+johnsnowlabs = LazyLoader("mlflow.johnsnowlabs", globals(), "mlflow.johnsnowlabs")
+keras = LazyLoader("mlflow.keras", globals(), "mlflow.keras")
+langchain = LazyLoader("mlflow.langchain", globals(), "mlflow.langchain")
+lightgbm = LazyLoader("mlflow.lightgbm", globals(), "mlflow.lightgbm")
+litellm = LazyLoader("mlflow.litellm", globals(), "mlflow.litellm")
+llama_index = LazyLoader("mlflow.llama_index", globals(), "mlflow.llama_index")
+llm = LazyLoader("mlflow.llm", globals(), "mlflow.llm")
+metrics = LazyLoader("mlflow.metrics", globals(), "mlflow.metrics")
+mistral = LazyLoader("mlflow.mistral", globals(), "mlflow.mistral")
+onnx = LazyLoader("mlflow.onnx", globals(), "mlflow.onnx")
+openai = LazyLoader("mlflow.openai", globals(), "mlflow.openai")
+paddle = LazyLoader("mlflow.paddle", globals(), "mlflow.paddle")
+pmdarima = LazyLoader("mlflow.pmdarima", globals(), "mlflow.pmdarima")
+promptflow = LazyLoader("mlflow.promptflow", globals(), "mlflow.promptflow")
+prophet = LazyLoader("mlflow.prophet", globals(), "mlflow.prophet")
+pydantic_ai = LazyLoader("mlflow.pydantic_ai", globals(), "mlflow.pydantic_ai")
+pyfunc = LazyLoader("mlflow.pyfunc", globals(), "mlflow.pyfunc")
+pyspark = LazyLoader("mlflow.pyspark", globals(), "mlflow.pyspark")
+pytorch = LazyLoader("mlflow.pytorch", globals(), "mlflow.pytorch")
+rfunc = LazyLoader("mlflow.rfunc", globals(), "mlflow.rfunc")
+sentence_transformers = LazyLoader(
+    "mlflow.sentence_transformers",
+    globals(),
+    "mlflow.sentence_transformers",
+)
+shap = LazyLoader("mlflow.shap", globals(), "mlflow.shap")
+sklearn = LazyLoader("mlflow.sklearn", globals(), "mlflow.sklearn")
+smolagents = LazyLoader("mlflow.smolagents", globals(), "mlflow.smolagents")
+spacy = LazyLoader("mlflow.spacy", globals(), "mlflow.spacy")
+spark = LazyLoader("mlflow.spark", globals(), "mlflow.spark")
+statsmodels = LazyLoader("mlflow.statsmodels", globals(), "mlflow.statsmodels")
+tensorflow = LazyLoader("mlflow.tensorflow", globals(), "mlflow.tensorflow")
+# TxtAI integration is defined at https://github.com/neuml/mlflow-txtai
+txtai = LazyLoader("mlflow.txtai", globals(), "mlflow_txtai")
+transformers = LazyLoader("mlflow.transformers", globals(), "mlflow.transformers")
+xgboost = LazyLoader("mlflow.xgboost", globals(), "mlflow.xgboost")
+
+if TYPE_CHECKING:
+    # Do not move this block above the lazy-loaded modules above.
+    # All the lazy-loaded modules above must be imported here for code completion to work in IDEs.
+    from mlflow import (  # noqa: F401
+        ag2,
+        anthropic,
+        autogen,
+        bedrock,
+        catboost,
+        crewai,
+        diviner,
+        dspy,
+        gemini,
+        groq,
+        h2o,
+        johnsnowlabs,
+        keras,
+        langchain,
+        lightgbm,
+        litellm,
+        llama_index,
+        llm,
+        metrics,
+        mistral,
+        onnx,
+        openai,
+        paddle,
+        pmdarima,
+        promptflow,
+        prophet,
+        pydantic_ai,
+        pyfunc,
+        pyspark,
+        pytorch,
+        rfunc,
+        sentence_transformers,
+        shap,
+        sklearn,
+        smolagents,
+        spacy,
+        spark,
+        statsmodels,
+        tensorflow,
+        transformers,
+        xgboost,
+    )
+
+if MLFLOW_CONFIGURE_LOGGING.get() is True:
+    _configure_mlflow_loggers(root_module_name=__name__)
+
+# Core modules required for mlflow-tracing
+from mlflow.tracing.assessment import (
+    delete_assessment,
+    get_assessment,
+    log_assessment,
+    log_expectation,
+    log_feedback,
+    override_feedback,
+    update_assessment,
+)
+from mlflow.tracing.fluent import (
+    add_trace,
+    delete_trace_tag,
+    get_active_trace_id,
+    get_current_active_span,
+    get_last_active_trace_id,
+    get_trace,
+    log_trace,
+    search_traces,
+    set_trace_tag,
+    start_span,
+    start_span_no_context,
+    trace,
+    update_current_trace,
+)
+from mlflow.tracking import (
+    get_tracking_uri,
+    is_tracking_uri_set,
+    set_tracking_uri,
+)
+from mlflow.tracking.fluent import active_run, flush_trace_async_logging, set_experiment
+
+# These are minimal set of APIs to be exposed via `mlflow-tracing` package.
+# APIs listed here must not depend on dependencies that are not part of `mlflow-tracing` package.
+__all__ = [
+    "MlflowException",
+    # Minimal tracking APIs required for tracing core functionality
+    "set_experiment",
+    "set_tracking_uri",
+    "get_tracking_uri",
+    "is_tracking_uri_set",
+    # NB: Tracing SDK doesn't support using Runs, however, active_run is used heavily within
+    # the autologging code base.
+    "active_run",
+    # Tracing APIs
+    "add_trace",
+    "delete_trace_tag",
+    "flush_trace_async_logging",
+    "get_active_trace_id",
+    "get_current_active_span",
+    "get_last_active_trace_id",
+    "get_trace",
+    "log_trace",
+    "search_traces",
+    "set_trace_tag",
+    "start_span",
+    "start_span_no_context",
+    "trace",
+    "update_current_trace",
+    # Assessment APIs
+    "get_assessment",
+    "delete_assessment",
+    "log_assessment",
+    "update_assessment",
+    "log_expectation",
+    "log_feedback",
+    "override_feedback",
+]
+
+# Only import these modules when mlflow or mlflow-skinny is installed i.e. not importing them
+# when only mlflow-tracing is installed.
+if not IS_TRACING_SDK_ONLY:
+    from mlflow.client import MlflowClient
+
+    # For backward compatibility, we expose the following functions and classes at the top level in
+    # addition to `mlflow.config`.
+    from mlflow.config import (
+        disable_system_metrics_logging,
+        enable_system_metrics_logging,
+        get_registry_uri,
+        set_registry_uri,
+        set_system_metrics_node_id,
+        set_system_metrics_samples_before_logging,
+        set_system_metrics_sampling_interval,
+    )
+    from mlflow.models.evaluation.deprecated import evaluate
+    from mlflow.models.evaluation.validation import validate_evaluation_results
+    from mlflow.projects import run
+    from mlflow.tracking._model_registry.fluent import (
+        # TODO: Prompt Registry APIs are moved to the `mlflow.genai` namespace and direct
+        # imports from mlflow will be deprecated in the future.
+        delete_prompt_alias,
+        load_prompt,
+        register_model,
+        register_prompt,
+        search_model_versions,
+        search_prompts,
+        search_registered_models,
+        set_model_version_tag,
+        set_prompt_alias,
+    )
+    from mlflow.tracking.fluent import (
+        ActiveModel,
+        ActiveRun,
+        autolog,
+        clear_active_model,
+        create_experiment,
+        create_external_model,
+        delete_experiment,
+        delete_logged_model_tag,
+        delete_run,
+        delete_tag,
+        end_run,
+        finalize_logged_model,
+        flush_artifact_async_logging,
+        flush_async_logging,
+        get_active_model_id,
+        get_artifact_uri,
+        get_experiment,
+        get_experiment_by_name,
+        get_logged_model,
+        get_parent_run,
+        get_run,
+        initialize_logged_model,
+        last_active_run,
+        last_logged_model,
+        load_table,
+        log_artifact,
+        log_artifacts,
+        log_dict,
+        log_figure,
+        log_image,
+        log_input,
+        log_inputs,
+        log_metric,
+        log_metrics,
+        log_model_params,
+        log_outputs,
+        log_param,
+        log_params,
+        log_table,
+        log_text,
+        search_experiments,
+        search_logged_models,
+        search_runs,
+        set_active_model,
+        set_experiment_tag,
+        set_experiment_tags,
+        set_logged_model_tags,
+        set_tag,
+        set_tags,
+        start_run,
+    )
+    from mlflow.tracking.multimedia import Image
+    from mlflow.utils.async_logging.run_operations import RunOperations  # noqa: F401
+    from mlflow.utils.credentials import login
+    from mlflow.utils.doctor import doctor
+
+    __all__ += [
+        "ActiveRun",
+        "ActiveModel",
+        "MlflowClient",
+        "MlflowException",
+        "autolog",
+        "clear_active_model",
+        "create_experiment",
+        "create_external_model",
+        "delete_experiment",
+        "delete_run",
+        "delete_tag",
+        "disable_system_metrics_logging",
+        "doctor",
+        "enable_system_metrics_logging",
+        "end_run",
+        "evaluate",
+        "finalize_logged_model",
+        "flush_async_logging",
+        "flush_artifact_async_logging",
+        "get_active_model_id",
+        "get_artifact_uri",
+        "get_experiment",
+        "get_experiment_by_name",
+        "get_logged_model",
+        "get_parent_run",
+        "get_registry_uri",
+        "get_run",
+        "initialize_logged_model",
+        "last_active_run",
+        "last_logged_model",
+        "load_table",
+        "log_artifact",
+        "log_artifacts",
+        "log_dict",
+        "log_figure",
+        "log_image",
+        "log_input",
+        "log_inputs",
+        "log_model_params",
+        "log_outputs",
+        "log_metric",
+        "log_metrics",
+        "log_param",
+        "log_params",
+        "log_table",
+        "log_text",
+        "login",
+        "pyfunc",
+        "register_model",
+        "run",
+        "search_experiments",
+        "search_logged_models",
+        "search_model_versions",
+        "search_registered_models",
+        "search_runs",
+        "search_prompts",
+        "set_active_model",
+        "set_experiment_tag",
+        "set_experiment_tags",
+        "set_model_version_tag",
+        "set_registry_uri",
+        "set_system_metrics_node_id",
+        "set_system_metrics_samples_before_logging",
+        "set_system_metrics_sampling_interval",
+        "set_tag",
+        "set_tags",
+        "start_run",
+        "validate_evaluation_results",
+        "Image",
+        # Prompt Registry APIs
+        # TODO: Prompt Registry APIs are moved to the `mlflow.genai` namespace and direct
+        # imports from mlflow will be deprecated in the future.
+        "load_prompt",
+        "register_prompt",
+        "search_prompts",
+        "set_prompt_alias",
+        "delete_prompt_alias",
+        "set_logged_model_tags",
+        "delete_logged_model_tag",
+    ]
+
+
+# `mlflow.gateway` depends on optional dependencies such as pydantic, psutil, and has version
+# restrictions for dependencies. Importing this module fails if they are not installed or
+# if invalid versions of these required packages are installed.
+with contextlib.suppress(Exception):
+    from mlflow import gateway  # noqa: F401
+
+    __all__.append("gateway")

mlflow_tracing-3.0.0/mlflow/__main__.py

@@ -0,0 +1,3 @@
+from mlflow.cli import cli
+
+cli.main()

mlflow_tracing-3.0.0/mlflow/anthropic/__init__.py

@@ -0,0 +1,40 @@
+from mlflow.anthropic.autolog import async_patched_class_call, patched_class_call
+from mlflow.utils.annotations import experimental
+from mlflow.utils.autologging_utils import autologging_integration, safe_patch
+
+FLAVOR_NAME = "anthropic"
+
+
+@experimental
+@autologging_integration(FLAVOR_NAME)
+def autolog(
+    log_traces: bool = True,
+    disable: bool = False,
+    silent: bool = False,
+):
+    """
+    Enables (or disables) and configures autologging from Anthropic to MLflow.
+    Only synchronous calls and asynchnorous APIs are supported. Streaming is not recorded.
+
+    Args:
+        log_traces: If ``True``, traces are logged for Anthropic models.
+            If ``False``, no traces are collected during inference. Default to ``True``.
+        disable: If ``True``, disables the Anthropic autologging. Default to ``False``.
+        silent: If ``True``, suppress all event logs and warnings from MLflow during Anthropic
+            autologging. If ``False``, show all events and warnings.
+    """
+    from anthropic.resources import AsyncMessages, Messages
+
+    safe_patch(
+        FLAVOR_NAME,
+        Messages,
+        "create",
+        patched_class_call,
+    )
+
+    safe_patch(
+        FLAVOR_NAME,
+        AsyncMessages,
+        "create",
+        async_patched_class_call,
+    )