satisfactoscript 1.0.0b4__tar.gz → 1.2.0__tar.gz

{satisfactoscript-1.0.0b4 → satisfactoscript-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: satisfactoscript
-Version: 1.0.0b4
+Version: 1.2.0
 Summary: Declarative data engineering framework — multi-platform (Databricks, Snowflake, BigQuery).
 Author-email: julhouba <houbartjulien80@gmail.com>
 License: MIT
@@ -16,7 +16,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Operating System :: OS Independent
-Classifier: Development Status :: 4 - Beta
+Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research
 Classifier: Topic :: Database
@@ -43,6 +43,9 @@ Requires-Dist: google-generativeai>=0.5.0; extra == "llm-google"
 Provides-Extra: semantic-pdf
 Requires-Dist: fpdf2>=2.7.0; extra == "semantic-pdf"
 Requires-Dist: matplotlib>=3.7.0; extra == "semantic-pdf"
+Provides-Extra: serving
+Requires-Dist: mlflow<3,>=2.12.0; extra == "serving"
+Requires-Dist: openai>=1.0.0; extra == "serving"
 Provides-Extra: semantic-full
 Requires-Dist: openai>=1.0.0; extra == "semantic-full"
 Requires-Dist: anthropic>=0.30.0; extra == "semantic-full"
@@ -54,7 +57,7 @@ Requires-Dist: pytest-cov>=4.0; extra == "dev"
 Requires-Dist: ruff>=0.1.0; extra == "dev"
 Requires-Dist: pytest-mock>=3.10.0; extra == "dev"
 
-# SatisfactoScript Framework (v1.0.0-beta.4)
+# SatisfactoScript Framework (v1.0.0)
 
 > **An Enterprise-Ready, Declarative Data Engineering Framework for Databricks Lakehouse.**
 

{satisfactoscript-1.0.0b4 → satisfactoscript-1.2.0}/README.md

@@ -1,4 +1,4 @@
-# SatisfactoScript Framework (v1.0.0-beta.4)
+# SatisfactoScript Framework (v1.0.0)
 
 > **An Enterprise-Ready, Declarative Data Engineering Framework for Databricks Lakehouse.**
 

{satisfactoscript-1.0.0b4 → satisfactoscript-1.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "satisfactoscript"
-version = "1.0.0-beta.4"
+version = "1.2.0"
 description = "Declarative data engineering framework — multi-platform (Databricks, Snowflake, BigQuery)."
 readme = "README.md"
 license = { text = "MIT" }
@@ -28,7 +28,7 @@ classifiers = [
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Operating System :: OS Independent",
-    "Development Status :: 4 - Beta",
+    "Development Status :: 5 - Production/Stable",
     "Intended Audience :: Developers",
     "Intended Audience :: Science/Research",
     "Topic :: Database",
@@ -74,6 +74,12 @@ semantic-pdf = [
     "matplotlib>=3.7.0"
 ]
 
+# --- Databricks Model Serving ---
+serving = [
+    "mlflow>=2.12.0,<3",
+    "openai>=1.0.0",
+]
+
 # --- Bundles pratiques ---
 semantic-full = [
     "openai>=1.0.0",

{satisfactoscript-1.0.0b4 → satisfactoscript-1.2.0}/src/satisfactoscript/__init__.py

@@ -1,7 +1,7 @@
 from .core.core import SatisfactoEngine
 from .core.registry import RuleRegistry
 from .core.config import ConfigurationManager
-from .utils import safe_columns, setup_notebook
+from .utils import safe_columns, setup_notebook, configure_logging
 from .core.schema_loader import load_schema, parse_schema
 from .core.rule_analyzer import RuleAnalyzer
 from .core.rule_planner import RulePlanner, RuleCycleError
@@ -16,6 +16,7 @@ __all__ = [
     "ConfigurationManager",
     "safe_columns",
     "setup_notebook",
+    "configure_logging",
     "load_schema",
     "parse_schema",
     "RuleAnalyzer",

{satisfactoscript-1.0.0b4 → satisfactoscript-1.2.0}/src/satisfactoscript/backends/snowpark.py

@@ -19,6 +19,9 @@ import logging
 from functools import reduce
 from typing import Any
 
+from satisfactoscript.backends.sql_base import ANTI_SEMI_JOIN_UNSUPPORTED_MSG
+from satisfactoscript.core.ir import _normalise_join_type
+
 logger = logging.getLogger(__name__)
 
 
@@ -368,6 +371,9 @@ class SnowparkBackend:
         return df.filter(condition)
 
     def join(self, left: Any, right: Any, on: Any, how: str = "left") -> Any:
+        join_type = _normalise_join_type(how)
+        if join_type in {"left_anti", "left_semi"}:
+            raise NotImplementedError(ANTI_SEMI_JOIN_UNSUPPORTED_MSG)
         return left.join(right, on=on, how=how)
 
     def drop_columns(self, df: Any, columns: list) -> Any:

{satisfactoscript-1.0.0b4 → satisfactoscript-1.2.0}/src/satisfactoscript/backends/sql_base.py

@@ -30,6 +30,11 @@ from typing import Any
 logger = logging.getLogger(__name__)
 
 _alias_counter = itertools.count(1)
+ANTI_SEMI_JOIN_UNSUPPORTED_MSG = (
+    "anti/semi join only supported on the Spark DataFrame backend so far "
+    "(see Plan 21)"
+)
+_UNSUPPORTED_SQL_JOIN_TYPES = {"LEFT ANTI", "LEFT SEMI"}
 
 
 def _next_alias() -> str:
@@ -342,6 +347,8 @@ class SQLQuery:
                 right_inner = right_q._base_to_sql()
                 on_sql = _build_join_on(self._alias, right_q._alias, on_cond)
                 jt = _normalise_join_type(how)
+                if jt in _UNSUPPORTED_SQL_JOIN_TYPES:
+                    raise NotImplementedError(ANTI_SEMI_JOIN_UNSUPPORTED_MSG)
                 parts.append(f"{jt} JOIN ({right_inner}) AS `{right_q._alias}`")
                 parts.append(f"  ON {on_sql}")
         else:
@@ -409,6 +416,10 @@ def _normalise_join_type(how: str) -> str:
     how = how.upper().replace("_", " ")
     if how in ("LEFT", "LEFT OUTER"):
         return "LEFT"
+    if how in ("ANTI", "LEFT ANTI"):
+        return "LEFT ANTI"
+    if how in ("SEMI", "LEFT SEMI"):
+        return "LEFT SEMI"
     if how in ("RIGHT", "RIGHT OUTER"):
         return "RIGHT"
     if how in ("INNER",):
@@ -639,14 +650,22 @@ class SQLBackend:
             inner_op_name = resolve_filter_operator(raw_op_name) or raw_op_name
             inner_val = parts[1] if len(parts) > 1 else None
             # Evaluate condition against c_expr directly (not via build_filter column lookup)
-            if inner_op_name == "is_not_null": return SQLCondition(f"{c_expr} IS NOT NULL")
-            if inner_op_name == "is_null": return SQLCondition(f"{c_expr} IS NULL")
-            if inner_op_name == "contains": return SQLCondition(f"{c_expr} LIKE '%{_sql_escape(str(inner_val))}%'")
-            if inner_op_name == "not_contains": return SQLCondition(f"{c_expr} NOT LIKE '%{_sql_escape(str(inner_val))}%'")
-            if inner_op_name == "starts_with": return SQLCondition(f"{c_expr} LIKE '{_sql_escape(str(inner_val))}%'")
-            if inner_op_name == "ends_with": return SQLCondition(f"{c_expr} LIKE '%{_sql_escape(str(inner_val))}'")
-            if inner_op_name == "like": return SQLCondition(f"{c_expr} LIKE '{_sql_escape(str(inner_val))}'")
-            if inner_op_name == "not_like": return SQLCondition(f"{c_expr} NOT LIKE '{_sql_escape(str(inner_val))}'")
+            if inner_op_name == "is_not_null":
+                return SQLCondition(f"{c_expr} IS NOT NULL")
+            if inner_op_name == "is_null":
+                return SQLCondition(f"{c_expr} IS NULL")
+            if inner_op_name == "contains":
+                return SQLCondition(f"{c_expr} LIKE '%{_sql_escape(str(inner_val))}%'")
+            if inner_op_name == "not_contains":
+                return SQLCondition(f"{c_expr} NOT LIKE '%{_sql_escape(str(inner_val))}%'")
+            if inner_op_name == "starts_with":
+                return SQLCondition(f"{c_expr} LIKE '{_sql_escape(str(inner_val))}%'")
+            if inner_op_name == "ends_with":
+                return SQLCondition(f"{c_expr} LIKE '%{_sql_escape(str(inner_val))}'")
+            if inner_op_name == "like":
+                return SQLCondition(f"{c_expr} LIKE '{_sql_escape(str(inner_val))}'")
+            if inner_op_name == "not_like":
+                return SQLCondition(f"{c_expr} NOT LIKE '{_sql_escape(str(inner_val))}'")
             _comp_sym = {"equals": "=", "not_equals": "!=", "greater_than": ">",
                          "less_than": "<", "greater_than_equal": ">=", "less_than_equal": "<="}
             if inner_op_name in _comp_sym:
@@ -675,6 +694,7 @@ class SQLBackend:
             "trim":      lambda: SQLColumn(f"TRIM({c_expr})"),
             "round":     lambda: SQLColumn(f"ROUND({c_expr}, {op.args[0]})"),
             "abs":       lambda: SQLColumn(f"ABS({c_expr})"),
+            "ceil":      lambda: SQLColumn(f"CEIL({c_expr})"),
             "length":    lambda: SQLColumn(f"LENGTH({c_expr})"),
             "to_date":   lambda: SQLColumn(f"PARSE_DATE('{op.args[0]}', {c_expr})"),
             "split":     lambda: SQLColumn(f"SPLIT({c_expr}, '{op.args[0]}')[ORDINAL({int(op.args[1]) + 1})]"),
@@ -702,22 +722,42 @@ class SQLBackend:
         val = f.value
         c_expr = self._q(col_name)
 
-        if op == "is_not_null": return SQLCondition(f"{c_expr} IS NOT NULL")
-        if op == "is_null": return SQLCondition(f"{c_expr} IS NULL")
+        if op == "is_not_null":
+            return SQLCondition(f"{c_expr} IS NOT NULL")
+        if op == "is_null":
+            return SQLCondition(f"{c_expr} IS NULL")
         if op in ("in", "not_in"):
             lst = val if isinstance(val, list) else [v.strip() for v in str(val).replace(";", ",").split(",")]
             vals_str = ", ".join(_smart_val(v) for v in lst)
             return SQLCondition(f"{c_expr} {'NOT ' if op == 'not_in' else ''}IN ({vals_str})")
-        if op == "contains": return SQLCondition(f"{c_expr} LIKE '%{_sql_escape(str(val))}%'")
-        if op == "not_contains": return SQLCondition(f"{c_expr} NOT LIKE '%{_sql_escape(str(val))}%'")
-        if op == "starts_with": return SQLCondition(f"{c_expr} LIKE '{_sql_escape(str(val))}%'")
-        if op == "ends_with": return SQLCondition(f"{c_expr} LIKE '%{_sql_escape(str(val))}'")
-        if op == "like": return SQLCondition(f"{c_expr} LIKE '{_sql_escape(str(val))}'")
-        if op == "not_like": return SQLCondition(f"{c_expr} NOT LIKE '{_sql_escape(str(val))}'")
+        if op == "contains":
+            return SQLCondition(f"{c_expr} LIKE '%{_sql_escape(str(val))}%'")
+        if op == "not_contains":
+            return SQLCondition(f"{c_expr} NOT LIKE '%{_sql_escape(str(val))}%'")
+        if op == "starts_with":
+            return SQLCondition(f"{c_expr} LIKE '{_sql_escape(str(val))}%'")
+        if op == "ends_with":
+            return SQLCondition(f"{c_expr} LIKE '%{_sql_escape(str(val))}'")
+        if op == "like":
+            return SQLCondition(f"{c_expr} LIKE '{_sql_escape(str(val))}'")
+        if op == "not_like":
+            return SQLCondition(f"{c_expr} NOT LIKE '{_sql_escape(str(val))}'")
         if op == "sql":
             if not allow_raw_sql:
                 raise ValueError("[Governance] sql: filter disabled (allow_raw_sql: false).")
             return SQLCondition(val)
+        if op == "between":
+            parts = [v.strip() for v in str(val).split(",")]
+            if len(parts) != 2:
+                raise ValueError(f"between filter on column '{col_name}' expects exactly 2 values.")
+            lo, hi = parts
+            return SQLCondition(f"({c_expr} >= {_smart_val(lo)} AND {c_expr} <= {_smart_val(hi)})")
+        if op == "not_between":
+            parts = [v.strip() for v in str(val).split(",")]
+            if len(parts) != 2:
+                raise ValueError(f"not_between filter on column '{col_name}' expects exactly 2 values.")
+            lo, hi = parts
+            return SQLCondition(f"({c_expr} < {_smart_val(lo)} OR {c_expr} > {_smart_val(hi)})")
         _comp = {"equals": "=", "not_equals": "!=", "greater_than": ">",
                  "less_than": "<", "greater_than_equal": ">=", "less_than_equal": "<="}
         if op in _comp:
@@ -893,4 +933,4 @@ class SQLBackend:
 
     def optimize_table(self, fqn: str, zorder_cols: list[str] | None = None) -> None:
         """Default no-op. Override in subclasses for platform-specific optimisation."""
-        print(f"   [SQLBackend] optimize_table: no-op for {fqn}")
+        print(f"   [SQLBackend] optimize_table: no-op for {fqn}")

{satisfactoscript-1.0.0b4 → satisfactoscript-1.2.0}/src/satisfactoscript/cli.py

@@ -117,7 +117,6 @@ def _run_hub(args: argparse.Namespace) -> None:
     """Boucle REPL principale du SatisfactoHub."""
     try:
         from rich.console import Console
-        from rich.table import Table as RichTable
     except ImportError:
         print("[ERROR] Le module 'rich' est requis pour le hub. Installez-le avec : pip install rich")
         sys.exit(1)
@@ -175,7 +174,7 @@ def _run_hub(args: argparse.Namespace) -> None:
 
     if not args.new_session and len(session) > 0:
         ts = session.created_at.strftime("%Y-%m-%d") if hasattr(session.created_at, "strftime") else str(session.created_at)
-        console.print(f"  [1] Nouvelle session  (efface la session précédente)")
+        console.print("  [1] Nouvelle session  (efface la session précédente)")
         console.print(f"  [2] Reprendre la session du {ts} ({len(session)} messages)\n")
         try:
             choice = input("Choix [1/2] : ").strip()
@@ -255,8 +254,8 @@ def _run_hub(args: argparse.Namespace) -> None:
         session.save(scope_id)
 
 
-def _render_response(console: "Console", response: object) -> None:  # type: ignore[name-defined]
-    """Affiche la réponse dans le terminal selon son type."""
+def _render_response(console: object, response: object) -> None:
+    """Render a HubResponse in the terminal with Rich formatting."""
     from .agentic.models import (
         AgentResponse,
         BuilderResponse,
@@ -264,6 +263,7 @@ def _render_response(console: "Console", response: object) -> None:  # type: ign
         LineageResponse,
         QualityResponse,
     )
+    from .serving._response_serializer import hub_response_to_text
 
     if isinstance(response, AgentResponse):
         if response.mode == "error":
@@ -271,27 +271,12 @@ def _render_response(console: "Console", response: object) -> None:  # type: ign
         elif response.mode in ("ambiguous", "needs_clarification"):
             console.print(f"[yellow]{response.clarification_question or response.explanation}[/yellow]")
         else:
-            _render_agent_response(console, response)
+            _render_agent_response_rich(console, response)
 
-    elif isinstance(response, LineageResponse):
-        if response.error:
-            console.print(f"[red]{response.error}[/red]")
-        elif response.diagram:
-            console.print(response.diagram)
-        else:
-            console.print(response.narrative or f"Lignage ({response.mode}) — colonne : {response.column}")
-
-    elif isinstance(response, QualityResponse):
-        if response.error:
-            console.print(f"[red]{response.error}[/red]")
-        else:
-            console.print(response.text_output or response.narrative or "Checks exécutés.")
-
-    elif isinstance(response, DictionaryResponse):
-        if response.error:
-            console.print(f"[red]{response.error}[/red]")
-        else:
-            console.print(response.text_output or response.narrative or f"Champ : {response.column}")
+    elif isinstance(response, (LineageResponse, QualityResponse, DictionaryResponse)):
+        text = hub_response_to_text(response)
+        style = "red" if getattr(response, "error", None) else ""
+        console.print(f"[{style}]{text}[/{style}]" if style else text)
 
     elif isinstance(response, BuilderResponse):
         if not response.success:
@@ -305,8 +290,8 @@ def _render_response(console: "Console", response: object) -> None:  # type: ign
         console.print(str(response))
 
 
-def _render_agent_response(console: "Console", response: object) -> None:  # type: ignore[name-defined]
-    """Affiche un AgentResponse en mode query selon le format du résultat."""
+def _render_agent_response_rich(console: object, response: object) -> None:
+    """Render an AgentResponse with Rich formatting (tables, colours)."""
     try:
         from rich.table import Table as RichTable
         from .agentic.models import ResponseFormat
@@ -324,7 +309,6 @@ def _render_agent_response(console: "Console", response: object) -> None:  # typ
             console.print(f"  {result.kpi_label or ''}: [green]{result.kpi_value}[/green]")
 
         elif fmt == ResponseFormat.TABLE:
-            # Essayer d'afficher via rich.Table si le DataFrame est disponible
             data_df = getattr(result, "data", None)
             if data_df is not None:
                 try:

{satisfactoscript-1.0.0b4 → satisfactoscript-1.2.0}/src/satisfactoscript/core/interpreter.py

@@ -15,6 +15,7 @@ import logging
 from functools import reduce
 from typing import TYPE_CHECKING, Any
 
+from satisfactoscript.core.ir import _normalise_join_type
 from satisfactoscript.core.registry import RuleRegistry
 from satisfactoscript.core.sandbox import SandboxResolver
 from satisfactoscript.core.rule_analyzer import RuleAnalyzer
@@ -26,6 +27,8 @@ if TYPE_CHECKING:
 
 logger = logging.getLogger(__name__)
 
+_LEFT_ONLY_JOIN_TYPES = {"left_anti", "left_semi"}
+
 
 class SchemaInterpreter:
     """
@@ -340,7 +343,7 @@ class SchemaInterpreter:
 
                 on_l = key_l if isinstance(key_l, list) else [key_l]
                 on_r = key_r if isinstance(key_r, list) else [key_r]
-                join_type = j.get("type", "left")
+                join_type = _normalise_join_type(j.get("type", "left"))
 
                 logger.info("    -> [Join] %s JOIN %s(%s) -> %s(%s)", join_type.upper(), alias_l, on_l, alias_r, on_r)
                 df_to = dfs[alias_r]
@@ -350,7 +353,8 @@ class SchemaInterpreter:
                 else:
                     cond = reduce(lambda x, y: x & y, [df_main[lk] == df_to[rk] for lk, rk in zip(on_l, on_r)])
                     df_main = b.join(df_main, df_to, cond, join_type)
-                    df_main = b.drop_columns(df_main, [df_to[r] for r in on_r])
+                    if join_type not in _LEFT_ONLY_JOIN_TYPES:
+                        df_main = b.drop_columns(df_main, [df_to[r] for r in on_r])
 
         # 3. BUSINESS RULES
         if "business_rules" in schema_dict:

{satisfactoscript-1.0.0b4 → satisfactoscript-1.2.0}/src/satisfactoscript/core/ir.py

@@ -11,6 +11,29 @@ from __future__ import annotations
 from dataclasses import dataclass, field
 from typing import Any
 
+VALID_JOIN_TYPES: frozenset[str] = frozenset(
+    {"left", "right", "inner", "full", "cross", "left_anti", "left_semi"}
+)
+
+_JOIN_TYPE_ALIASES: dict[str, str] = {
+    "left outer": "left",
+    "right outer": "right",
+    "outer": "full",
+    "full outer": "full",
+    "full_outer": "full",
+    "anti": "left_anti",
+    "left anti": "left_anti",
+    "leftanti": "left_anti",
+    "semi": "left_semi",
+    "left semi": "left_semi",
+    "leftsemi": "left_semi",
+}
+
+
+def _normalise_join_type(raw: str) -> str:
+    key = raw.strip().lower().replace("-", " ")
+    return _JOIN_TYPE_ALIASES.get(key, key)
+
 
 # ---------------------------------------------------------------------------
 # Leaf types
@@ -180,12 +203,19 @@ def parse_to_ir(schema_dict: dict) -> ParsedSchema:
         else:
             alias_r = table_to
             key_r = j.get("on_to")
+        raw_type = j.get("type", "left")
+        join_type = _normalise_join_type(raw_type)
+        if join_type not in VALID_JOIN_TYPES:
+            raise ValueError(
+                f"Invalid join type {raw_type!r} for join {alias_l!r} → {alias_r!r}. "
+                f"Valid types: {', '.join(sorted(VALID_JOIN_TYPES))}"
+            )
         joins.append(ParsedJoin(
             alias_left=alias_l,
             keys_left=key_l if isinstance(key_l, list) else [key_l],
             alias_right=alias_r,
             keys_right=key_r if isinstance(key_r, list) else [key_r],
-            join_type=j.get("type", "left"),
+            join_type=join_type,
         ))
 
     # --- select_final / add_columns ---

{satisfactoscript-1.0.0b4 → satisfactoscript-1.2.0}/src/satisfactoscript/core/op_catalog.py

@@ -32,7 +32,7 @@ class OperatorSpec:
     """
     ``"none"``    — operator takes no value (``is_null``, ``is_not_null``)
     ``"single"``  — operator takes one scalar value
-    ``"list"``    — operator takes a comma-separated / YAML-list value (``in``, ``not_in``)
+    ``"list"``    — operator takes a comma-separated / YAML-list value (``in``, ``not_in``, ``between``, ``not_between``)
     ``"sql"``     — operator takes a raw SQL expression (``sql``)
     """
 
@@ -49,7 +49,7 @@ class OpSpec:
 
     arity: str = "none"
     """
-    ``"none"``        — no argument  (``upper``, ``lower``, ``trim``, ``abs``, ``length``)
+    ``"none"``        — no argument  (``upper``, ``lower``, ``trim``, ``abs``, ``length``, ``ceil``)
     ``"single"``      — one argument after ``:``  (``cast:``, ``lit:``, ``round:``, …)
     ``"two"``         — two comma-separated arguments (``split:sep,idx``, ``substring:start,len``)
     ``"expression"``  — raw SQL expression (``expr:``)
@@ -125,6 +125,16 @@ FILTER_OPERATORS: dict[str, OperatorSpec] = {
         arity="list",
         description="Passes rows where column value is in the provided list.",
     ),
+    "between": OperatorSpec(
+        canonical="between",
+        arity="list",
+        description="Passes rows where lo <= column <= hi (inclusive). Two comma-separated values.",
+    ),
+    "not_between": OperatorSpec(
+        canonical="not_between",
+        arity="list",
+        description="Passes rows where column is strictly outside the provided [lo, hi] interval.",
+    ),
     "not_in": OperatorSpec(
         canonical="not_in",
         arity="list",
@@ -189,6 +199,7 @@ COLUMN_OPS: dict[str, OpSpec] = {
     # ---- numeric ----
     "round": OpSpec("round", arity="single", description="Round to N decimal places."),
     "abs": OpSpec("abs", arity="none", description="Absolute value."),
+    "ceil": OpSpec("ceil", arity="none", description="Round up to nearest integer."),
     # ---- date ----
     "to_date": OpSpec("to_date", arity="single", description="Parse string to date using the given format."),
     # ---- null handling ----