data-flow-control 0.1.0__tar.gz → 0.1.2__tar.gz

{data_flow_control-0.1.0 → data_flow_control-0.1.2}/Cargo.lock

@@ -1594,7 +1594,7 @@ dependencies = [
 
 [[package]]
 name = "passant-cli"
-version = "0.1.0"
+version = "0.1.2"
 dependencies = [
  "anyhow",
  "assert_cmd",
@@ -1606,7 +1606,7 @@ dependencies = [
 
 [[package]]
 name = "passant-core"
-version = "0.1.0"
+version = "0.1.2"
 dependencies = [
  "anyhow",
  "criterion",
@@ -1624,7 +1624,7 @@ dependencies = [
 
 [[package]]
 name = "passant-py"
-version = "0.1.0"
+version = "0.1.2"
 dependencies = [
  "passant-core",
  "pyo3",

{data_flow_control-0.1.0 → data_flow_control-0.1.2}/Cargo.toml

@@ -3,7 +3,7 @@ members = ["passant-core", "passant-py"]
 resolver = "2"
 
 [workspace.package]
-version = "0.1.0"
+version = "0.1.2"
 edition = "2024"
 license = "MIT"
 authors = ["Charlie Summers"]

data_flow_control-0.1.2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 dataflowcontrol
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

{data_flow_control-0.1.0 → data_flow_control-0.1.2}/PKG-INFO

@@ -1,12 +1,14 @@
 Metadata-Version: 2.4
 Name: data-flow-control
-Version: 0.1.0
+Version: 0.1.2
 Requires-Dist: boto3>=1.26.0
 Requires-Dist: duckdb>=1.3.0
+Requires-Dist: langchain>=1.3,<2
+Requires-Dist: langchain-core>=1.3,<2
 Requires-Dist: numpy>=1.24.4
 Requires-Dist: sqlglot==28.3.0
 Requires-Dist: clickhouse-connect>=0.7.0 ; extra == 'clickhouse'
-Requires-Dist: datafusion>=53.0.0 ; python_full_version >= '3.10' and extra == 'datafusion'
+Requires-Dist: datafusion>=53.0.0 ; extra == 'datafusion'
 Requires-Dist: pyarrow>=14.0.0 ; extra == 'datafusion'
 Requires-Dist: maturin>=1.7.0 ; extra == 'dev'
 Requires-Dist: pytest>=8.4.2 ; extra == 'dev'
@@ -16,5 +18,7 @@ Provides-Extra: clickhouse
 Provides-Extra: datafusion
 Provides-Extra: dev
 Provides-Extra: postgres
+License-File: LICENSE
 Summary: Rust-backed Data Flow Control rewrite engine
-Requires-Python: >=3.9
+License-Expression: MIT
+Requires-Python: >=3.10

{data_flow_control-0.1.0 → data_flow_control-0.1.2}/passant-core/src/rewrite_stats.rs

@@ -36,7 +36,7 @@ impl From<RewriteStats> for RewriteStatsExport {
     }
 }
 
-/// Optional rewrite instrumentation counters (see `passant/docs/performance.md`).
+/// Optional rewrite instrumentation counters (see `developer-docs/performance.md`).
 #[derive(Debug, Default, Clone)]
 pub struct RewriteStats {
     pub total_policies: usize,

{data_flow_control-0.1.0 → data_flow_control-0.1.2}/pyproject.toml

@@ -1,11 +1,15 @@
 [project]
 name = "data-flow-control"
-version = "0.1.0"
+version = "0.1.2"
 description = "Rust-backed Data Flow Control rewrite engine"
-requires-python = ">=3.9"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.10"
 dependencies = [
     "boto3>=1.26.0",
     "duckdb>=1.3.0",
+    "langchain>=1.3,<2",
+    "langchain-core>=1.3,<2",
     "numpy>=1.24.4",
     "sqlglot==28.3.0",
 ]
@@ -23,7 +27,7 @@ clickhouse = [
     "clickhouse-connect>=0.7.0",
 ]
 datafusion = [
-    "datafusion>=53.0.0; python_version >= '3.10'",
+    "datafusion>=53.0.0",
     "pyarrow>=14.0.0",
 ]
 
@@ -45,10 +49,16 @@ markers = [
     "postgres: requires psycopg and Passant docker postgres service",
     "clickhouse: requires clickhouse-connect and Passant docker clickhouse service",
     "umbra: requires psycopg and Passant docker umbra service",
-    "flock: optional Flock DuckDB extension tests (see passant/scripts/setup_flock.sh)",
+    "flock: optional Flock DuckDB extension tests (see scripts/setup_flock.sh)",
     "ui_extension: optional extended_duckdb UI stream union tests",
+    "langchain: LangChain tool-use integration tests",
 ]
 
+[tool.ruff.lint.per-file-ignores]
+"python/tests/test_langchain*.py" = ["E402"]
+"python/tests/test_call_tool_with_dataflow.py" = ["E402"]
+
 [tool.ruff]
 line-length = 100
-target-version = "py39"
+target-version = "py310"
+exclude = ["extended_duckdb"]

data_flow_control-0.1.2/python/data_flow_control/__init__.py

@@ -0,0 +1,31 @@
+from ._passant import PassantRewriteError
+from .connection import dfc
+from .dialect import Dialect
+from .options import RewriteOptions, UiUpdateMode
+from .policy import Policy, Resolution
+from .ui import UiViolationEvent
+
+__all__ = [
+    "create_agent",
+    "dfc",
+    "Dialect",
+    "langchain_dfc",
+    "Policy",
+    "Resolution",
+    "RewriteOptions",
+    "UiUpdateMode",
+    "PassantRewriteError",
+    "UiViolationEvent",
+]
+
+
+def __getattr__(name: str):
+    if name == "create_agent":
+        from .langchain import create_agent as _create_agent
+
+        return _create_agent
+    if name == "langchain_dfc":
+        from .langchain import langchain_dfc as _langchain_dfc
+
+        return _langchain_dfc
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

data_flow_control-0.1.2/python/data_flow_control/langchain/__init__.py

@@ -0,0 +1,8 @@
+"""LangChain integration for Passant data flow control."""
+
+from __future__ import annotations
+
+from .agent import create_agent, store_langchain_agent_config
+from .wrapper import LangChainDFC, langchain_dfc
+
+__all__ = ["LangChainDFC", "create_agent", "langchain_dfc", "store_langchain_agent_config"]

data_flow_control-0.1.2/python/data_flow_control/langchain/agent.py

@@ -0,0 +1,114 @@
+"""LangChain agent configuration for Passant wrapping."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+from langchain.agents import create_agent as _langchain_create_agent
+
+from .middleware import CALL_TOOL_WITH_DATAFLOW_NAME
+from .tool_spec import ToolSpec, tools_to_specs
+
+PASSANT_CONFIG_ATTR = "_passant_langchain_config"
+
+
+class UnsupportedAgentError(ValueError):
+    """Raised when an agent cannot be wrapped through public LangChain hooks."""
+
+
+@dataclass
+class AgentConfig:
+    model: Any
+    tools: list[Any]
+    middleware: list[Any] = field(default_factory=list)
+    system_prompt: str | None = None
+    create_agent_kwargs: dict[str, Any] = field(default_factory=dict)
+
+
+def create_agent(
+    model: Any,
+    tools: list[Any],
+    *,
+    middleware: list[Any] | None = None,
+    system_prompt: str | None = None,
+    **create_agent_kwargs: Any,
+) -> Any:
+    """Create a LangChain agent and attach Passant wrap configuration."""
+    agent = _langchain_create_agent(
+        model=model,
+        tools=tools,
+        middleware=tuple(middleware or ()),
+        system_prompt=system_prompt,
+        **create_agent_kwargs,
+    )
+    return store_langchain_agent_config(
+        agent,
+        model=model,
+        tools=tools,
+        middleware=middleware,
+        system_prompt=system_prompt,
+        **create_agent_kwargs,
+    )
+
+
+def store_langchain_agent_config(
+    agent: Any,
+    *,
+    model: Any,
+    tools: list[Any],
+    middleware: list[Any] | None = None,
+    system_prompt: str | None = None,
+    **create_agent_kwargs: Any,
+) -> Any:
+    """Attach Passant agent configuration using only public create_agent inputs."""
+    config = AgentConfig(
+        model=model,
+        tools=list(tools),
+        middleware=list(middleware or []),
+        system_prompt=system_prompt,
+        create_agent_kwargs=dict(create_agent_kwargs),
+    )
+    setattr(agent, PASSANT_CONFIG_ATTR, config)
+    return agent
+
+
+def resolve_agent_config(agent: Any) -> AgentConfig:
+    stored = getattr(agent, PASSANT_CONFIG_ATTR, None)
+    if stored is not None:
+        return stored
+
+    raise UnsupportedAgentError(
+        "Could not resolve LangChain agent configuration for the provided agent. "
+        "Create the agent with data_flow_control.langchain.create_agent(...), or call "
+        "store_langchain_agent_config(agent, model=..., tools=...) after create_agent(...). "
+        "Passant does not introspect private LangGraph state."
+    )
+
+
+def build_wrapped_agent(
+    config: AgentConfig,
+    *,
+    visible_tools: list[Any],
+    middleware: list[Any],
+) -> Any:
+    wrapped = _langchain_create_agent(
+        model=config.model,
+        tools=visible_tools,
+        system_prompt=config.system_prompt,
+        middleware=[*config.middleware, *middleware],
+        **config.create_agent_kwargs,
+    )
+    setattr(wrapped, PASSANT_CONFIG_ATTR, config)
+    return wrapped
+
+
+def specs_from_agent_tools(
+    tools: list[Any],
+    *,
+    output_schemas: dict[str, Any] | None,
+) -> list[ToolSpec]:
+    filtered = [
+        tool for tool in tools if getattr(tool, "name", None) != CALL_TOOL_WITH_DATAFLOW_NAME
+    ]
+    return tools_to_specs(filtered, output_schemas=output_schemas)

data_flow_control-0.1.2/python/data_flow_control/langchain/call_tool_with_dataflow.py

@@ -0,0 +1,160 @@
+"""CallToolWithDataFlow LangChain tool implementation."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+from typing import Any
+
+from langchain.tools import tool
+
+from .database import ToolUseDatabase
+from .middleware import CALL_TOOL_WITH_DATAFLOW_NAME
+from .sql_validation import validate_call_tool_sql
+
+
+class CallToolWithDataFlowRunner:
+    """Executes SQL over Passant tool tables and drains pending tool inputs."""
+
+    def __init__(self, db: ToolUseDatabase) -> None:
+        self.db = db
+
+    def _drain_new_rows(self, before: dict[str, set[int]]) -> list[dict[str, Any]]:
+        tool_outputs: list[dict[str, Any]] = []
+        new_rows = self.db.find_new_pending_rows(before)
+        with self.db._lock:
+            for tool_name, input_id in new_rows:
+                if not self.db.claim_input_row(tool_name, input_id):
+                    continue
+                status, _result, output_id = self.db.execute_tool_for_input(tool_name, input_id)
+                tool_outputs.append(
+                    {
+                        "tool": tool_name,
+                        "input_id": input_id,
+                        "status": status,
+                        "output_id": output_id,
+                    }
+                )
+        return tool_outputs
+
+    async def _adrain_new_rows(self, before: dict[str, set[int]]) -> list[dict[str, Any]]:
+        tool_outputs: list[dict[str, Any]] = []
+        new_rows = self.db.find_new_pending_rows(before)
+        if self.db._async_lock is None:
+            self.db._async_lock = asyncio.Lock()
+        async with self.db._async_lock:
+            for tool_name, input_id in new_rows:
+                if not self.db.claim_input_row(tool_name, input_id):
+                    continue
+                status, _result, output_id = await self.db.execute_tool_for_input_async(
+                    tool_name, input_id
+                )
+                tool_outputs.append(
+                    {
+                        "tool": tool_name,
+                        "input_id": input_id,
+                        "status": status,
+                        "output_id": output_id,
+                    }
+                )
+        return tool_outputs
+
+    def run(self, sql: str) -> str:
+        validated = validate_call_tool_sql(
+            sql,
+            allowed_input_tables=self.db.allowed_input_tables,
+            protected_tables=self.db.protected_tables,
+        )
+        sql_call_id = self.db._next_sql_call_id()
+        before = self.db.snapshot_pending_input_ids()
+        rows: list[list[Any]] = []
+        error: str | None = None
+        tool_outputs: list[dict[str, Any]] = []
+
+        try:
+            if validated.statement_type == "select":
+                result = self.db.conn.execute(validated.sql)
+                rows = [list(row) for row in result.fetchall()]
+            else:
+                self.db.conn.execute(validated.sql)
+
+            tool_outputs = self._drain_new_rows(before)
+        except Exception as exc:
+            error = str(exc)
+
+        self.db.log_sql_call(
+            sql_call_id=sql_call_id,
+            sql=validated.sql,
+            row_count_inserted=len(tool_outputs),
+            tool_calls_executed=len(tool_outputs),
+            error=error,
+        )
+
+        if error is not None:
+            raise RuntimeError(error)
+
+        payload = {
+            "sql_call_id": sql_call_id,
+            "statement_type": validated.statement_type,
+            "inserted_input_rows": len(tool_outputs),
+            "tool_calls_executed": len(tool_outputs),
+            "tool_outputs": tool_outputs,
+            "rows": rows,
+        }
+        return json.dumps(payload, default=str)
+
+    async def arun(self, sql: str) -> str:
+        validated = validate_call_tool_sql(
+            sql,
+            allowed_input_tables=self.db.allowed_input_tables,
+            protected_tables=self.db.protected_tables,
+        )
+        sql_call_id = self.db._next_sql_call_id()
+        before = self.db.snapshot_pending_input_ids()
+        rows: list[list[Any]] = []
+        error: str | None = None
+        tool_outputs: list[dict[str, Any]] = []
+
+        try:
+            if validated.statement_type == "select":
+                result = await asyncio.to_thread(self.db.conn.execute, validated.sql)
+                rows = [list(row) for row in result.fetchall()]
+            else:
+                await asyncio.to_thread(self.db.conn.execute, validated.sql)
+
+            tool_outputs = await self._adrain_new_rows(before)
+        except Exception as exc:
+            error = str(exc)
+
+        await asyncio.to_thread(
+            self.db.log_sql_call,
+            sql_call_id=sql_call_id,
+            sql=validated.sql,
+            row_count_inserted=len(tool_outputs),
+            tool_calls_executed=len(tool_outputs),
+            error=error,
+        )
+
+        if error is not None:
+            raise RuntimeError(error)
+
+        payload = {
+            "sql_call_id": sql_call_id,
+            "statement_type": validated.statement_type,
+            "inserted_input_rows": len(tool_outputs),
+            "tool_calls_executed": len(tool_outputs),
+            "tool_outputs": tool_outputs,
+            "rows": rows,
+        }
+        return json.dumps(payload, default=str)
+
+
+def build_call_tool_with_dataflow(db: ToolUseDatabase) -> Any:
+    runner = CallToolWithDataFlowRunner(db)
+
+    @tool(CALL_TOOL_WITH_DATAFLOW_NAME)
+    def call_tool_with_dataflow(sql: str) -> str:
+        """Execute SQL over Passant tool input/output tables and run inserted tool inputs."""
+        return runner.run(sql)
+
+    return call_tool_with_dataflow