mammoth-cli 2.2.23__tar.gz → 2.2.25__tar.gz

{mammoth_cli-2.2.23 → mammoth_cli-2.2.25}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mammoth-cli
-Version: 2.2.23
+Version: 2.2.25
 Summary: Command-line interface for the Mammoth Analytics platform
 Project-URL: homepage, https://mammoth.io
 Project-URL: repository, https://github.com/EdgeMetric/mammothsdk

{mammoth_cli-2.2.23 → mammoth_cli-2.2.25}/mammoth_cli/__init__.py

@@ -6,7 +6,7 @@ not implement a second HTTP client and does not call private SDK members.
 
 from __future__ import annotations
 
-__version__ = "2.2.23"
+__version__ = "2.2.25"
 
 # The versioned machine output envelope contract.
 SCHEMA_VERSION = 1

{mammoth_cli-2.2.23 → mammoth_cli-2.2.25}/mammoth_cli/bundled_skill/mammoth-cli/references/about-mammoth.md

@@ -143,7 +143,12 @@ No command:
   existing dataset with `view export dataset` (`target_ds_id` and
   `save_as_mode` `APPEND_TO_DS`). An append is a standing link: it is stored
   as a pipeline step of the source view, so every later re-run of that view
-  appends again into the target dataset, not just the first run. To stack
+  appends again into the target dataset, not just the first run. A column
+  with the same name but a different type in the source view and the target
+  dataset (say `date` as text against `date` as date) would land in a
+  separate column, so the export is refused with `append_type_mismatch`
+  before anything is written; `view transform convert-type` on the source
+  view aligns the type. To stack
   rows into a brand-new dataset instead of an existing one, omit
   `target_ds_id`. A row present in both sources lands twice: note the
   appended view's `row_count` (`view get`) and its `duplicates` fact

{mammoth_cli-2.2.23 → mammoth_cli-2.2.25}/mammoth_cli/commands/view.py

@@ -3719,8 +3719,8 @@ def _existing_internal_dataset_export(
 _DATASET_GET_SYMBOL = "mammoth.api.datasets.DatasetsAPI.get"
 
 
-def _target_dataset_schema_names(service: Any, target_ds_id: int) -> set[str]:
-    """The target dataset's own schema column display names.
+def _target_dataset_schema(service: Any, target_ds_id: int) -> dict[str, str]:
+    """The target dataset's own schema: column display name -> type ('' if absent).
 
     ``dataset.get``'s ``data_schema`` is the dataset's base schema, not any
     view's live/rendered columns -- a view's own rename task can show a
@@ -3744,7 +3744,7 @@ def _target_dataset_schema_names(service: Any, target_ds_id: int) -> set[str]:
             hint="Read the target dataset before appending to it.",
             details={"side": "target", "dataset_id": target_ds_id},
         )
-    names: set[str] = set()
+    names: dict[str, str] = {}
     for column in data_schema:
         display_name = column.get("c_name") if isinstance(column, dict) else None
         if not isinstance(display_name, str):
@@ -3754,10 +3754,51 @@ def _target_dataset_schema_names(service: Any, target_ds_id: int) -> set[str]:
                 hint="Read the target dataset before appending to it.",
                 details={"side": "target", "dataset_id": target_ds_id},
             )
-        names.add(display_name)
+        names[display_name] = str(column.get("c_type") or "")
     return names
 
 
+def _reject_append_type_mismatch(
+    source_types: Any,
+    target_schema: dict[str, str],
+    mapping: dict[str, str],
+    ids: tuple[int, int],
+) -> None:
+    """Refuse an append where a column both sides name has a different type.
+
+    The backend does not coerce: a same-named column of another type lands in
+    a separate new column, splitting the data. Columns only on one side, or
+    renamed through ``column_mapping``, are not compared; an unknown type
+    (empty) on either side is not a mismatch.
+    """
+    if not isinstance(source_types, dict):
+        return
+    mismatched = {
+        name: (str(source_types[name]).lower(), target_schema[name].lower())
+        for name in sorted(source_types.keys() & target_schema.keys() - set(mapping))
+        if source_types[name]
+        and target_schema[name]
+        and str(source_types[name]).lower() != target_schema[name].lower()
+    }
+    if not mismatched:
+        return
+    view_id, target_ds_id = ids
+    listed = "; ".join(f"{n}: source {src}, target {tgt}" for n, (src, tgt) in mismatched.items())
+    raise CliError(
+        code="append_type_mismatch",
+        message=(
+            f"View {view_id} has column(s) whose type differs from target dataset "
+            f"{target_ds_id}: {listed}. An append would create separate columns."
+        ),
+        exit_status=EXIT_USAGE,
+        hint=(
+            f"Run mammoth view transform convert-type on view {view_id} so each column "
+            "matches the target type, then retry the export."
+        ),
+        details={"mismatched": {n: {"source": s, "target": t} for n, (s, t) in mismatched.items()}},
+    )
+
+
 def _reject_append_schema_mismatch(
     service: Any,
     dataview_id: int,
@@ -3785,7 +3826,8 @@ def _reject_append_schema_mismatch(
             hint="Read the source view before appending from it.",
             details={"side": "source", "dataview_id": dataview_id},
         )
-    target_names = _target_dataset_schema_names(service, target_ds_id)
+    target_schema = _target_dataset_schema(service, target_ds_id)
+    target_names = set(target_schema)
     mapping = column_mapping if isinstance(column_mapping, dict) else {}
     # View.columns (mammoth/view.py) maps display name -> internal name; these
     # dict keys are display names, matching what the backend's own schema
@@ -3793,6 +3835,12 @@ def _reject_append_schema_mismatch(
     source_names = set(source_columns)
     source_only = sorted(source_names - target_names - set(mapping))
     target_only = sorted(target_names - source_names - set(mapping.values()))
+    _reject_append_type_mismatch(
+        service.call_view(dataview_id, "column_types", dataset_id=dataset_id),
+        target_schema,
+        mapping,
+        (dataview_id, target_ds_id),
+    )
     if source_only:
         raise CliError(
             code="append_schema_mismatch",

{mammoth_cli-2.2.23 → mammoth_cli-2.2.25}/mammoth_cli/errors/envelope.py

@@ -78,6 +78,7 @@ ERROR_SUMMARIES: dict[str, str] = {
     ),
     "api_error": "Mammoth couldn't complete this step.",
     "append_schema_mismatch": "The new data doesn't line up with the existing columns.",
+    "append_type_mismatch": "A column has a different type than in the existing data.",
     "append_schema_unreadable": "The columns of the existing data couldn't be read.",
     "authentication_failed": "Mammoth didn't accept the sign-in for this step.",
     "authorization_required": "You don't have permission to do this.",

{mammoth_cli-2.2.23 → mammoth_cli-2.2.25}/mammoth_cli/services/data_quality.py

@@ -217,13 +217,26 @@ def _renamed_label_warning(
     }
 
 
-def _duplicate_count(rows: list[Mapping[str, Any]]) -> int:
-    """How many of ``rows`` are exact copies of an earlier row."""
+_DUPLICATE_SAMPLE_LIMIT = 5
+
+
+def _duplicate_summary(rows: list[Mapping[str, Any]]) -> tuple[int, list[dict[str, Any]]]:
+    """Return (rows that copy an earlier row, up to 5 sample duplicated rows).
+
+    A sample is the row's values as read plus how many times it occurs.
+    """
     counts: dict[str, int] = {}
+    first_seen: dict[str, Mapping[str, Any]] = {}
     for row in rows:
         fingerprint = json.dumps(row, sort_keys=True, default=str)
         counts[fingerprint] = counts.get(fingerprint, 0) + 1
-    return sum(count - 1 for count in counts.values() if count > 1)
+        first_seen.setdefault(fingerprint, row)
+    repeated = [fp for fp, count in counts.items() if count > 1]
+    samples = [
+        {"row": dict(first_seen[fp]), "occurrences": counts[fp]}
+        for fp in repeated[:_DUPLICATE_SAMPLE_LIMIT]
+    ]
+    return sum(counts[fp] - 1 for fp in repeated), samples
 
 
 def duplicate_rows_fact(
@@ -245,19 +258,24 @@ def duplicate_rows_fact(
     if not materialised:
         return None
     checked = len(materialised)
-    duplicates = _duplicate_count(materialised)
+    duplicates, samples = _duplicate_summary(materialised)
     if whole_view:
-        return {
+        whole: dict[str, Any] = {
             "exact_duplicate_rows": duplicates,
             "rows_checked": checked,
             "row_count": checked,
             "scope": "every row of the view",
         }
+        if samples:
+            whole["duplicate_samples"] = samples
+        return whole
     fact: dict[str, Any] = {
         "exact_duplicate_rows_in_page": duplicates,
         "rows_checked": checked,
         "scope": "this page only",
     }
+    if samples:
+        fact["duplicate_samples"] = samples
     if view_id is not None and dataset_id is not None:
         spec = json.dumps({"dataset_id": dataset_id})
         fact["table_wide_check"] = (
@@ -278,7 +296,7 @@ def _duplicate_rows_warning(
     table-wide duplication without separately checking the full table (e.g.
     ``view data aggregate`` COUNT vs a distinct count).
     """
-    duplicate_count = _duplicate_count(rows)
+    duplicate_count, samples = _duplicate_summary(rows)
     if not duplicate_count:
         return None
     warning: dict[str, Any] = {
@@ -288,6 +306,7 @@ def _duplicate_rows_warning(
             "of another row in this page (not checked table-wide)."
         ),
         "rows_checked": len(rows),
+        "duplicate_samples": samples,
     }
     if view_id is not None and dataset_id is not None:
         spec = json.dumps({"dataset_id": dataset_id})

{mammoth_cli-2.2.23 → mammoth_cli-2.2.25}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mammoth-cli"
-version = "2.2.23"
+version = "2.2.25"
 description = "Command-line interface for the Mammoth Analytics platform"
 authors = [{name = "Mammoth Analytics", email = "support@mammoth.io"}]
 readme = "README.md"