satisfactoscript 1.0.0__tar.gz → 1.1.0__tar.gz

{satisfactoscript-1.0.0 → satisfactoscript-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: satisfactoscript
-Version: 1.0.0
+Version: 1.1.0
 Summary: Declarative data engineering framework — multi-platform (Databricks, Snowflake, BigQuery).
 Author-email: julhouba <houbartjulien80@gmail.com>
 License: MIT
@@ -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"

{satisfactoscript-1.0.0 → satisfactoscript-1.1.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "satisfactoscript"
-version = "1.0.0"
+version = "1.1.0"
 description = "Declarative data engineering framework — multi-platform (Databricks, Snowflake, BigQuery)."
 readme = "README.md"
 license = { text = "MIT" }
@@ -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.0 → satisfactoscript-1.1.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.0 → satisfactoscript-1.1.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
@@ -340,7 +341,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]

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

@@ -11,6 +11,21 @@ from __future__ import annotations
 from dataclasses import dataclass, field
 from typing import Any
 
+VALID_JOIN_TYPES: frozenset[str] = frozenset({"left", "right", "inner", "full", "cross"})
+
+_JOIN_TYPE_ALIASES: dict[str, str] = {
+    "left outer": "left",
+    "right outer": "right",
+    "outer": "full",
+    "full outer": "full",
+    "full_outer": "full",
+}
+
+
+def _normalise_join_type(raw: str) -> str:
+    key = raw.strip().lower().replace("-", " ")
+    return _JOIN_TYPE_ALIASES.get(key, key)
+
 
 # ---------------------------------------------------------------------------
 # Leaf types
@@ -180,12 +195,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.0 → satisfactoscript-1.1.0}/src/satisfactoscript/semantic/llm_provider.py

@@ -261,6 +261,103 @@ class GoogleProvider(LLMProvider):
         return response.text
 
 
+# ---------------------------------------------------------------------------
+# Databricks Foundation Models
+# ---------------------------------------------------------------------------
+
+class DatabricksProvider(LLMProvider):
+    """
+    LLM provider for Databricks Foundation Models API (OpenAI-compatible).
+
+    The Databricks Foundation Models API is OpenAI-compatible and is exposed at
+    ``{DATABRICKS_HOST}/serving-endpoints``. This provider wraps the OpenAI client
+    with the correct base_url and uses a Databricks PAT as the API key.
+
+    Configuration via environment variables:
+        DATABRICKS_HOST       — workspace URL (e.g. https://adb-xxx.azuredatabricks.net)
+        DATABRICKS_TOKEN      — personal access token or service principal secret
+        DATABRICKS_LLM_MODEL  — serving endpoint name (default: databricks-dbrx-instruct)
+    """
+
+    def __init__(
+        self,
+        host: str | None = None,
+        token: str | None = None,
+        model: str | None = None,
+        **kwargs: Any,
+    ) -> None:
+        try:
+            import openai as _openai
+        except ImportError as exc:
+            raise ImportError(
+                "[LLMProvider] 'openai' is required for DatabricksProvider. "
+                "Install it with: pip install openai"
+            ) from exc
+
+        resolved_host = host or os.environ.get("DATABRICKS_HOST", "")
+        resolved_token = token or os.environ.get("DATABRICKS_TOKEN", "")
+
+        if not resolved_host:
+            raise ValueError(
+                "[DatabricksProvider] DATABRICKS_HOST is not set. "
+                "Set it to your workspace URL (e.g. https://adb-xxx.azuredatabricks.net)."
+            )
+        if not resolved_token:
+            raise ValueError(
+                "[DatabricksProvider] DATABRICKS_TOKEN is not set. "
+                "Set it to a personal access token or service principal secret."
+            )
+
+        base_url = resolved_host.rstrip("/") + "/serving-endpoints"
+        self._client = _openai.OpenAI(
+            api_key=resolved_token,
+            base_url=base_url,
+        )
+        self._model = model or os.environ.get(
+            "DATABRICKS_LLM_MODEL", "databricks-dbrx-instruct"
+        )
+
+    @property
+    def provider_name(self) -> str:
+        return "databricks"
+
+    def complete(
+        self,
+        system_prompt: str,
+        user_message: str,
+        temperature: float = 0.0,
+        response_format: dict | None = None,
+        **kwargs: Any,
+    ) -> str:
+        return self.complete_with_history(
+            system_prompt=system_prompt,
+            history=[{"role": "user", "content": user_message}],
+            temperature=temperature,
+            response_format=response_format,
+            **kwargs,
+        )
+
+    def complete_with_history(
+        self,
+        system_prompt: str,
+        history: list[dict],
+        temperature: float = 0.0,
+        response_format: dict | None = None,
+        **kwargs: Any,
+    ) -> str:
+        call_kwargs: dict[str, Any] = {
+            "model": kwargs.pop("model", self._model),
+            "messages": [{"role": "system", "content": system_prompt}] + history,
+            "temperature": temperature,
+        }
+        if response_format:
+            call_kwargs["response_format"] = response_format
+        call_kwargs.update(kwargs)
+
+        response = self._client.chat.completions.create(**call_kwargs)
+        return response.choices[0].message.content
+
+
 # ---------------------------------------------------------------------------
 # Factory
 # ---------------------------------------------------------------------------
@@ -269,6 +366,7 @@ _PROVIDER_MAP = {
     "openai": OpenAIProvider,
     "anthropic": AnthropicProvider,
     "google": GoogleProvider,
+    "databricks": DatabricksProvider,
 }
 
 
@@ -283,8 +381,9 @@ def get_llm_provider(
       1. Argument ``provider`` explicite.
       2. Variable d'environnement ``LLM_PROVIDER``.
       3. Auto-détection depuis les clés API présentes dans l'environnement
-         (OPENAI_API_KEY → openai, ANTHROPIC_API_KEY → anthropic, GOOGLE_API_KEY → google).
-      4. Fallback sur ``openai``.
+         (DATABRICKS_HOST+DATABRICKS_TOKEN → databricks, ANTHROPIC_API_KEY → anthropic,
+         OPENAI_API_KEY → openai, GOOGLE_API_KEY → google).
+      4. Erreur si aucune clé détectée.
 
     Args:
         provider: Nom du provider parmi {'openai', 'anthropic', 'google'}.
@@ -314,6 +413,8 @@ def get_llm_provider(
 
 def _auto_detect_provider() -> str:
     """Détecte le provider depuis les clés API présentes dans l'environnement."""
+    if os.environ.get("DATABRICKS_HOST") and os.environ.get("DATABRICKS_TOKEN"):
+        return "databricks"
     if os.environ.get("ANTHROPIC_API_KEY"):
         return "anthropic"
     if os.environ.get("OPENAI_API_KEY"):
@@ -322,6 +423,6 @@ def _auto_detect_provider() -> str:
         return "google"
     raise ValueError(
         "[LLMProvider] Aucune clé API détectée. "
-        "Définissez ANTHROPIC_API_KEY, OPENAI_API_KEY ou GOOGLE_API_KEY "
-        "dans votre .env ou passez provider= explicitement."
+        "Définissez DATABRICKS_HOST+DATABRICKS_TOKEN, ANTHROPIC_API_KEY, "
+        "OPENAI_API_KEY ou GOOGLE_API_KEY dans votre .env ou passez provider= explicitement."
     )

satisfactoscript-1.1.0/src/satisfactoscript/serving/__init__.py

@@ -0,0 +1,20 @@
+"""
+satisfactoscript.serving — MLflow ChatModel serving layer.
+
+Exposes AgenticHub as an OpenAI-compatible REST endpoint on Databricks Model Serving.
+
+Public exports:
+    SatisfactoChatModel  — mlflow.pyfunc.ChatModel wrapping AgenticHub
+    hub_response_to_text — convert any HubResponse to a plain text string
+"""
+
+from ._response_serializer import hub_response_to_text
+
+__all__ = ["SatisfactoChatModel", "hub_response_to_text"]
+
+
+def __getattr__(name: str):  # noqa: N807
+    if name == "SatisfactoChatModel":
+        from .chat_model import SatisfactoChatModel  # noqa: PLC0415
+        return SatisfactoChatModel
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

satisfactoscript-1.1.0/src/satisfactoscript/serving/_response_serializer.py

@@ -0,0 +1,96 @@
+"""
+hub_response_to_text — converts any HubResponse to a plain text string.
+
+Shared by the CLI renderer and the MLflow serving layer so serialization
+logic is not duplicated.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def hub_response_to_text(response: Any) -> str:
+    """
+    Convert any HubResponse dataclass to a plain text string.
+
+    Handles AgentResponse, LineageResponse, QualityResponse,
+    DictionaryResponse, and BuilderResponse. Falls back to str() for
+    any unrecognised type.
+    """
+    from satisfactoscript.agentic.models import (
+        AgentResponse,
+        BuilderResponse,
+        DictionaryResponse,
+        LineageResponse,
+        QualityResponse,
+    )
+
+    if isinstance(response, AgentResponse):
+        return _serialize_agent_response(response)
+
+    if isinstance(response, LineageResponse):
+        if response.error:
+            return f"Error: {response.error}"
+        return response.diagram or response.narrative or f"Lineage ({response.mode}) — column: {response.column}"
+
+    if isinstance(response, QualityResponse):
+        if response.error:
+            return f"Error: {response.error}"
+        return response.text_output or response.narrative or "Quality checks executed."
+
+    if isinstance(response, DictionaryResponse):
+        if response.error:
+            return f"Error: {response.error}"
+        return response.text_output or response.narrative or f"Field: {response.column}"
+
+    if isinstance(response, BuilderResponse):
+        if not response.success:
+            return f"Error: {response.error}"
+        parts = [response.yaml_content]
+        if response.output_path:
+            parts.append(f"Saved to: {response.output_path}")
+        return "\n".join(parts)
+
+    return str(response)
+
+
+def _serialize_agent_response(response: Any) -> str:
+    """Serialize an AgentResponse to plain text."""
+    from satisfactoscript.agentic.models import ResponseFormat
+
+    if response.mode == "error":
+        return f"Error: {response.error}"
+
+    if response.mode in ("ambiguous", "needs_clarification"):
+        return response.clarification_question or response.explanation or "Clarification needed."
+
+    result = getattr(response, "result", None)
+    if result is None:
+        return response.explanation or "Response received."
+
+    fmt = getattr(result, "format", None)
+    title = getattr(result, "title", "")
+
+    if fmt == ResponseFormat.KPI:
+        label = result.kpi_label or title or response.explanation or "Value"
+        return f"{label}: {result.kpi_value}"
+
+    if fmt == ResponseFormat.TABLE:
+        data = getattr(result, "data", None)
+        if data is not None:
+            try:
+                rows = data.limit(20).collect()
+                cols = data.columns
+                lines = [title] if title else []
+                lines.append(" | ".join(cols))
+                lines.append("-" * (len(" | ".join(cols))))
+                for row in rows:
+                    lines.append(" | ".join(str(v) for v in row))
+                return "\n".join(lines)
+            except Exception:
+                pass
+        return title or "No data."
+
+    text = getattr(result, "text_summary", None) or response.explanation
+    return text or "Response received."

satisfactoscript-1.1.0/src/satisfactoscript/serving/chat_model.py

@@ -0,0 +1,122 @@
+"""
+SatisfactoChatModel — MLflow ChatModel wrapping AgenticHub.
+
+Exposes AgenticHub.ask() as an OpenAI-compatible /chat/completions endpoint
+on Databricks Model Serving. load_context() is called once at pod startup;
+predict() handles each inbound request.
+
+Expected artifacts at log time:
+    "config"     — path to config.yaml
+    "models_dir" — path to the semantic models directory
+
+Expected environment variables at serving time:
+    DATABRICKS_HOST   — workspace URL
+    DATABRICKS_TOKEN  — PAT or service principal secret
+    DATABRICKS_LLM_MODEL — Foundation Model endpoint name (optional)
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+class SatisfactoChatModel:
+    """
+    MLflow pyfunc ChatModel that delegates to AgenticHub.
+
+    Lazily imports mlflow so the class can be imported in environments
+    where mlflow is not installed (e.g. during unit tests that mock it).
+    """
+
+    def load_context(self, context: Any) -> None:
+        """
+        Called once when the serving endpoint pod starts.
+
+        Initialises SparkSession, ConfigurationManager, SatisfactoEngine,
+        SemanticEngine, DatabricksLLMProvider, and AgenticHub. All heavy
+        dependencies are imported here so the module itself stays importable
+        without them installed.
+        """
+        from pyspark.sql import SparkSession
+
+        from satisfactoscript.agentic.hub import AgenticHub
+        from satisfactoscript.core.config import ConfigurationManager
+        from satisfactoscript.core.core import SatisfactoEngine
+        from satisfactoscript.semantic.llm_provider import get_llm_provider
+        from satisfactoscript.semantic.semantic import SemanticEngine
+
+        artifacts = getattr(context, "artifacts", {}) or {}
+        config_path = artifacts.get("config", "config.yaml")
+        models_dir = artifacts.get("models_dir", "semantic")
+
+        spark = SparkSession.builder.getOrCreate()
+        config_mgr = ConfigurationManager(config_path=config_path)
+        engine = SatisfactoEngine(spark, config_manager=config_mgr)
+        semantic = SemanticEngine(engine, models_dir=models_dir)
+        llm = get_llm_provider("databricks")
+
+        self._hub = AgenticHub(semantic_engine=semantic, llm_provider=llm)
+        logger.info("SatisfactoChatModel: AgenticHub initialised.")
+
+    def predict(
+        self,
+        context: Any,
+        messages: list[dict[str, Any]],
+        params: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        """
+        Handle a single chat completion request.
+
+        Extracts the last user message from the OpenAI-format messages list,
+        calls hub.ask(), and returns an OpenAI-compatible response dict.
+        """
+        from satisfactoscript.serving._response_serializer import hub_response_to_text
+
+        question = _extract_last_user_message(messages)
+        response = self._hub.ask(question)
+        text = hub_response_to_text(response)
+
+        return {
+            "choices": [
+                {
+                    "index": 0,
+                    "message": {"role": "assistant", "content": text},
+                    "finish_reason": "stop",
+                }
+            ]
+        }
+
+
+def _extract_last_user_message(messages: list[dict[str, Any]]) -> str:
+    """
+    Return the content of the last message with role='user'.
+
+    Raises ValueError if no user message is found.
+    """
+    for msg in reversed(messages):
+        if isinstance(msg, dict) and msg.get("role") == "user":
+            return str(msg.get("content", ""))
+    raise ValueError(
+        "SatisfactoChatModel.predict(): no message with role='user' found in messages."
+    )
+
+
+def _build_mlflow_model() -> "SatisfactoChatModel":  # noqa: F821
+    """
+    Return a SatisfactoChatModel instance registered as an mlflow.pyfunc.ChatModel.
+
+    Registers the mlflow.pyfunc flavour so the returned object can be passed
+    directly to mlflow.pyfunc.log_model(python_model=...).
+
+    This is a factory rather than direct inheritance because mlflow is an
+    optional dependency — we avoid a top-level mlflow import.
+    """
+    import mlflow
+
+    class _Registered(SatisfactoChatModel, mlflow.pyfunc.ChatModel):
+        pass
+
+    return _Registered()

{satisfactoscript-1.0.0 → satisfactoscript-1.1.0}/src/satisfactoscript.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: satisfactoscript
-Version: 1.0.0
+Version: 1.1.0
 Summary: Declarative data engineering framework — multi-platform (Databricks, Snowflake, BigQuery).
 Author-email: julhouba <houbartjulien80@gmail.com>
 License: MIT
@@ -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"

{satisfactoscript-1.0.0 → satisfactoscript-1.1.0}/src/satisfactoscript.egg-info/SOURCES.txt

@@ -68,6 +68,9 @@ src/satisfactoscript/semantic/glossary.py
 src/satisfactoscript/semantic/llm_provider.py
 src/satisfactoscript/semantic/semantic.py
 src/satisfactoscript/semantic/validator.py
+src/satisfactoscript/serving/__init__.py
+src/satisfactoscript/serving/_response_serializer.py
+src/satisfactoscript/serving/chat_model.py
 src/satisfactoscript/sinks/__init__.py
 src/satisfactoscript/sinks/jdbc.py
 tests/test_agent.py
@@ -115,6 +118,8 @@ tests/test_sandbox.py
 tests/test_schema_loader.py
 tests/test_semantic_builder.py
 tests/test_semantic_engine_catalog.py
+tests/test_serving_chat_model.py
+tests/test_serving_response_serializer.py
 tests/test_sink_jdbc.py
 tests/test_user_profile.py
 tests/test_utils_logging.py

{satisfactoscript-1.0.0 → satisfactoscript-1.1.0}/src/satisfactoscript.egg-info/requires.txt

@@ -30,6 +30,10 @@ matplotlib>=3.7.0
 fpdf2>=2.7.0
 matplotlib>=3.7.0
 
+[serving]
+mlflow<3,>=2.12.0
+openai>=1.0.0
+
 [snowflake]
 snowflake-snowpark-python>=1.0.0
 

{satisfactoscript-1.0.0 → satisfactoscript-1.1.0}/tests/test_backend_sql_base.py

@@ -226,6 +226,14 @@ class TestSQLQuery:
         assert "LEFT JOIN" in sql
         assert "cust_id" in sql
 
+    def test_join_full_outer(self):
+        left = SQLQuery("`orders`")
+        right = SQLQuery("`customers`")
+        left._joins.append(("full", right, ["customer_id"]))
+        sql = left.to_sql()
+        assert "FULL OUTER JOIN" in sql
+        assert "customer_id" in sql
+
     def test_qualify(self):
         q = SQLQuery("`orders`")
         q._qualify = "ROW_NUMBER() OVER (PARTITION BY `id` ORDER BY 1) = 1"

{satisfactoscript-1.0.0 → satisfactoscript-1.1.0}/tests/test_core_join.py

@@ -154,3 +154,36 @@ class TestProcessSchemaJoin:
         # drop must receive both right-side key refs
         joined.drop.assert_called_once_with(df_b["org_r"], df_b["date_r"])
         df_b.columns.assert_not_called()
+
+    def test_full_outer_join_same_keys(self):
+        """type: full → join(..., how='full') with list-join path."""
+        df_a = MagicMock(name="df_a")
+        df_b = MagicMock(name="df_b")
+        df_a.join.return_value = _joined_df()
+
+        schema = {
+            "join": [{"table_from": "a", "table_to": "b", "on_from": "id", "on_to": "id", "type": "full"}]
+        }
+
+        engine = _make_engine()
+        engine.process_schema(schema, dataframes_in={"a": df_a, "b": df_b})
+
+        df_a.join.assert_called_once_with(df_b, on=["id"], how="full")
+
+    def test_full_outer_join_different_keys(self):
+        """type: full outer (alias) → expression join, right key dropped."""
+        df_a = MagicMock(name="df_a")
+        df_b = MagicMock(name="df_b")
+        joined = _joined_df()
+        df_a.join.return_value = joined
+
+        schema = {
+            "join": [{"table_from": "a", "table_to": "b", "on_from": "order_id", "on_to": "id", "type": "full outer"}]
+        }
+
+        engine = _make_engine()
+        engine.process_schema(schema, dataframes_in={"a": df_a, "b": df_b})
+
+        _, join_kwargs = df_a.join.call_args
+        assert join_kwargs.get("how") == "full"
+        joined.drop.assert_called_once_with(df_b["id"])