maxc-cli 0.6.0__tar.gz → 0.6.1__tar.gz

{maxc_cli-0.6.0 → maxc_cli-0.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maxc-cli
-Version: 0.6.0
+Version: 0.6.1
 Summary: Agent-native MaxCompute CLI for external coding agents
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.9

{maxc_cli-0.6.0 → maxc_cli-0.6.1}/src/maxc_cli/__init__.py

@@ -2,4 +2,4 @@
 
 __all__ = ["__version__"]
 
-__version__ = "0.6.0"
+__version__ = "0.6.1"

{maxc_cli-0.6.0 → maxc_cli-0.6.1}/src/maxc_cli/backend/odps.py

@@ -56,6 +56,25 @@ def _summarize_fallback_warning(message: 'str') -> 'str | None':
     return None
 
 
+_RAW_RESULT_COLUMNS = ("task_name", "result")
+
+
+def _raw_task_result_rows(task_results: 'dict[str, Any]') -> 'list[dict[str, Any]]':
+    """Materialize raw task results as single-column rows for degraded reads.
+
+    Used when the tabular result reader cannot parse the server's CSV text
+    (e.g. unquoted commas inside SHOW INDEXES column values). The original
+    result strings are returned verbatim without type casting.
+    """
+    return [
+        {
+            "task_name": str(name),
+            "result": "" if value is None else str(value),
+        }
+        for name, value in task_results.items()
+    ]
+
+
 class OdpsBackend(
     JobMixin,  # JobMixin extends QueryMixin
     CatalogMixin,
@@ -116,7 +135,9 @@ class OdpsBackend(
             schema: list[dict[str, Any]] = []
             rows: list[dict[str, Any]] = []
             total_rows = 0
+            degraded_reason: str | None = None
         else:
+            degraded_reason = None
             try:
                 # Capture pyodps's tunnel-fallback UserWarnings so we can surface
                 # them via the envelope. catch_warnings(record=True) suppresses
@@ -124,42 +145,59 @@ class OdpsBackend(
                 # running without --json still see the original message.
                 with warnings.catch_warnings(record=True) as captured:
                     warnings.simplefilter("always")
-                    with instance.open_reader() as reader:
-                        # Materialize records first. When pyodps falls back from
-                        # the instance tunnel to CsvRecordReader (e.g. on tunnel
-                        # timeout), the column metadata is parsed lazily from the
-                        # CSV header during the first __next__ call — so we can
-                        # only inspect it after iteration begins.
-                        records = list(islice(reader, offset, offset + max_rows))
-
-                        reader_schema = getattr(reader, "schema", None)
-                        if reader_schema is not None and hasattr(reader_schema, "columns"):
-                            columns = list(reader_schema.columns)
-                        else:
-                            # Fallback path: CsvRecordReader exposes header columns
-                            # via `_csv_columns` after iteration starts.
-                            columns = list(getattr(reader, "_csv_columns", None) or [])
-
-                        if not columns:
-                            # Truly schema-less query-like result.
-                            schema = []
-                            rows = []
-                            total_rows = 0
-                        else:
-                            schema = [
-                                {
-                                    "name": column.name,
-                                    "type": str(column.type),
-                                    "comment": "",
-                                }
-                                for column in columns
-                            ]
-                            column_names = [column["name"] for column in schema]
-                            rows = [
-                                record_to_dict(column_names, record.values)
-                                for record in records
-                            ]
-                            total_rows = int(getattr(reader, "count", len(rows)) or len(rows))
+                    try:
+                        with instance.open_reader() as reader:
+                            # Materialize records first. When pyodps falls back from
+                            # the instance tunnel to CsvRecordReader (e.g. on tunnel
+                            # timeout), the column metadata is parsed lazily from the
+                            # CSV header during the first __next__ call — so we can
+                            # only inspect it after iteration begins.
+                            records = list(islice(reader, offset, offset + max_rows))
+
+                            reader_schema = getattr(reader, "schema", None)
+                            if reader_schema is not None and hasattr(reader_schema, "columns"):
+                                columns = list(reader_schema.columns)
+                            else:
+                                # Fallback path: CsvRecordReader exposes header columns
+                                # via `_csv_columns` after iteration starts.
+                                columns = list(getattr(reader, "_csv_columns", None) or [])
+
+                            if not columns:
+                                # Truly schema-less query-like result.
+                                schema = []
+                                rows = []
+                                total_rows = 0
+                            else:
+                                schema = [
+                                    {
+                                        "name": column.name,
+                                        "type": str(column.type),
+                                        "comment": "",
+                                    }
+                                    for column in columns
+                                ]
+                                column_names = [column["name"] for column in schema]
+                                rows = [
+                                    record_to_dict(column_names, record.values)
+                                    for record in records
+                                ]
+                                total_rows = int(getattr(reader, "count", len(rows)) or len(rows))
+                    except Exception as reader_exc:
+                        # Some SHOW results (e.g. multi-column SHOW INDEXES
+                        # col_names) contain unquoted commas that make
+                        # PyODPS's CSV reader raise IndexError while casting
+                        # fields. The job itself succeeded, so degrade to the
+                        # raw task-result text instead of failing the query.
+                        task_results = self._safe_task_results(instance)
+                        if not any(str(value).strip() for value in task_results.values()):
+                            # No raw text to degrade to — surface the real error.
+                            raise
+                        degraded_reason = str(reader_exc) or type(reader_exc).__name__
+                        all_raw_rows = _raw_task_result_rows(task_results)
+                        rows = all_raw_rows[offset : offset + max_rows]
+                        schema = [{"name": name, "type": "string", "comment": ""}
+                                  for name in _RAW_RESULT_COLUMNS]
+                        total_rows = len(rows)
 
                 for w in captured:
                     msg_text = str(w.message)
@@ -174,10 +212,19 @@ class OdpsBackend(
             except Exception as exc:
                 raise translate_odps_error(exc) from exc
 
+        if degraded_reason is not None:
+            fallback_warnings.append(
+                "Result reader failed to parse the task result "
+                f"({degraded_reason}); returning the raw task result text "
+                "verbatim in the `result` column without type casting."
+            )
+
         bytes_scanned, extra_metadata = self._task_cost(instance)
         returned_rows = len(rows)
         has_more = total_rows > (offset + returned_rows)
         extra_metadata["current_offset"] = offset
+        if degraded_reason is not None:
+            extra_metadata["result_kind"] = "raw_task_result"
         if resultless_statement:
             extra_metadata["result_kind"] = "statement"
             if statement_operation is not None:

{maxc_cli-0.6.0 → maxc_cli-0.6.1}/src/maxc_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maxc-cli
-Version: 0.6.0
+Version: 0.6.1
 Summary: Agent-native MaxCompute CLI for external coding agents
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.9

{maxc_cli-0.6.0 → maxc_cli-0.6.1}/tests/test_query_result_csv_fallback.py

@@ -17,6 +17,7 @@ pytestmark = pytest.mark.unit
 
 from odps.readers import CsvRecordReader
 
+from maxc_cli.backend.job import JobMixin
 from maxc_cli.backend.odps import OdpsBackend
 
 
@@ -27,9 +28,18 @@ class _FakeInstance:
     start_time = None
     end_time = None
 
-    def __init__(self, reader, *, warn_on_open: str | None = None) -> None:
+    def __init__(
+        self,
+        reader,
+        *,
+        warn_on_open: str | None = None,
+        task_results: dict[str, str] | None = None,
+        raise_on_task_results: bool = False,
+    ) -> None:
         self._reader = reader
         self._warn_on_open = warn_on_open
+        self._task_results = task_results
+        self._raise_on_task_results = raise_on_task_results
 
     def open_reader(self):
         if self._warn_on_open:
@@ -40,12 +50,18 @@ class _FakeInstance:
     def get_task_cost(self):
         return None
 
+    def get_task_results(self):
+        if self._raise_on_task_results or self._task_results is None:
+            raise RuntimeError("get_task_results not stubbed")
+        return dict(self._task_results)
+
 
 class _StubBackend:
     """Bind just the methods under test without invoking OdpsBackend.__init__."""
 
     project = "test_project"
     _instance_to_query_result = OdpsBackend._instance_to_query_result
+    _safe_task_results = JobMixin._safe_task_results
     _task_cost = OdpsBackend._task_cost
 
 
@@ -56,8 +72,15 @@ def _run(
     max_rows: int = 100,
     offset: int = 0,
     warn_on_open: str | None = None,
+    task_results: dict[str, str] | None = None,
+    raise_on_task_results: bool = False,
 ):
-    instance = _FakeInstance(reader, warn_on_open=warn_on_open)
+    instance = _FakeInstance(
+        reader,
+        warn_on_open=warn_on_open,
+        task_results=task_results,
+        raise_on_task_results=raise_on_task_results,
+    )
     return _StubBackend()._instance_to_query_result(
         instance,
         project="test_project",
@@ -404,6 +427,101 @@ def test_query_like_statement_still_opens_result_reader() -> None:
         )
 
 
+# ---------------------------------------------------------------------------
+# Raw task-result degradation: when the CSV reader cannot parse a successful
+# job's result text (e.g. SHOW INDEXES multi-column col_names contain unquoted
+# commas and PyODPS raises IndexError while casting), fall back to returning
+# the raw task result verbatim instead of failing the query.
+# ---------------------------------------------------------------------------
+
+SHOW_INDEXES_MULTI_COLUMN_HEADER = (
+    "idx_name,tab_name,col_names,idx_tab_name,idx_type,comment\n"
+)
+SHOW_INDEXES_MULTI_COLUMN_ROW = (
+    "vidx,tbl,c1,c2,vidx_idx,VECTOR,\n"
+)
+
+
+def test_csv_index_error_degrades_to_raw_task_result() -> None:
+    """The SHOW INDEXES crash: data rows have more CSV fields than the header,
+    so CsvRecordReader raises IndexError mid-iteration. The job succeeded, so
+    the envelope must carry the raw result text with an explanatory warning.
+    """
+    raw = SHOW_INDEXES_MULTI_COLUMN_HEADER + SHOW_INDEXES_MULTI_COLUMN_ROW
+    reader = CsvRecordReader(schema=None, stream=raw)
+    result = _run(
+        reader,
+        sql="SHOW INDEXES ON proj.default.tbl",
+        task_results={"AnonymousSQLTask": raw},
+    )
+
+    assert [col["name"] for col in result.schema] == ["task_name", "result"]
+    assert result.rows == [{"task_name": "AnonymousSQLTask", "result": raw}]
+    assert result.total_rows == 1
+    assert result.extra_metadata["result_kind"] == "raw_task_result"
+    assert any("raw task result" in w for w in result.warnings), result.warnings
+    assert any("IndexError" in w or "index out of range" in w for w in result.warnings), (
+        result.warnings
+    )
+
+
+def test_real_pyodps_indexerror_on_unquoted_comma_row_degrades() -> None:
+    """End-to-end through the real PyODPS reader: a row whose values contain
+    unquoted commas must degrade rather than propagate IndexError."""
+    raw = (
+        "a,b\n"
+        '1,"x"\n'
+        "2,x,y,z\n"  # extra unquoted fields -> IndexError inside _cast_value
+    )
+    reader = CsvRecordReader(schema=None, stream=raw)
+    with pytest.raises(IndexError):
+        list(reader)  # sanity: the bare reader genuinely fails
+
+    result = _run(
+        CsvRecordReader(schema=None, stream=raw),
+        sql="SHOW INDEXES ON t",
+        task_results={"SQLTask_1": raw},
+    )
+    assert result.rows[0]["result"] == raw
+    assert result.extra_metadata["result_kind"] == "raw_task_result"
+
+
+def test_reader_failure_without_task_result_text_still_raises() -> None:
+    """Degradation requires actual result text; empty or unreadable task
+    results keep the original error translation so real failures are not
+    masked as success."""
+    reader = CsvRecordReader(schema=None, stream="a,b\n1,2,3\n")
+    with pytest.raises(Exception, match="list index out of range"):
+        _run(reader, sql="SHOW INDEXES ON t", raise_on_task_results=True)
+
+    # Whitespace-only task results are treated as absent: the header row is
+    # consumed by the lazy column load, so iteration yields no records and the
+    # bare reader never raises. A genuinely unparseable body must still fail.
+    with pytest.raises(Exception, match="list index out of range"):
+        _run(
+            CsvRecordReader(schema=None, stream="hdr\nx\na,b\n1,2,3\n"),
+            sql="SHOW INDEXES ON t",
+            task_results={"AnonymousSQLTask": "   \n"},
+        )
+
+
+def test_degraded_offset_and_max_rows_apply_to_task_rows() -> None:
+    raw_a = "a,b\n1,2,3\n"
+    raw_b = "a,b\n4,5,6\n"
+    reader = CsvRecordReader(schema=None, stream=raw_a)
+    result = _run(
+        reader,
+        sql="SHOW INDEXES ON t",
+        task_results={"taskA": raw_a, "taskB": raw_b},
+        max_rows=1,
+        offset=1,
+    )
+    assert [row["task_name"] for row in result.rows] == ["taskB"]
+    # total_rows counts the materialized window, so pagination terminates.
+    assert result.total_rows == 1
+    assert result.has_more is False
+
+
 # ---------------------------------------------------------------------------
 # Fallback-warning capture: surface pyodps's "tunnel fallback" UserWarning
 # into the envelope so agents can see that the result was truncated.