genesis-flow 1.0.1__py3-none-any.whl → 1.0.3__py3-none-any.whl

mlflow/genai/datasets/evaluation_dataset.py

@@ -1,11 +1,14 @@
 from typing import TYPE_CHECKING, Any, Optional, Union
 
 from mlflow.data import Dataset
+from mlflow.data.dataset_source import DatasetSource
 from mlflow.data.digest_utils import compute_pandas_digest
 from mlflow.data.evaluation_dataset import EvaluationDataset as LegacyEvaluationDataset
 from mlflow.data.pyfunc_dataset_mixin import PyFuncConvertibleDatasetMixin
-from mlflow.data.spark_dataset_source import SparkDatasetSource
 from mlflow.entities import Dataset as DatasetEntity
+from mlflow.genai.datasets.databricks_evaluation_dataset_source import (
+    DatabricksEvaluationDatasetSource,
+)
 
 if TYPE_CHECKING:
     import pandas as pd
@@ -56,11 +59,11 @@ class EvaluationDataset(Dataset, PyFuncConvertibleDatasetMixin):
         return self._dataset.profile
 
     @property
-    def source(self) -> Optional[str]:
+    def source(self) -> DatasetSource:
         """Source information for the dataset."""
-        # NB: The managed Dataset entity in Agent SDK doesn't propagate the source
-        # information. So we use the table name as the fallback source.
-        return self._dataset.source or SparkDatasetSource(table_name=self.name)
+        if isinstance(self._dataset.source, DatasetSource):
+            return self._dataset.source
+        return DatabricksEvaluationDatasetSource(table_name=self.name, dataset_id=self.dataset_id)
 
     @property
     def source_type(self) -> Optional[str]:

mlflow/genai/scorers/base.py

@@ -35,7 +35,7 @@ class SerializedScorer:
 
     # Builtin scorer fields (for scorers from mlflow.genai.scorers.builtin_scorers)
     builtin_scorer_class: Optional[str] = None
-    builtin_scorer_pydantic_data: Optional[dict[str, Any]] = None
+    builtin_scorer_pydantic_data: Optional[dict] = None
 
     # Decorator scorer fields (for @scorer decorated functions)
     call_source: Optional[str] = None
@@ -43,14 +43,21 @@ class SerializedScorer:
     original_func_name: Optional[str] = None
 
 
-@experimental(version="3.0.0")
+@experimental
 class Scorer(BaseModel):
     name: str
-    aggregations: Optional[list[str]] = None
+    aggregations: Optional[list] = None
+
+    _cached_dump: Optional[dict[str, Any]] = PrivateAttr(default=None)
 
-    def model_dump(self, **kwargs) -> dict[str, Any]:
+    def model_dump(self, **kwargs) -> dict:
         """Override model_dump to include source code."""
         # Create serialized scorer with core fields
+
+        # Return cached dump if available (prevents re-serialization issues with dynamic functions)
+        if self._cached_dump is not None:
+            return self._cached_dump
+
         serialized = SerializedScorer(
             name=self.name,
             aggregations=self.aggregations,
@@ -79,7 +86,7 @@ class Scorer(BaseModel):
 
         return asdict(serialized)
 
-    def _extract_source_code_info(self) -> dict[str, Optional[str]]:
+    def _extract_source_code_info(self) -> dict:
         """Extract source code information for the original decorated function."""
         from mlflow.genai.scorers.scorer_utils import extract_function_body
 
@@ -165,7 +172,13 @@ class Scorer(BaseModel):
         # Rather than serializing and deserializing the `run` method of `Scorer`, we recreate the
         # Scorer using the original function and the `@scorer` decorator. This should be safe so
         # long as `@scorer` is a stable API.
-        return scorer(recreated_func, name=serialized.name, aggregations=serialized.aggregations)
+        scorer_instance = scorer(
+            recreated_func, name=serialized.name, aggregations=serialized.aggregations
+        )
+        # Cache the serialized data to prevent re-serialization issues with dynamic functions
+        original_serialized_data = asdict(serialized)
+        object.__setattr__(scorer_instance, "_cached_dump", original_serialized_data)
+        return scorer_instance
 
     def run(self, *, inputs=None, outputs=None, expectations=None, trace=None):
         from mlflow.evaluation import Assessment as LegacyAssessment
@@ -317,18 +330,13 @@ class Scorer(BaseModel):
         raise NotImplementedError("Implementation of __call__ is required for Scorer class")
 
 
-@experimental(version="3.0.0")
+@experimental
 def scorer(
     func=None,
     *,
     name: Optional[str] = None,
     aggregations: Optional[
-        list[
-            Union[
-                Literal["min", "max", "mean", "median", "variance", "p90", "p99"],
-                Callable[[list[Union[int, float]]], Union[int, float]],
-            ]
-        ]
+        list[Union[Literal["min", "max", "mean", "median", "variance", "p90", "p99"], Callable]]
     ] = None,
 ):
     """
@@ -464,7 +472,7 @@ def scorer(
 
     class CustomScorer(Scorer):
         # Store reference to the original function
-        _original_func: Optional[Callable[..., Any]] = PrivateAttr(default=None)
+        _original_func: Optional[Callable] = PrivateAttr(default=None)
 
         def __init__(self, **data):
             super().__init__(**data)

mlflow/langchain/utils/chat.py

@@ -283,6 +283,16 @@ def _get_lc_model_input_fields(lc_model) -> set[str]:
 
 
 def _should_transform_request_json_for_chat(lc_model):
+    # Don't convert the request to LangChain's Message format for LangGraph models.
+    # Inputs may have key like "messages", but they are graph state fields, not OAI chat format.
+    try:
+        from langgraph.graph.state import CompiledStateGraph
+
+        if isinstance(lc_model, CompiledStateGraph):
+            return False
+    except ImportError:
+        pass
+
     # Avoid converting the request to LangChain's Message format if the chain
     # is an AgentExecutor, as LangChainChatMessage might not be accepted by the chain
     from langchain.agents import AgentExecutor

mlflow/models/container/__init__.py

@@ -91,8 +91,8 @@ def _install_pyfunc_deps(
     server_deps = ["gunicorn[gevent]"]
     if enable_mlserver:
         server_deps = [
-            "'mlserver>=1.2.0,!=1.3.1,<1.4.0'",
-            "'mlserver-mlflow>=1.2.0,!=1.3.1,<1.4.0'",
+            "'mlserver>=1.2.0,!=1.3.1,<2.0.0'",
+            "'mlserver-mlflow>=1.2.0,!=1.3.1,<2.0.0'",
         ]
 
     install_server_deps = [f"pip install {' '.join(server_deps)}"]