maxframe 1.3.1__cp39-cp39-win_amd64.whl → 2.0.0__cp39-cp39-win_amd64.whl

maxframe/dataframe/datasource/from_records.py

@@ -1,5 +1,3 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
 # Copyright 1999-2025 Alibaba Group Holding Ltd.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -14,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from typing import MutableMapping, Union
+
 import numpy as np
 import pandas as pd
 
@@ -58,6 +58,13 @@ class DataFrameFromRecords(DataFrameOperator, DataFrameOperatorMixin):
             columns_value=columns_value,
         )
 
+    @classmethod
+    def estimate_size(
+        cls, ctx: MutableMapping[str, Union[int, float]], op: "DataFrameFromRecords"
+    ):  # pragma: no cover
+        # todo implement this to facilitate local computation
+        ctx[op.outputs[0].key] = float("inf")
+
 
 def from_records(
     data,

maxframe/dataframe/datasource/from_tensor.py

@@ -1,5 +1,3 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
 # Copyright 1999-2025 Alibaba Group Holding Ltd.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -15,13 +13,13 @@
 # limitations under the License.
 
 from collections import OrderedDict
-from typing import Any, Dict, List, Union
+from typing import Any, Dict, List, MutableMapping, Union
 
 import numpy as np
 import pandas as pd
 
 from ... import opcodes
-from ...core import ENTITY_TYPE, OutputType
+from ...core import ENTITY_TYPE, EntityData, OutputType
 from ...serialization.serializables import AnyField, KeyField
 from ...tensor.core import Tensor
 from ...tensor.datasource import tensor as astensor
@@ -46,24 +44,25 @@ class DataFrameFromTensor(DataFrameOperator, DataFrameOperatorMixin):
         kwargs["_output_types"] = [OutputType.dataframe]
         super().__init__(*args, **kwargs)
 
-    def _set_inputs(self, inputs: List[EntityType]):
-        super()._set_inputs(inputs)
-        inputs_iter = iter(self._inputs)
-        if self.input is not None:
-            if not isinstance(self.input, dict):
-                self.input = next(inputs_iter)
+    @classmethod
+    def _set_inputs(cls, op: "DataFrameFromTensor", inputs: List[EntityData]):
+        super()._set_inputs(op, inputs)
+        inputs_iter = iter(op._inputs)
+        if op.input is not None:
+            if not isinstance(op.input, dict):
+                op.input = next(inputs_iter)
             else:
                 # check each value for input
                 new_input = OrderedDict()
-                for k, v in self.input.items():
+                for k, v in op.input.items():
                     if isinstance(v, ENTITY_TYPE):
                         new_input[k] = next(inputs_iter)
                     else:
                         new_input[k] = v
-                self.input = new_input
+                op.input = new_input
 
-        if isinstance(self.index, ENTITY_TYPE):
-            self.index = next(inputs_iter)
+        if isinstance(op.index, ENTITY_TYPE):
+            op.index = next(inputs_iter)
 
     def __call__(
         self,
@@ -138,7 +137,11 @@ class DataFrameFromTensor(DataFrameOperator, DataFrameOperatorMixin):
                 )
             index_value = self._process_index(index, tileables)
         else:
-            self.index = index = pd.RangeIndex(0, tileables[0].shape[0])
+            if np.isnan(tileables[0].shape[0]):
+                index = pd.RangeIndex(0)
+            else:
+                index = pd.RangeIndex(0, tileables[0].shape[0])
+            self.index = index
             index_value = parse_index(index)
 
         if columns is not None:
@@ -260,6 +263,13 @@ class DataFrameFromTensor(DataFrameOperator, DataFrameOperatorMixin):
             columns_value=columns_value,
         )
 
+    @classmethod
+    def estimate_size(
+        cls, ctx: MutableMapping[str, Union[int, float]], op: "DataFrameFromTensor"
+    ):  # pragma: no cover
+        # todo implement this to facilitate local computation
+        ctx[op.outputs[0].key] = float("inf")
+
 
 def dataframe_from_tensor(
     tensor: Tensor,
@@ -340,12 +350,13 @@ class SeriesFromTensor(DataFrameOperator, DataFrameOperatorMixin):
     input = KeyField("input")
     index = AnyField("index")
 
-    def _set_inputs(self, inputs: List[EntityType]):
-        super()._set_inputs(inputs)
-        if self.input is not None:
-            self.input = self.inputs[0]
-        if self.index is not None and hasattr(self.index, "key"):
-            self.index = self.inputs[-1]
+    @classmethod
+    def _set_inputs(cls, op: "SeriesFromTensor", inputs: List[EntityData]):
+        super()._set_inputs(op, inputs)
+        if op.input is not None:
+            op.input = op.inputs[0]
+        if op.index is not None and hasattr(op.index, "key"):
+            op.index = op.inputs[-1]
 
     def __call__(
         self,

maxframe/dataframe/datasource/read_csv.py

@@ -1,5 +1,3 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
 # Copyright 1999-2025 Alibaba Group Holding Ltd.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -15,6 +13,7 @@
 # limitations under the License.
 
 from io import BytesIO
+from typing import MutableMapping, Union
 from urllib.parse import urlparse
 
 import numpy as np
@@ -129,6 +128,13 @@ class DataFrameReadCSV(
             chunk_bytes=chunk_bytes,
         )
 
+    @classmethod
+    def estimate_size(
+        cls, ctx: MutableMapping[str, Union[int, float]], op: "DataFrameReadCSV"
+    ):  # pragma: no cover
+        # todo implement this to facilitate local computation
+        ctx[op.outputs[0].key] = float("inf")
+
 
 def read_csv(
     path,

maxframe/dataframe/datasource/read_odps_query.py

@@ -13,13 +13,18 @@
 # limitations under the License.
 
 import dataclasses
+import functools
+import io
 import logging
 import re
-from typing import Dict, List, Optional, Tuple, Union
+import tokenize
+from typing import Dict, List, MutableMapping, Optional, Tuple, Union
 
 import numpy as np
 import pandas as pd
 from odps import ODPS
+from odps.errors import ODPSError
+from odps.models import TableSchema
 from odps.types import Column, OdpsSchema, validate_data_type
 from odps.utils import split_sql_by_semicolon
 
@@ -110,7 +115,15 @@ def _split_explain_string(explain_string: str) -> List[str]:
     grouped = []
     for part in parts:
         part = part.strip("\n")
-        if grouped and not part.startswith(" "):
+        part_line1 = part.split("\n", 1)[0]
+        # initial line of part should not start with spaces (Statistics row)
+        #  or with quote marks
+        if (
+            grouped
+            and not part.startswith(" ")
+            and "'" not in part_line1
+            and '"' not in part_line1
+        ):
             final_parts.append("\n\n".join(grouped).strip())
             grouped = []
         grouped.append(part)
@@ -235,13 +248,18 @@ def _parse_explained_schema(explain_string: str) -> OdpsSchema:
         return _parse_full_explain(explain_string)
 
 
-def _build_explain_sql(sql_stmt: str, no_split: bool = False) -> str:
+def _build_explain_sql(
+    sql_stmt: str, no_split: bool = False, use_output: bool = False
+) -> str:
+    clause = "EXPLAIN "
+    if use_output:
+        clause += "OUTPUT "
     if no_split:
-        return "EXPLAIN " + sql_stmt
+        return clause + sql_stmt
     sql_parts = split_sql_by_semicolon(sql_stmt)
     if not sql_parts:
         raise ValueError(f"Cannot explain SQL statement {sql_stmt}")
-    sql_parts[-1] = "EXPLAIN " + sql_parts[-1]
+    sql_parts[-1] = clause + sql_parts[-1]
     return "\n".join(sql_parts)
 
 
@@ -267,6 +285,15 @@ class DataFrameReadODPSQuery(
     def set_pruned_columns(self, columns, *, keep_order=None):  # pragma: no cover
         self.columns = columns
 
+    @classmethod
+    def estimate_size(
+        cls, ctx: MutableMapping[str, Union[int, float]], op: "DataFrameReadODPSQuery"
+    ):  # pragma: no cover
+        # use infinity to show that the size cannot be inferred
+        # todo when local catalyst is implemented,
+        #  a more precise estimation here can be useful then.
+        ctx[op.outputs[0].key] = float("inf")
+
     def __call__(self, chunk_bytes=None, chunk_size=None):
         if is_empty(self.index_columns):
             index_value = parse_index(pd.RangeIndex(0))
@@ -302,6 +329,73 @@ class DataFrameReadODPSQuery(
         )
 
 
+def _check_token_in_sql(token: str, sql: str) -> bool:
+    try:
+        names = set()
+        for tk_info in tokenize.tokenize(io.BytesIO(sql.encode()).readline):
+            if tk_info.type == tokenize.NAME:
+                names.add(tk_info.string)
+        return token in names
+    except:  # pragma: no cover
+        return False
+
+
+def _resolve_schema_by_explain(
+    odps_entry: ODPS,
+    query: str,
+    no_split_sql: bool = False,
+    hints: Dict[str, str] = None,
+    use_explain_output: bool = True,
+) -> OdpsSchema:
+    hints = (hints or dict()).copy()
+    hints["odps.sql.select.output.format"] = "json"
+    explain_stmt = _build_explain_sql(
+        query, no_split=no_split_sql, use_output=use_explain_output
+    )
+    inst = odps_entry.execute_sql(explain_stmt, hints=hints)
+    logger.debug("Explain output instance ID: %s", inst.id)
+    explain_str = list(inst.get_task_results().values())[0]
+    if use_explain_output:
+        if not explain_str or "nothing to explain" in explain_str:
+            raise ValueError("The SQL statement should be an instant query")
+        return TableSchema.parse(None, explain_str)
+    else:
+        return _parse_explained_schema(explain_str)
+
+
+def _resolve_query_schema(
+    odps_entry: ODPS,
+    query: str,
+    no_split_sql: bool = False,
+    hints: Dict[str, str] = None,
+    use_explain_output: Optional[bool] = None,
+) -> OdpsSchema:
+    methods = []
+    if use_explain_output is not False:
+        # None or True
+        methods.append(_resolve_schema_by_explain)
+    if use_explain_output is not True:
+        # None or False
+        methods.append(
+            functools.partial(_resolve_schema_by_explain, use_explain_output=False)
+        )
+    for idx, resolve_method in enumerate(methods):
+        try:
+            return resolve_method(
+                odps_entry, query, no_split_sql=no_split_sql, hints=hints
+            )
+        except ODPSError as ex:
+            msg = (
+                f"Failed to obtain schema from SQL explain: {ex!r}\n"
+                f"Explain instance ID: {ex.instance_id}"
+            )
+            if idx + 1 == len(methods) or "ODPS-0130161" not in str(ex):
+                exc = ValueError(msg)
+                raise exc.with_traceback(ex.__traceback__) from None
+    # will this happen?
+    raise ValueError("Failed to obtain schema from SQL explain")  # pragma: no cover
+
+
 def read_odps_query(
     query: str,
     odps_entry: ODPS = None,
@@ -341,6 +435,8 @@ def read_odps_query(
         DataFrame read from MaxCompute (ODPS) table
     """
     no_split_sql = kw.pop("no_split_sql", False)
+    # if use_explain_output is None, will try two methods.
+    use_explain_output = kw.pop("use_explain_output", None)
 
     hints = options.sql.settings.copy() or {}
     if sql_hints:
@@ -365,24 +461,18 @@ def read_odps_query(
 
     col_renames = {}
     if not skip_schema:
-        explain_stmt = _build_explain_sql(query, no_split=no_split_sql)
-        inst = odps_entry.execute_sql(explain_stmt, hints=hints)
-        logger.debug("Explain instance ID: %s", inst.id)
-        explain_str = list(inst.get_task_results().values())[0]
-
-        try:
-            odps_schema = _parse_explained_schema(explain_str)
-        except BaseException as ex:
-            exc = ValueError(
-                f"Failed to obtain schema from SQL explain: {ex!r}"
-                f"\nExplain instance ID: {inst.id}"
-            )
-            raise exc.with_traceback(ex.__traceback__) from None
+        odps_schema = _resolve_query_schema(
+            odps_entry,
+            query,
+            no_split_sql=no_split_sql,
+            hints=hints,
+            use_explain_output=use_explain_output,
+        )
 
         new_columns = []
         for col in odps_schema.columns:
             anon_match = _ANONYMOUS_COL_REGEX.match(col.name)
-            if anon_match and col.name not in query:
+            if anon_match and not _check_token_in_sql(col.name, query):
                 new_name = anonymous_col_prefix + anon_match.group(1)
                 col_renames[col.name] = new_name
                 new_columns.append(Column(new_name, col.type))

maxframe/dataframe/datasource/read_odps_table.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 
 import logging
-from typing import List, Optional, Union
+from typing import List, MutableMapping, Optional, Union
 
 import numpy as np
 import pandas as pd
@@ -34,7 +34,7 @@ from ...serialization.serializables import (
     SeriesField,
     StringField,
 )
-from ...utils import is_empty
+from ...utils import estimate_table_size, is_empty
 from ..core import DataFrame  # noqa: F401
 from ..utils import parse_index
 from .core import ColumnPruneSupportedDataSourceMixin, IncrementalIndexDatasource
@@ -46,6 +46,7 @@ class DataFrameReadODPSTable(
     IncrementalIndexDatasource,
     ColumnPruneSupportedDataSourceMixin,
 ):
+    __slots__ = ("_odps_entry",)
     _op_type_ = opcodes.READ_ODPS_TABLE
 
     table_name = StringField("table_name")
@@ -61,7 +62,8 @@ class DataFrameReadODPSTable(
     index_dtypes = SeriesField("index_dtypes", default=None)
 
     def __init__(self, memory_scale=None, **kw):
-        output_type = kw.get("output_type", OutputType.dataframe)
+        output_type = kw.pop("output_type", OutputType.dataframe)
+        self._odps_entry = kw.pop("odps_entry", None)
         super(DataFrameReadODPSTable, self).__init__(
             memory_scale=memory_scale, _output_types=[output_type], **kw
         )
@@ -130,6 +132,18 @@ class DataFrameReadODPSTable(
                 chunk_size=chunk_size,
             )
 
+    @classmethod
+    def estimate_size(
+        cls, ctx: MutableMapping[str, Union[int, float]], op: "DataFrameReadODPSTable"
+    ) -> None:
+        odps_entry = op._odps_entry or ODPS.from_global() or ODPS.from_environments()
+        if not odps_entry:  # pragma: no cover
+            ctx[op.outputs[0].key] = float("inf")
+            return
+        ctx[op.outputs[0].key] = estimate_table_size(
+            odps_entry, op.table_name, op.partitions
+        )
+
 
 def read_odps_table(
     table_name: Union[str, Table],
@@ -212,7 +226,8 @@ def read_odps_table(
         index_dtypes = pd.Series(table_index_types, index=index_col)
 
     if columns is not None:
-        table_col_set = set([c.lower() for c in columns])
+        new_columns = [c.lower() for c in columns]
+        table_col_set = set(new_columns)
         col_diff = sorted(table_col_set - set(table_columns))
         if col_diff:
             raise ValueError(
@@ -223,7 +238,6 @@ def read_odps_table(
             raise ValueError("Index columns and columns shall not overlap.")
 
         # reorder columns
-        new_columns = [c for c in table_columns if c in table_col_set]
         df_types = [df_types[table_columns.index(col)] for col in new_columns]
         table_columns = new_columns
         columns = new_columns
@@ -253,6 +267,7 @@ def read_odps_table(
         last_modified_time=to_timestamp(table.last_data_modified_time),
         index_columns=index_col,
         index_dtypes=index_dtypes,
+        odps_entry=odps_entry,
         **kw,
     )
     return op(shape, chunk_bytes=chunk_bytes, chunk_size=chunk_size)

maxframe/dataframe/datasource/read_parquet.py

@@ -1,5 +1,3 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
 # Copyright 1999-2025 Alibaba Group Holding Ltd.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -15,7 +13,7 @@
 # limitations under the License.
 
 import os
-from typing import Dict
+from typing import Dict, MutableMapping, Union
 from urllib.parse import urlparse
 
 import numpy as np
@@ -308,6 +306,13 @@ class DataFrameReadParquet(
             columns_value=columns_value,
         )
 
+    @classmethod
+    def estimate_size(
+        cls, ctx: MutableMapping[str, Union[int, float]], op: "DataFrameReadParquet"
+    ):  # pragma: no cover
+        # todo implement this to facilitate local computation
+        ctx[op.outputs[0].key] = float("inf")
+
 
 def read_parquet(
     path,

maxframe/dataframe/datasource/tests/test_datasource.py

@@ -15,15 +15,19 @@
 import os
 import uuid
 from collections import OrderedDict
+from math import isinf
 
+import mock
 import numpy as np
 import pandas as pd
 import pytest
 from odps import ODPS
 from odps import types as odps_types
+from odps.errors import ODPSError
 
 from .... import tensor as mt
 from ....core import OutputType
+from ....core.operator import estimate_size
 from ....tests.utils import tn
 from ....utils import lazy_import
 from ... import read_odps_query, read_odps_table
@@ -48,6 +52,7 @@ from ..read_odps_query import (
     ColumnSchema,
     _parse_full_explain,
     _parse_simple_explain,
+    _resolve_query_schema,
     _resolve_task_sector,
 )
 from ..series import from_pandas as from_pandas_series
@@ -71,6 +76,10 @@ def test_from_pandas_dataframe():
     assert df.index_value.max_val == 9
     np.testing.assert_equal(df.columns_value._index_value._data, data.columns.values)
 
+    result_ctx = dict()
+    estimate_size(result_ctx, df.op)
+    assert result_ctx[df.key] > 0 and not isinf(result_ctx[df.key])
+
     data2 = data[::2]
     df2 = from_pandas_df(data2, chunk_size=4)
 
@@ -258,6 +267,10 @@ def test_from_odps_table():
         ),
     )
 
+    result_ctx = dict()
+    estimate_size(result_ctx, df.op)
+    assert result_ctx[df.key] >= 0 and not isinf(result_ctx[df.key])
+
     with pytest.raises(ValueError):
         read_odps_table(test_table, columns=["col3", "col4"])
     with pytest.raises(ValueError):
@@ -300,6 +313,7 @@ def test_from_odps_table():
         ),
     )
 
+    test_parted_table.create_partition("pt=20240103")
     df = read_odps_table(
         test_parted_table, columns=["col1", "col2", "pt"], partitions="pt=20240103"
     )
@@ -314,6 +328,10 @@ def test_from_odps_table():
         ),
     )
 
+    result_ctx = dict()
+    estimate_size(result_ctx, df.op)
+    assert result_ctx[df.key] >= 0 and not isinf(result_ctx[df.key])
+
     out_idx = read_odps_table(
         test_table,
         columns=[],
@@ -345,7 +363,7 @@ def test_from_odps_query():
 
     with pytest.raises(ValueError) as err_info:
         read_odps_query(
-            f"CREATE TABLE dummy_table_{uuid.uuid4().hex} "
+            f"CREATE TABLE dummy_table_{uuid.uuid4().hex} LIFECYCLE 1 "
             f"AS SELECT * FROM {table1_name}"
         )
     assert "instant query" in err_info.value.args[0]
@@ -545,3 +563,64 @@ def test_resolve_multi_join():
     for col, (exp_nm, exp_tp) in zip(schema.columns, expected_col_types.items()):
         assert col.name == exp_nm
         assert col.type == odps_types.validate_data_type(exp_tp)
+
+
+def test_resolve_break_lines():
+    input_path = os.path.join(
+        os.path.dirname(__file__), "test-data", "task-input-with-break-line.txt"
+    )
+    with open(input_path, "r") as f:
+        sector = f.read()
+
+    expected_col_types = {
+        "key": "string",
+        "value": "string",
+    }
+
+    schema = _parse_full_explain(sector)
+    for col, (exp_nm, exp_tp) in zip(schema.columns, expected_col_types.items()):
+        assert col.name == exp_nm
+        assert col.type == odps_types.validate_data_type(exp_tp)
+
+
+@pytest.mark.parametrize("use_explain_output", [None, False, True])
+def test_explain_use_explain_output(use_explain_output):
+    class MockInstance:
+        @property
+        def id(self):
+            return "mock_id"
+
+        def get_task_results(self):
+            return {"pot": """{"columns":[{"name":"a_bigint","type":"BIGINT"}]}"""}
+
+    old_execute_sql = ODPS.execute_sql
+    exec_count = 0
+
+    def new_execute_sql(self, sql, *args, **kw):
+        nonlocal exec_count
+        exec_count += 1
+
+        if use_explain_output and sql.lower().startswith("explain output select"):
+            return MockInstance()
+        elif use_explain_output is None and sql.lower().startswith("explain output"):
+            raise ODPSError("ODPS-0130161: mock error")
+        return old_execute_sql(self, sql, *args, **kw)
+
+    odps_entry = ODPS.from_environments()
+
+    with mock.patch("odps.core.ODPS.execute_sql", new=new_execute_sql):
+        with pytest.raises(ValueError):
+            _resolve_query_schema(
+                odps_entry, "not_a_sql", use_explain_output=use_explain_output
+            )
+        assert exec_count == (2 if use_explain_output is None else 1)
+
+        exec_count = 0
+        schema = _resolve_query_schema(
+            odps_entry,
+            "select cast(1 as bigint) as a_bigint",
+            use_explain_output=use_explain_output,
+        )
+        assert schema.columns[0].name == "a_bigint"
+        assert schema.columns[0].type == odps_types.bigint
+        assert exec_count == (2 if use_explain_output is None else 1)

maxframe/dataframe/datastore/tests/test_to_odps.py

@@ -12,9 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import pandas as pd
 import pytest
 
-from ... import DataFrame
+from ... import DataFrame, Index
 from ..to_odps import to_odps_table
 
 
@@ -23,6 +24,25 @@ def df():
     return DataFrame({"A": [1, 2], "B": [3, 4]})
 
 
+@pytest.fixture
+def df_with_named_index():
+    return DataFrame({"A": [1, 2], "B": [3, 4]}, index=Index([1, 2], name="A"))
+
+
+@pytest.fixture
+def df_with_named_multi_indexes():
+    arrays = [
+        ["c1", "c2"],
+        ["d1", "d2"],
+        ["e1", "e2"],
+    ]
+    multi_index = pd.MultiIndex.from_arrays(arrays, names=("C", "D", "E"))
+    return DataFrame(
+        {"A": [1, 2], "B": [3, 4]},
+        index=multi_index,
+    )
+
+
 @pytest.mark.parametrize(
     "kwargs",
     [
@@ -46,3 +66,34 @@ def test_to_odps_table_validation(df, kwargs):
 )
 def test_to_odps_table_vaild(df, kwargs):
     to_odps_table(df, "test_table", **kwargs)
+
+
+def test_to_odps_table_column_conflicts(
+    df, df_with_named_index, df_with_named_multi_indexes
+):
+    to_odps_table(df.reset_index(), "test_table", index=False)
+    to_odps_table(df.reset_index(), "test_table", index_label="C")
+    with pytest.raises(ValueError):
+        to_odps_table(df.reset_index(), "test_table")
+
+    to_odps_table(df_with_named_index, "test_table", index=False)
+    to_odps_table(df_with_named_index, "test_table", index_label="C")
+    with pytest.raises(ValueError):
+        to_odps_table(df_with_named_index, "test_table")
+
+    to_odps_table(df, "test_table", partition="C='1'")
+    with pytest.raises(ValueError):
+        to_odps_table(df, "test_table", partition="A='1'")
+
+    with pytest.raises(ValueError):
+        to_odps_table(df, "test_table", partition="A='1'")
+
+    to_odps_table(df_with_named_multi_indexes, "test_table")
+    to_odps_table(
+        df_with_named_multi_indexes, "test_table", partition="C='1'", index=False
+    )
+    with pytest.raises(ValueError):
+        to_odps_table(df_with_named_multi_indexes, "test_table", partition="C='1'")
+
+    df_with_named_multi_indexes.index.names = ["C1", "D1", "E1"]
+    to_odps_table(df_with_named_multi_indexes, "test_table", partition="C='1'")