inputlayer-client-dev 0.1.0.dev919__tar.gz → 0.1.0.dev924__tar.gz

{inputlayer_client_dev-0.1.0.dev919 → inputlayer_client_dev-0.1.0.dev924}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: inputlayer-client-dev
-Version: 0.1.0.dev919
+Version: 0.1.0.dev924
 Summary: Python Object-Logic Mapper for InputLayer knowledge graph engine
 License-Expression: Apache-2.0
 License-File: LICENSE

{inputlayer_client_dev-0.1.0.dev919 → inputlayer_client_dev-0.1.0.dev924}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "inputlayer-client-dev"
-version = "0.1.0.dev919"
+version = "0.1.0.dev924"
 description = "Python Object-Logic Mapper for InputLayer knowledge graph engine"
 readme = "README.md"
 license = "Apache-2.0"

{inputlayer_client_dev-0.1.0.dev919 → inputlayer_client_dev-0.1.0.dev924}/src/inputlayer/compiler.py

@@ -666,6 +666,17 @@ def compile_rule(
         else:
             head_parts.append(column_to_variable(col))
 
+    # Compile filter conditions BEFORE building body atoms, so every column
+    # the condition references is registered in the env and gets bound to a
+    # variable in its atom. Compiling them after produced atoms with `_` for
+    # condition-only columns while the condition referenced an unbound
+    # variable - which the engine accepts and silently satisfies, deriving
+    # wrong results (e.g. a tier == "gold" filter matching every row).
+    cond_parts: list[str] = []
+    if condition:
+        cond_parts = compile_bool_expr(condition, env)
+        cond_parts = [p for p in cond_parts if p]
+
     # Build body atoms
     body_atoms: list[str] = []
     for rn, cls, alias in body_relations:
@@ -680,12 +691,6 @@ def compile_rule(
                 atom_parts.append("_")
         body_atoms.append(f"{rn}({', '.join(atom_parts)})")
 
-    # Compile filter conditions
-    cond_parts: list[str] = []
-    if condition:
-        cond_parts = compile_bool_expr(condition, env)
-        cond_parts = [p for p in cond_parts if p]
-
     all_body = body_atoms + cond_parts
     prefix = "+" if persistent else ""
     head_str = f"{prefix}{head_name}({', '.join(head_parts)})"

{inputlayer_client_dev-0.1.0.dev919 → inputlayer_client_dev-0.1.0.dev924}/src/inputlayer/knowledge_graph.py

@@ -963,11 +963,22 @@ class KnowledgeGraph:
         )
 
     async def load(self, path: str, *, mode: str | None = None) -> None:
-        """Load data from a file."""
-        cmd = f".load {path}"
-        if mode:
-            cmd += f" {mode}"
-        await self._execute(cmd)
+        """Load an IQL file into this knowledge graph.
+
+        The file is read locally and sent to the server as a single
+        multi-statement program, so the load is atomic: the server parses
+        every statement before executing any, and rejects the whole
+        program on the first error.
+
+        (Sending ``.load`` over the wire does not work: the server treats
+        it as a client-only REPL command and silently ignores it.)
+        """
+        if mode is not None:
+            msg = "load(mode=...) is not supported; --replace/--merge are unimplemented server-side"
+            raise NotImplementedError(msg)
+        with open(path, encoding="utf-8") as f:
+            program = f.read()
+        await self._execute(program)
 
     async def clear_prefix(self, prefix: str) -> ClearResult:
         """Clear all relations matching a prefix."""

{inputlayer_client_dev-0.1.0.dev919 → inputlayer_client_dev-0.1.0.dev924}/tests/test_compiler.py

@@ -494,6 +494,25 @@ class TestCompileRule:
         )
         assert "+high_earner(Id, Name)" in result
         assert "Salary > 100000" in result
+        # The condition column must be BOUND in the body atom. Emitting
+        # employee(Id, Name, _, _, _) alongside `Salary > 100000` leaves
+        # Salary unbound - the engine accepts that and silently satisfies
+        # the comparison, deriving wrong results.
+        assert "employee(Id, Name, _, Salary, _)" in result
+
+    def test_condition_only_column_is_bound(self):
+        # Regression: a column referenced ONLY by the where-condition (not
+        # selected into the head) must still be bound in its atom.
+        cond = Comparison("=", AstColumn("employee", "department"), Literal("eng"))
+        result = compile_rule(
+            "eng_member",
+            ["name"],
+            {"name": AstColumn("employee", "name")},
+            [(Employee._resolve_name(), Employee, None)],
+            condition=cond,
+            persistent=True,
+        )
+        assert result == '+eng_member(Name) <- employee(_, Name, Department, _, _), Department = "eng"'
 
     def test_recursive(self):
         # reachable(Src, Dst) <- reachable(Src, Mid), edge(Mid, Dst)

inputlayer_client_dev-0.1.0.dev924/tests/test_kg_load.py

@@ -0,0 +1,51 @@
+"""Tests for KnowledgeGraph.load: local file read, sent as one atomic program."""
+
+from __future__ import annotations
+
+from unittest.mock import AsyncMock
+
+import pytest
+
+from inputlayer.knowledge_graph import KnowledgeGraph
+
+
+def _kg_with_mocked_execute() -> KnowledgeGraph:
+    kg = KnowledgeGraph.__new__(KnowledgeGraph)
+    kg._execute = AsyncMock()  # type: ignore[method-assign]
+    return kg
+
+
+class TestLoad:
+    async def test_sends_file_contents_as_one_program(self, tmp_path) -> None:
+        pack = tmp_path / "pack.iql"
+        pack.write_text(
+            "// a comment the server strips\n"
+            '+claim(id: string, val: string)\n'
+            '+claim[("c1", "v1")]\n'
+        )
+
+        kg = _kg_with_mocked_execute()
+        await kg.load(str(pack))
+
+        kg._execute.assert_awaited_once()
+        program = kg._execute.await_args.args[0]
+        # The whole file goes over in a single execute, comments included
+        # (the server strips them), never as a `.load` meta command.
+        assert '+claim[("c1", "v1")]' in program
+        assert "// a comment" in program
+        assert not program.lstrip().startswith(".load")
+
+    async def test_mode_is_rejected(self, tmp_path) -> None:
+        pack = tmp_path / "pack.iql"
+        pack.write_text("+r(x: string)\n")
+
+        kg = _kg_with_mocked_execute()
+        with pytest.raises(NotImplementedError):
+            await kg.load(str(pack), mode="--replace")
+        kg._execute.assert_not_awaited()
+
+    async def test_missing_file_raises(self) -> None:
+        kg = _kg_with_mocked_execute()
+        with pytest.raises(FileNotFoundError):
+            await kg.load("/nonexistent/pack.iql")
+        kg._execute.assert_not_awaited()