maxc-cli 0.9.3__tar.gz → 0.9.4__tar.gz

{maxc_cli-0.9.3 → maxc_cli-0.9.4}/PKG-INFO

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

{maxc_cli-0.9.3 → maxc_cli-0.9.4}/src/maxc_cli/__init__.py

@@ -2,4 +2,4 @@
 
 __all__ = ["__version__"]
 
-__version__ = "0.9.3"
+__version__ = "0.9.4"

{maxc_cli-0.9.3 → maxc_cli-0.9.4}/src/maxc_cli/backend/odps.py

@@ -13,7 +13,7 @@ from ..helpers import (
     translate_odps_error,
 )
 from ..models import QueryResult
-from ..utils import detect_operation, extract_table_names
+from ..utils import detect_operation, extract_table_names, sql_keyword_tokens, sql_statements
 from .auth import AuthMixin
 from .catalog import CatalogMixin
 from .data import DataMixin
@@ -75,6 +75,26 @@ def _raw_task_result_rows(task_results: 'dict[str, Any]') -> 'list[dict[str, Any
     ]
 
 
+def _is_show_partitions(sql: 'str') -> 'bool':
+    statements = sql_statements(sql)
+    return len(statements) == 1 and sql_keyword_tokens(statements[0])[:2] == ["SHOW", "PARTITIONS"]
+
+
+def _show_partition_rows(task_results: 'Any') -> 'list[dict[str, str]]':
+    """SHOW PARTITIONS emits headerless lines, not a CSV table with a header."""
+    if not isinstance(task_results, dict):
+        raise ValueError("SHOW PARTITIONS returned invalid task results")
+    rows = []
+    for text in task_results.values():
+        if text is None:
+            continue
+        if not isinstance(text, str):
+            raise ValueError("SHOW PARTITIONS returned invalid task result text")
+        # Split only protocol line endings; Unicode separators may be values.
+        rows.extend({"partition": line.removesuffix("\r")} for line in text.split("\n") if line.removesuffix("\r"))
+    return rows
+
+
 class OdpsBackend(
     JobMixin,  # JobMixin extends QueryMixin
     CatalogMixin,
@@ -123,11 +143,12 @@ class OdpsBackend(
     ) -> 'QueryResult':
         """Convert ODPS instance to QueryResult."""
         fallback_warnings: list[str] = []
+        show_partitions = _is_show_partitions(sql)
         statement_operation = _write_operation(sql)
         instance_is_select = getattr(instance, "_is_select", None)
         confirmed_task_results = None
         resultless_statement = statement_operation is not None and instance_is_select is not True
-        if not resultless_statement and instance_is_select is False:
+        if not show_partitions and not resultless_statement and instance_is_select is False:
             try:
                 task_results = instance.get_task_results()
             except Exception:
@@ -140,7 +161,23 @@ class OdpsBackend(
                     resultless_statement = not any(str(value or "").strip() for value in task_results.values())
                     if resultless_statement and sql.strip():
                         statement_operation = detect_operation(sql)
-        if resultless_statement:
+        if show_partitions:
+            try:
+                # The generic CSV reader consumes the first partition as a
+                # header and raises on an empty body. Read this known textual
+                # result directly, retaining lookup failures as real errors.
+                all_rows = _show_partition_rows(instance.get_task_results())
+            except Exception as exc:
+                error = translate_odps_error(exc)
+                error.instance_id = instance.id
+                error.logview = self._safe_logview(instance)
+                raise error from exc
+            schema = [{"name": "partition", "type": "string", "comment": ""}]
+            rows = all_rows[offset : offset + max_rows]
+            total_rows = len(all_rows)
+            degraded_reason = None
+            resultless_statement = False
+        elif resultless_statement:
             # Successful write statements have no tabular result. In
             # particular, PyODPS's DDL fallback reader may try to iterate a
             # missing task_results value and raise after the server job has

{maxc_cli-0.9.3 → maxc_cli-0.9.4}/src/maxc_cli.egg-info/PKG-INFO

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

{maxc_cli-0.9.3 → maxc_cli-0.9.4}/tests/test_query_result_csv_fallback.py

@@ -688,3 +688,113 @@ def test_select_marker_preserves_results_for_a_known_write_operation() -> None:
     )
     assert result.rows == [{"value": "1"}]
     assert "result_kind" not in result.extra_metadata
+
+
+@pytest.mark.parametrize("marker", [None, False, True])
+@pytest.mark.parametrize("partitions", [[], ["ds=20261021"], ["ds=20261021", "ds=20261022"]])
+def test_show_partitions_preserves_headerless_rows(marker, partitions):
+    raw = "\n".join(partitions) + ("\n" if partitions else "")
+    # Use the real SDK reader which caused the regression without making its
+    # current empty/headerless parsing bugs part of MaxC's permanent contract.
+    instance = _FakeInstance(reader=CsvRecordReader(schema=None, stream=raw), task_results={"SQLTask": raw})
+    instance._is_select = marker
+    result = _StubBackend()._instance_to_query_result(instance, project="test_project", max_rows=100, sql="SHOW PARTITIONS t", elapsed_ms=1)
+    assert result.schema == [{"name": "partition", "type": "string", "comment": ""}]
+    assert result.rows == [{"partition": p} for p in partitions]
+    assert result.total_rows == result.returned_rows == len(partitions)
+    assert result.has_more is False
+    assert result.extra_metadata.get("result_kind") != "statement"
+
+
+@pytest.mark.parametrize("offset, expected, has_more", [(0, ["ds=1"], True), (1, ["ds=2"], False), (2, [], False)])
+def test_show_partitions_pages_each_partition(offset, expected, has_more):
+    result = _run(None, sql="SET odps.sql.type.vector.enable=true; /* scope */ SHOW\nPARTITIONS t", task_results={"SQLTask": "ds=1\r\nds=2\r\n"}, offset=offset, max_rows=1)
+    assert result.rows == [{"partition": p} for p in expected]
+    assert result.total_rows == 2
+    assert result.returned_rows == len(expected)
+    assert result.has_more is has_more
+
+
+@pytest.mark.parametrize("task_results", [{}, {"SQLTask": None}, {"SQLTask": ""}])
+def test_show_partitions_successful_empty_task_result_has_schema(task_results):
+    result = _run(None, sql="SHOW PARTITIONS t", task_results=task_results)
+    assert result.schema[0]["name"] == "partition"
+    assert result.rows == []
+    assert result.total_rows == 0
+
+
+def test_show_partitions_lookup_failure_is_not_empty_success():
+    with pytest.raises(Exception, match="get_task_results not stubbed"):
+        _run(None, sql="SHOW PARTITIONS t", raise_on_task_results=True)
+
+
+@pytest.mark.parametrize("task_results", [None, [], {"SQLTask": object()}])
+def test_show_partitions_invalid_task_results_are_not_empty_success(task_results):
+    instance = _FakeInstance(reader=None)
+    instance.get_task_results = lambda: task_results
+    with pytest.raises(Exception, match="invalid task result"):
+        _StubBackend()._instance_to_query_result(instance, project="test_project", max_rows=100, sql="SHOW PARTITIONS t", elapsed_ms=1)
+
+
+def test_partition_like_select_header_stays_a_real_csv_header():
+    result = _run(CsvRecordReader(schema=None, stream="ds=20261021\nvalue\n"), sql="SELECT value AS `ds=20261021` FROM t")
+    assert result.rows == [{"ds=20261021": "value"}]
+
+
+def test_show_partitions_keeps_unicode_separators_inside_partition_value():
+    partition = "ds=before\u2028after"
+    result = _run(None, sql="SHOW PARTITIONS t", task_results={"SQLTask": partition + "\n"})
+    assert result.rows == [{"partition": partition}]
+
+
+@pytest.mark.parametrize("partitions", [[], ["ds=1"], ["ds=1", "ds=2"]])
+def test_completed_job_fetch_recovers_show_partitions_sql(partitions):
+    from types import SimpleNamespace
+
+    class _CompletedInstance(_FakeInstance):
+        def get_sql_query(self):
+            return "SHOW PARTITIONS t"
+
+    instance = _CompletedInstance(
+        reader=None, task_results={"SQLTask": "\n".join(partitions)},
+    )
+
+    class _JobBackend(_StubBackend):
+        fetch_job_result = JobMixin.fetch_job_result
+        _safe_sql = JobMixin._safe_sql
+
+        def _get_instance(self, job_id, **kwargs):
+            assert job_id == instance.id
+            return instance
+
+        def _instance_to_job_info(self, instance, **kwargs):
+            return SimpleNamespace(status="success")
+
+        def _rehydrate_sqlrt_result_instance(self, instance):
+            return instance
+
+    result = _JobBackend().fetch_job_result(instance.id, max_rows=1, offset=0)
+    assert result.sql_executed == "SHOW PARTITIONS t"
+    assert result.schema[0]["name"] == "partition"
+    assert result.rows == [{"partition": p} for p in partitions[:1]]
+    assert result.total_rows == len(partitions)
+    assert result.has_more is (len(partitions) > 1)
+
+
+def test_show_partitions_permission_error_preserves_original_job():
+    from odps.errors import NoPermission
+
+    from maxc_cli.exceptions import PermissionDeniedError
+
+    class _DeniedInstance(_FakeInstance):
+        def get_task_results(self):
+            raise NoPermission("Access denied", request_id="show-partitions-request")
+
+    with pytest.raises(PermissionDeniedError) as caught:
+        _StubBackend()._instance_to_query_result(
+            _DeniedInstance(reader=None), project="test_project", max_rows=100,
+            sql="SHOW PARTITIONS t", elapsed_ms=1,
+        )
+    assert caught.value.error_code == "PERMISSION_DENIED"
+    assert caught.value.instance_id == _DeniedInstance.id
+    assert "show-partitions-request" in caught.value.suggestion