maxframe 2.2.0__cp38-cp38-win32.whl → 2.3.0rc1__cp38-cp38-win32.whl

maxframe/dataframe/tseries/between_time.py

@@ -0,0 +1,122 @@
+# 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
+
+from ... import opcodes
+from ...core import get_output_types
+from ...serialization.serializables import AnyField, Int32Field, StringField
+from ..operators import DataFrameOperator, DataFrameOperatorMixin
+from ..utils import parse_index, validate_axis
+
+
+class DataFrameBetweenTime(DataFrameOperator, DataFrameOperatorMixin):
+    _op_type_ = opcodes.BETWEEN_TIME
+
+    start_time = AnyField("start_time")
+    end_time = AnyField("end_time")
+    inclusive = StringField("inclusive")
+    axis = Int32Field("axis")
+
+    def __call__(self, df_or_series):
+        self._output_types = get_output_types(df_or_series)
+        out_params = df_or_series.params
+
+        new_shape = list(df_or_series.shape)
+        new_shape[self.axis] = np.nan
+        out_params["shape"] = tuple(new_shape)
+
+        idx_key_params = (df_or_series, self.start_time, self.end_time, self.inclusive)
+        if self.axis == 0:
+            out_params["index_value"] = parse_index(
+                df_or_series.index_value.to_pandas()[:0], idx_key_params
+            )
+        else:
+            out_params["columns_value"] = parse_index(
+                df_or_series.columns_value.to_pandas()[:0], idx_key_params
+            )
+
+        return self.new_tileable([df_or_series], **out_params)
+
+
+def between_time(df_or_series, start_time, end_time, inclusive="both", axis=0):
+    """
+    Select values between particular times of the day (e.g., 9:00-9:30 AM).
+
+    By setting ``start_time`` to be later than ``end_time``,
+    you can get the times that are *not* between the two times.
+
+    Parameters
+    ----------
+    start_time : datetime.time or str
+        Initial time as a time filter limit.
+    end_time : datetime.time or str
+        End time as a time filter limit.
+    inclusive : {"both", "neither", "left", "right"}, default "both"
+        Include boundaries; whether to set each bound as closed or open.
+    axis : {0 or 'index', 1 or 'columns'}, default 0
+        Determine range time on index or columns value.
+        For `Series` this parameter is unused and defaults to 0.
+
+    Returns
+    -------
+    Series or DataFrame
+        Data from the original object filtered to the specified dates range.
+
+    Raises
+    ------
+    TypeError
+        If the index is not  a :class:`DatetimeIndex`
+
+    See Also
+    --------
+    at_time : Select values at a particular time of the day.
+    first : Select initial periods of time series based on a date offset.
+    last : Select final periods of time series based on a date offset.
+    DatetimeIndex.indexer_between_time : Get just the index locations for
+        values between particular times of the day.
+
+    Examples
+    --------
+    >>> import maxframe.dataframe as md
+    >>> i = md.date_range('2018-04-09', periods=4, freq='1D20min')
+    >>> ts = md.DataFrame({'A': [1, 2, 3, 4]}, index=i)
+    >>> ts.execute()
+                         A
+    2018-04-09 00:00:00  1
+    2018-04-10 00:20:00  2
+    2018-04-11 00:40:00  3
+    2018-04-12 01:00:00  4
+
+    >>> ts.between_time('0:15', '0:45').execute()
+                         A
+    2018-04-10 00:20:00  2
+    2018-04-11 00:40:00  3
+
+    You get the times that are *not* between two times by setting
+    ``start_time`` later than ``end_time``:
+
+    >>> ts.between_time('0:45', '0:15').execute()
+                         A
+    2018-04-09 00:00:00  1
+    2018-04-12 01:00:00  4
+    """
+    axis = validate_axis(axis, df_or_series)
+    op = DataFrameBetweenTime(
+        start_time=start_time,
+        end_time=end_time,
+        inclusive=inclusive,
+        axis=axis,
+    )
+    return op(df_or_series)

maxframe/dataframe/utils.py

@@ -25,9 +25,9 @@ from typing import TYPE_CHECKING, Any, Callable, List, Optional
 
 import numpy as np
 import pandas as pd
-from pandas.api.types import is_string_dtype
 from pandas.core.dtypes.inference import is_dict_like, is_list_like
 
+from ..config.validators import dtype_backend_validator
 from ..core import ENTITY_TYPE, Entity, ExecutableTuple, OutputType, get_output_types
 from ..lib.dtypes_extension import ExternalBlobDtype, SolidBlob
 from ..lib.mmh3 import hash as mmh_hash
@@ -36,7 +36,6 @@ from ..utils import (
     ModulePlaceholder,
     is_full_slice,
     lazy_import,
-    make_dtype,
     make_dtypes,
     quiet_stdio,
     sbytes,
@@ -105,9 +104,9 @@ def hash_dtypes(dtypes, size):
     return [dtypes[index] for index in hashed_indexes]
 
 
-def sort_dataframe_inplace(df, *axis):
+def sort_dataframe_inplace(df, *axis, **kw):
     for ax in axis:
-        df.sort_index(axis=ax, inplace=True)
+        df.sort_index(axis=ax, inplace=True, **kw)
     return df
 
 
@@ -1024,27 +1023,21 @@ def create_sa_connection(con, **kwargs):
             engine.dispose()
 
 
-def to_arrow_dtypes(dtypes, test_df=None):
-    from .arrays import ArrowStringDtype
+def to_arrow_dtypes(dtypes):
+    from ..io.odpsio.schema import pandas_dtypes_to_arrow_schema
 
+    arrow_schema = pandas_dtypes_to_arrow_schema(dtypes)
     new_dtypes = dtypes.copy()
     for i in range(len(dtypes)):
-        dtype = dtypes.iloc[i]
-        if is_string_dtype(dtype):
-            if test_df is not None:
-                series = test_df.iloc[:, i]
-                # check value
-                non_na_series = series[series.notna()]
-                if len(non_na_series) > 0:
-                    first_value = non_na_series.iloc[0]
-                    if isinstance(first_value, str):
-                        new_dtypes.iloc[i] = ArrowStringDtype()
-                else:  # pragma: no cover
-                    # empty, set arrow string dtype
-                    new_dtypes.iloc[i] = ArrowStringDtype()
-            else:
-                # empty, set arrow string dtype
-                new_dtypes.iloc[i] = ArrowStringDtype()
+        arrow_type = arrow_schema.types[i]
+        dt = dtypes.iloc[i]
+        if isinstance(dt, pd.api.extensions.ExtensionDtype):
+            # make existing extension dtype consistent
+            new_dtypes.iloc[i] = dt
+        elif arrow_type == pa.string():
+            new_dtypes.iloc[i] = pd.StringDtype("pyarrow")
+        else:
+            new_dtypes.iloc[i] = ArrowDtype(arrow_type)
     return new_dtypes
 
 
@@ -1482,7 +1475,8 @@ def infer_dataframe_return_value(
                 elementwise=elementwise or False,
             )
 
-    ret_output_type = ret_dtypes = None
+    ret_output_type = None
+    ret_dtypes = dtypes
     maybe_agg = False
     build_kw = build_kw or {}
     obj_key = df_obj.key
@@ -1529,7 +1523,8 @@ def infer_dataframe_return_value(
                     f'please specify `output_type` as "dataframe"'
                 )
             ret_output_type = ret_output_type or OutputType.dataframe
-            ret_dtypes = ret_dtypes or infer_df_obj.dtypes
+            if ret_dtypes is None:
+                ret_dtypes = infer_df_obj.dtypes
         else:
             if output_type is not None and output_type == OutputType.dataframe:
                 raise TypeError(
@@ -1549,7 +1544,7 @@ def infer_dataframe_return_value(
         return InferredDataFrameMeta(
             ret_output_type,
             make_dtypes(ret_dtypes),
-            make_dtype(dtype),
+            make_dtypes(dtype),
             name,
             ret_index_value,
             maybe_agg,
@@ -1562,7 +1557,7 @@ def infer_dataframe_return_value(
         return InferredDataFrameMeta(
             output_type,
             make_dtypes(dtypes),
-            make_dtype(dtype),
+            make_dtypes(dtype),
             name,
             ret_index_value,
             maybe_agg,
@@ -1645,3 +1640,12 @@ def call_groupby_with_params(df_or_series, groupby_params: dict):
     if selection:
         res = res[selection]
     return res
+
+
+def validate_dtype_backend(value):
+    if isinstance(value, bool):
+        # compatibility for legacy use_arrow_dtype property
+        value = "pyarrow" if value else "numpy"
+    if not dtype_backend_validator(value):
+        raise ValueError(f"Invalid dtype_backend: {value}")
+    return value

maxframe/learn/contrib/llm/core.py

@@ -20,12 +20,16 @@ import pandas as pd
 from ....core.entity.output_types import OutputType
 from ....core.operator.base import Operator
 from ....core.operator.core import TileableOperatorMixin
-from ....dataframe.core import SERIES_TYPE
 from ....dataframe.operators import DataFrameOperatorMixin
 from ....dataframe.utils import parse_index
 from ....serialization.serializables import Int32Field
 from ....serialization.serializables.core import Serializable
-from ....serialization.serializables.field import AnyField, DictField, StringField
+from ....serialization.serializables.field import (
+    AnyField,
+    BoolField,
+    DictField,
+    StringField,
+)
 
 
 class LLM(Serializable):
@@ -55,11 +59,7 @@ class LLMTaskOperator(Operator, DataFrameOperatorMixin):
         col_name = list(outputs.keys())
         columns = parse_index(pd.Index(col_name), store_data=True)
         out_dtypes = pd.Series(list(outputs.values()), index=col_name)
-        index_value = index or (
-            parse_index(pd.RangeIndex(-1), data)
-            if isinstance(data, SERIES_TYPE)
-            else data.index_value
-        )
+        index_value = index or data.index_value
 
         return self.new_dataframe(
             inputs=[data],
@@ -75,3 +75,12 @@ class LLMTextGenOperator(LLMTaskOperator, TileableOperatorMixin):
 
     def get_output_dtypes(self) -> Dict[str, np.dtype]:
         return {"response": np.dtype("O"), "success": np.dtype("bool")}
+
+
+class LLMTextEmbeddingOp(LLMTaskOperator, TileableOperatorMixin):
+    dimensions = Int32Field("dimensions", default=None)
+    encoding_format = StringField("encoding_format", default=None)
+    simple_output = BoolField("simple_output", default=False)
+
+    def get_output_dtypes(self) -> Dict[str, np.dtype]:
+        return {"response": np.dtype("O"), "success": np.dtype("bool")}

maxframe/learn/contrib/llm/deploy/__init__.py

@@ -0,0 +1,13 @@
+# 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.

maxframe/learn/contrib/llm/deploy/config.py

@@ -0,0 +1,221 @@
+# 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.
+
+from copy import deepcopy
+from typing import Any, Dict, List, Optional, Union
+
+from .....protocol import Serializable
+from .....serialization.serializables import StringField
+from .....serialization.serializables.field import (
+    DictField,
+    EnumField,
+    Int32Field,
+    ListField,
+)
+from .....serialization.serializables.field_type import FieldTypes
+from .framework import InferenceFrameworkEnum
+
+
+class ModelDeploymentConfig(Serializable):
+    """
+    Model deployment configuration for extending MaxFrame with custom models.
+
+    This configuration is designed for users who need to deploy models that are not
+    available within MaxFrame's built-in model offerings. It provides a way to specify
+    custom deployment solutions by informing each MaxFrame worker which framework to use,
+    which model path to load, and how to load it.
+
+    The configuration assumes that models are already set up in the container image or
+    mounted paths, and uses the current deploy_config to load them. Users are responsible
+    for ensuring the runtime environment state and compatibility.
+
+    Parameters
+    ----------
+    model_name: str
+        The name of the model.
+    model_file: str
+        The file path of the model.
+    inference_framework_type: InferenceFrameworkEnum
+        The inference framework of the model.
+    required_resource_files: List[Union[str, Any]]
+        The required resource files of the model.
+    load_params: Dict[str, Any]
+        The load params of the model.
+    required_cpu: int
+        The required cpu of the model.
+    required_memory: int
+        The required memory of the model.
+    required_gu: int
+        The required gu of the model.
+    required_gpu_memory: int
+        The required gpu memory of the model.
+    device: str
+        The device of the model. One of "cpu" or "cuda".
+    properties: Dict[str, Any]
+        The properties of the model.
+    tags: List[str]
+        The tags of the model.
+
+    Notes
+    -----
+    - Preview version for model deployments, all fields could be changed in the future.
+
+    **User Responsibility Notice**: Users must have a complete understanding of what
+    they are computing and ensure they fully comprehend the implications of their
+    configuration choices. You are responsible for:
+
+    * Ensuring model compatibility with the specified inference framework
+    * Verifying that model files exist and are accessible in the runtime environment
+    * Confirming that resource requirements (CPU, memory, GPU) are adequate
+    * Validating that all dependencies and libraries are properly installed
+    * Understanding the computational behavior and characteristics of your chosen model
+
+    Examples
+    --------
+    >>> from maxframe.learn.contrib.llm.deploy.config import ModelDeploymentConfig
+    >>> from maxframe.learn.contrib.llm.deploy.framework import InferenceFrameworkEnum
+    >>> from maxframe.learn.contrib.llm.models.managed import ManagedTextGenLLM
+
+    >>> # Configure model deployment with VLLM framework
+    >>> model_config = ModelDeploymentConfig(
+    ...     # Path to the model files (assumed to be available in container/mount)
+    ...     model_file="/models/Qwen3-4B-Instruct-2507-FP8",
+    ...     # Use VLLM serving framework for text generation
+    ...     inference_framework_type=InferenceFrameworkEnum.VLLM_SERVE_TEXT,
+    ...     # Framework-specific loading parameters
+    ...     load_params={
+    ...         "max_context_tokens": 4096,  # Maximum context length for the model
+    ...         "max_startup_wait_seconds": 600  # Max wait time for model startup
+    ...     },
+    ...     # Target device for inference
+    ...     device="cuda",
+    ...     # Resource requirements (2 GPU units)
+    ...     required_gu=2,
+    ...     # Model tags for capabilities
+    ...     tags=["text-generation"],
+    ... )
+
+    >>> # Create managed LLM instance with the deployment configuration
+    >>> llm = ManagedTextGenLLM(name="my-model", deploy_config=model_config)
+    >>> # Generate text using the deployed model.
+    >>> result_df = llm.generate(
+    ...     df,  # Input DataFrame containing prompts
+    ...     prompt_template=messages,  # Template for formatting prompts
+    ...     running_options={
+    ...         "max_context_tokens": 4096,  # Runtime context limit
+    ...     },
+    ...     params={
+    ...         "temperature": 0.7,  # Sampling temperature
+    ...         "max_tokens": 2048  # Maximum tokens to generate
+    ...     },
+    ... )
+
+    To make this model config working with the ManagedTextGenLLM,
+    you need to provide a custom image with the required dependencies and model files.
+
+    """
+
+    model_name: str = StringField("model_name")
+    model_file: str = StringField("model_file")
+    inference_framework_type: InferenceFrameworkEnum = EnumField(
+        "inference_framework_type", enum_type=InferenceFrameworkEnum
+    )
+    required_resource_files: List[Union[str, Any]] = ListField(
+        "required_resource_files", field_type=FieldTypes.any, default_factory=list
+    )
+    load_params: Dict[str, Any] = DictField(
+        "load_params",
+        key_type=FieldTypes.string,
+        value_type=FieldTypes.any,
+        default_factory=dict,
+    )
+    required_cpu: Optional[int] = Int32Field("required_cpu", default=None)
+    required_memory: Optional[int] = Int32Field("required_memory", default=None)
+    required_gu: Optional[int] = Int32Field("required_gu", default=None)
+    required_gpu_memory: Optional[int] = Int32Field("required_gpu_memory", default=None)
+    device: str = StringField("device")
+    properties: Dict[str, Any] = DictField(
+        "properties",
+        key_type=FieldTypes.string,
+        value_type=FieldTypes.any,
+        default_factory=dict,
+    )
+    tags: List[str] = ListField(
+        "tags",
+        field_type=FieldTypes.string,
+        default_factory=list,
+    )
+
+    def is_reasoning_model(self):
+        if self.properties is None:
+            return False
+        return self.properties.get("reasoning_model", False)
+
+    def copy(self) -> "ModelDeploymentConfig":
+        return deepcopy(self)
+
+    def __eq__(self, other):
+        if not isinstance(other, ModelDeploymentConfig):
+            return False
+
+        return (
+            self.model_name == other.model_name
+            and self.model_file == other.model_file
+            and self.inference_framework_type == other.inference_framework_type
+            and self.required_resource_files == other.required_resource_files
+            and self.load_params == other.load_params
+            and self.required_cpu == other.required_cpu
+            and self.required_memory == other.required_memory
+            and self.required_gu == other.required_gu
+            and self.required_gpu_memory == other.required_gpu_memory
+            and self.device == other.device
+            and self.properties == other.properties
+            and self.tags == other.tags
+        )
+
+    def __hash__(self):
+        return hash(
+            (
+                self.model_name,
+                self.model_file,
+                self.inference_framework_type,
+                self.required_resource_files,
+                self.load_params,
+                self.required_cpu,
+                self.required_memory,
+                self.required_gu,
+                self.required_gpu_memory,
+                self.device,
+                self.properties,
+                self.tags,
+            )
+        )
+
+    def check_validity(self):
+        required_fields = [
+            "model_name",
+            "model_file",
+            "inference_framework_type",
+            "device",
+        ]
+        for field in required_fields:
+            if getattr(self, field) is None:
+                raise ValueError(f"{field} is required")
+
+        one_of_fields = ["required_cpu", "required_gu"]
+        if not any(getattr(self, field) is not None for field in one_of_fields):
+            raise ValueError(f"At least one of {one_of_fields} is required")
+
+        if not self.tags:
+            raise ValueError("tags is required")