maxframe 2.2.0__cp310-cp310-macosx_10_9_universal2.whl → 2.3.0rc1__cp310-cp310-macosx_10_9_universal2.whl

maxframe/learn/contrib/llm/tests/test_openai.py

@@ -0,0 +1,187 @@
+# Copyright 1999-2025 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import numpy as np
+
+import maxframe.dataframe as md
+
+from ..models.openai import (
+    OpenAICompatibleLLM,
+    OpenAICompatibleTextGenOp,
+    OpenAICompatibleTextLLM,
+)
+
+
+def test_openai_compatible_llm_field_assignment():
+    """Test OpenAICompatibleLLM field assignment."""
+    llm = OpenAICompatibleLLM()
+    llm.base_url = "https://api.openai.com/v1"
+    llm.api_key = "test-key"
+    llm.batch_size = 10
+    llm.batch_timeout = 300
+
+    assert llm.base_url == "https://api.openai.com/v1"
+    assert llm.api_key == "test-key"
+    assert llm.batch_size == 10
+    assert llm.batch_timeout == 300
+
+
+def test_openai_compatible_text_llm_initialization():
+    """Test OpenAICompatibleTextLLM initialization."""
+    model = OpenAICompatibleTextLLM(
+        name="gpt-3.5-turbo", base_url="https://api.openai.com/v1", api_key="test-key"
+    )
+
+    assert model.name == "gpt-3.5-turbo"
+    assert model.base_url == "https://api.openai.com/v1"
+    assert model.api_key == "test-key"
+    # Test inherited default values
+    assert model.batch_size is None
+    assert model.batch_timeout is None
+
+
+def test_openai_compatible_text_llm_generate_method():
+    """Test OpenAICompatibleTextLLM generate method."""
+    model = OpenAICompatibleTextLLM(
+        name="gpt-3.5-turbo", base_url="https://api.openai.com/v1", api_key="test-key"
+    )
+
+    # Create test data
+    df = md.DataFrame({"query": ["Hello world"]})
+    prompt_template = [{"role": "user", "content": "{query}"}]
+    params = {"temperature": 0.7}
+
+    # Test that generate method returns a DataFrame (result of operator execution)
+    result = model.generate(
+        data=df,
+        prompt_template=prompt_template,
+        simple_output=True,
+        params=params,
+        extra_param="test",
+    )
+
+    # Verify result is a DataFrame
+    assert hasattr(result, "index_value")
+    assert hasattr(result, "dtypes")
+
+    # Verify the operator that was created has the correct parameters
+    # We can access the operator through the result's op attribute
+    op = result.op
+    assert isinstance(op, OpenAICompatibleTextGenOp)
+    assert op.model == model
+    assert op.prompt_template == prompt_template
+    assert op.simple_output is True
+    assert op.params == params
+
+
+def test_openai_compatible_text_llm_generate_with_defaults():
+    """Test OpenAICompatibleTextLLM generate method with default parameters."""
+    model = OpenAICompatibleTextLLM(
+        name="gpt-3.5-turbo", base_url="https://api.openai.com/v1", api_key="test-key"
+    )
+
+    df = md.DataFrame({"query": ["Hello world"]})
+    prompt_template = [{"role": "user", "content": "{query}"}]
+
+    # Test that generate method returns a DataFrame (result of operator execution)
+    result = model.generate(data=df, prompt_template=prompt_template)
+
+    # Verify result is a DataFrame
+    assert hasattr(result, "index_value")
+    assert hasattr(result, "dtypes")
+
+    # Verify the operator that was created has the correct parameters
+    # We can access the operator through the result's op attribute
+    op = result.op
+    assert isinstance(op, OpenAICompatibleTextGenOp)
+    assert op.model == model
+    assert op.prompt_template == prompt_template
+    assert op.simple_output is False
+    assert op.params is None
+
+
+def test_openai_compatible_text_generation_operator_default_values():
+    """Test OpenAICompatibleTextGenOperator default field values."""
+    op = OpenAICompatibleTextGenOp()
+    assert op.simple_output is False
+
+
+def test_openai_compatible_text_generation_operator_field_assignment():
+    """Test OpenAICompatibleTextGenOperator field assignment."""
+    op = OpenAICompatibleTextGenOp()
+    op.simple_output = True
+    assert op.simple_output is True
+
+
+def test_openai_compatible_text_generation_operator_output_dtypes():
+    """Test OpenAICompatibleTextGenOperator inherits correct output dtypes."""
+    op = OpenAICompatibleTextGenOp()
+    dtypes = op.get_output_dtypes()
+    assert dtypes["response"] == np.dtype("O")
+    assert dtypes["success"] == np.dtype("bool")
+
+
+def test_openai_compatible_text_generation_operator_with_model():
+    """Test OpenAICompatibleTextGenOperator with model parameter."""
+    model = OpenAICompatibleTextLLM(
+        name="gpt-3.5-turbo", base_url="https://api.openai.com/v1", api_key="test-key"
+    )
+
+    prompt_template = [{"role": "user", "content": "Hello"}]
+    params = {"temperature": 0.5}
+
+    op = OpenAICompatibleTextGenOp(
+        model=model, prompt_template=prompt_template, simple_output=True, params=params
+    )
+
+    assert op.model == model
+    assert op.prompt_template == prompt_template
+    assert op.simple_output is True
+    assert op.params == params
+
+
+def test_openai_compatible_text_llm_inheritance():
+    """Test that OpenAICompatibleTextLLM properly inherits from both parent classes."""
+    model = OpenAICompatibleTextLLM(
+        name="gpt-3.5-turbo", base_url="https://api.openai.com/v1", api_key="test-key"
+    )
+
+    # Test TextGenLLM inheritance - should have validate_params method
+    assert hasattr(model, "validate_params")
+    assert callable(getattr(model, "validate_params"))
+
+    # Test OpenAICompatibleLLM inheritance - should have OpenAI-specific fields
+    assert hasattr(model, "base_url")
+    assert hasattr(model, "api_key")
+    assert hasattr(model, "batch_size")
+    assert hasattr(model, "batch_timeout")
+
+    # Test that validate_params doesn't raise error with empty params
+    model.validate_params({})
+
+
+def test_openai_compatible_text_llm_validate_params():
+    """Test OpenAICompatibleTextLLM validate_params method."""
+    model = OpenAICompatibleTextLLM(
+        name="gpt-3.5-turbo", base_url="https://api.openai.com/v1", api_key="test-key"
+    )
+
+    # Should not raise exception with valid params
+    model.validate_params({"temperature": 0.7, "max_tokens": 100})
+
+    # Should not raise exception with empty params
+    model.validate_params({})
+
+    # Should not raise exception with None params
+    model.validate_params(None)

maxframe/learn/contrib/llm/tests/test_text_gen.py

@@ -0,0 +1,155 @@
+# Copyright 1999-2025 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import mock
+import numpy as np
+import pytest
+
+import maxframe.dataframe as md
+
+from .. import text as llm_text
+
+
+def test_generate_invalid_data_type_raises():
+    model = mock.create_autospec(llm_text.TextGenLLM, instance=True)
+    with pytest.raises(ValueError):
+        llm_text.generate(
+            123, model, prompt_template=[{"role": "user", "content": "x"}]
+        )
+
+
+def test_generate_invalid_model_type_raises():
+    df = md.DataFrame({"query": ["x"]})
+    with pytest.raises(TypeError):
+        llm_text.generate(
+            df, object(), prompt_template=[{"role": "user", "content": "x"}]
+        )
+
+
+def test_generate_calls_validate_params_with_default_and_forwards():
+    df = md.DataFrame({"query": ["hello"]})
+    model = mock.create_autospec(llm_text.TextGenLLM, instance=True)
+    sentinel = object()
+    model.generate.return_value = sentinel
+
+    ret = llm_text.generate(
+        df, model, prompt_template=[{"role": "user", "content": "x"}]
+    )
+
+    assert ret is sentinel
+    model.validate_params.assert_called_once()
+    assert model.validate_params.call_args[0][0] == {}
+    assert model.generate.call_args.kwargs["prompt_template"] == [
+        {"role": "user", "content": "x"}
+    ]
+    assert model.generate.call_args.kwargs["params"] == {}
+
+
+def test_summary_type_and_dtype_validation_and_forward():
+    model = mock.create_autospec(llm_text.TextGenLLM, instance=True)
+
+    with pytest.raises(ValueError):
+        llm_text.summary("not_series", model)
+
+    s_wrong = md.Series(np.array([1], dtype=np.int_))
+    with pytest.raises(ValueError):
+        llm_text.summary(s_wrong, model)
+
+    s_ok = md.Series(np.array(["a"], dtype=np.str_))
+    model.summarize.return_value = "OK_SUM"
+    with mock.patch.object(llm_text.np, "str_", s_ok.dtype, create=True):
+        ret = llm_text.summary(s_ok, model)
+    assert ret == "OK_SUM"
+    model.summarize.assert_called_once()
+
+
+def test_translate_type_and_dtype_validation_and_forward():
+    model = mock.create_autospec(llm_text.TextGenLLM, instance=True)
+
+    with pytest.raises(ValueError):
+        llm_text.translate(
+            "not_series", model, source_language="en", target_language="zh"
+        )
+
+    s_wrong = md.Series(np.array([1], dtype=np.int_))
+    with pytest.raises(ValueError):
+        llm_text.translate(s_wrong, model, source_language="en", target_language="zh")
+
+    s_ok = md.Series(np.array(["hello"], dtype=np.str_))
+    model.translate.return_value = "OK_TRANS"
+    with mock.patch.object(llm_text.np, "str_", s_ok.dtype, create=True):
+        ret = llm_text.translate(
+            s_ok, model, source_language="en", target_language="zh"
+        )
+    assert ret == "OK_TRANS"
+    model.translate.assert_called_once()
+
+
+def test_classify_validation_and_forward():
+    model = mock.create_autospec(llm_text.TextGenLLM, instance=True)
+
+    with pytest.raises(ValueError):
+        llm_text.classify("not_series", model, labels=["A", "B"])
+
+    s_wrong = md.Series(np.array([1], dtype=np.int_))
+    with pytest.raises(ValueError):
+        llm_text.classify(s_wrong, model, labels=["A", "B"])
+
+    s_ok = md.Series(np.array(["text"], dtype=np.str_))
+    with pytest.raises(TypeError):
+        with mock.patch.object(llm_text.np, "str_", s_ok.dtype, create=True):
+            llm_text.classify(s_ok, model, labels="not_list")
+
+    with pytest.raises(ValueError):
+        with mock.patch.object(llm_text.np, "str_", s_ok.dtype, create=True):
+            llm_text.classify(s_ok, model, labels=[])
+
+    model.classify.return_value = "OK_CLS"
+    with mock.patch.object(llm_text.np, "str_", s_ok.dtype, create=True):
+        ret = llm_text.classify(
+            s_ok,
+            model,
+            labels=["A", "B"],
+            description="desc",
+            examples=[{"text": "t", "label": "A", "reason": "r"}],
+        )
+    assert ret == "OK_CLS"
+    model.classify.assert_called_once()
+
+
+def test_extract_validation_and_forward():
+    model = mock.create_autospec(llm_text.TextGenLLM, instance=True)
+
+    with pytest.raises(ValueError):
+        llm_text.extract("not_series", model, schema={"a": "b"})
+
+    s_wrong = md.Series(np.array([1], dtype=np.int_))
+    with pytest.raises(ValueError):
+        llm_text.extract(s_wrong, model, schema={"a": "b"})
+
+    s_ok = md.Series(np.array(["text"], dtype=np.str_))
+    with pytest.raises(ValueError):
+        llm_text.extract(s_ok, model, schema=None)
+
+    with pytest.raises(ValueError):
+        llm_text.extract(s_ok, model, schema={"a": "b"}, examples="not_list")
+
+    with pytest.raises(ValueError):
+        llm_text.extract(s_ok, model, schema={"a": "b"}, examples=[{"not": "tuple"}])
+
+    model.extract.return_value = "OK_EXT"
+    with mock.patch.object(llm_text.np, "str_", s_ok.dtype, create=True):
+        ret = llm_text.extract(s_ok, model, schema={"a": "b"}, examples=[("in", "out")])
+    assert ret == "OK_EXT"
+    model.extract.assert_called_once()