langchain-timbr 2.1.11__tar.gz → 2.1.13__tar.gz

{langchain_timbr-2.1.11 → langchain_timbr-2.1.13}/.github/workflows/install-dependencies-and-run-tests.yml

@@ -9,6 +9,8 @@ on:
 env:
   TIMBR_URL: ${{ secrets.TIMBR_URL }}
   TIMBR_TOKEN: ${{ secrets.TIMBR_TOKEN }}
+  TIMBR_ONTOLOGY_NO_DTIMBR_PERMS: ${{ secrets.TIMBR_ONTOLOGY_NO_DTIMBR_PERMS }}
+  TIMBR_TOKEN_NO_DTIMBR_PERMS: ${{ secrets.TIMBR_TOKEN_NO_DTIMBR_PERMS }}
   LLM_TYPE: ${{ secrets.LLM_TYPE }}
   LLM_MODEL: ${{ secrets.LLM_MODEL }}
   LLM_API_KEY: ${{ secrets.LLM_API_KEY }}
@@ -20,6 +22,7 @@ env:
   JWT_PASSWORD: ${{ secrets.JWT_PASSWORD }}
   JWT_SCOPE: ${{ secrets.JWT_SCOPE }}
   JWT_SECRET: ${{ secrets.JWT_SECRET }}
+  LLM_TIMEOUT: ${{ secrets.LLM_TIMEOUT }}
 
 jobs:
   test-python-310:

{langchain_timbr-2.1.11 → langchain_timbr-2.1.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langchain-timbr
-Version: 2.1.11
+Version: 2.1.13
 Summary: LangChain & LangGraph extensions that parse LLM prompts into Timbr semantic SQL and execute them.
 Project-URL: Homepage, https://github.com/WPSemantix/langchain-timbr
 Project-URL: Documentation, https://docs.timbr.ai/doc/docs/integration/langchain-sdk/

{langchain_timbr-2.1.11 → langchain_timbr-2.1.13}/src/langchain_timbr/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '2.1.11'
-__version_tuple__ = version_tuple = (2, 1, 11)
+__version__ = version = '2.1.13'
+__version_tuple__ = version_tuple = (2, 1, 13)
 
 __commit_id__ = commit_id = None

{langchain_timbr-2.1.11 → langchain_timbr-2.1.13}/src/langchain_timbr/langgraph/execute_timbr_query_node.py

@@ -102,7 +102,7 @@ class ExecuteSemanticQueryNode:
 
     def run(self, state: StateGraph) -> dict:
         try:
-            prompt = state.messages[-1].content if state.messages[-1] else None
+            prompt = state.messages[-1].get('content') if state.messages[-1] and 'content' in state.messages[-1] else None
         except Exception:
             prompt = state.get('prompt', None)
 

{langchain_timbr-2.1.11 → langchain_timbr-2.1.13}/src/langchain_timbr/langgraph/generate_timbr_sql_node.py

@@ -94,7 +94,7 @@ class GenerateTimbrSqlNode:
 
     def run(self, state: StateGraph) -> dict:
         try:
-            prompt = state.messages[-1].content if (state.messages and state.messages[-1]) else None
+            prompt = state.messages[-1].get('content') if state.messages[-1] and 'content' in state.messages[-1] else None
         except Exception:
             prompt = state.get('prompt', None)
 

{langchain_timbr-2.1.11 → langchain_timbr-2.1.13}/src/langchain_timbr/langgraph/identify_concept_node.py

@@ -66,7 +66,7 @@ class IdentifyConceptNode:
 
     def run(self, state: StateGraph) -> dict:
         try:
-          prompt = state.messages[-1].content if state.messages[-1] else None
+          prompt = state.messages[-1].get('content') if state.messages[-1] and 'content' in state.messages[-1] else None
         except Exception:
           prompt = state.get('prompt', None)
 

{langchain_timbr-2.1.11 → langchain_timbr-2.1.13}/src/langchain_timbr/utils/timbr_llm_utils.py

@@ -304,7 +304,7 @@ def determine_concept(
 
         concepts_desc_arr.append(concept_verbose)
     
-    if len(concepts_and_views) == 1: # and not (concepts[0].lower() == 'none' or concepts[0].lower() == 'null'):
+    if len(concepts_and_views) == 1:
         # If only one concept is provided, return it directly
         determined_concept_name = list(concepts_and_views.keys())[0]
     else:
@@ -763,42 +763,67 @@ def generate_sql(
                 if reasoning_status == "correct":
                     break
                 
-                # Step 2: Regenerate SQL with feedback
+                # Step 2: Regenerate SQL with feedback (with validation retries)
                 evaluation_note = note + f"\n\nThe previously generated SQL: `{sql_query}` was assessed as '{evaluation.get('assessment')}' because: {evaluation.get('reasoning', '*could not determine cause*')}. Please provide a corrected SQL query that better answers the question: '{question}'."
                 
                 # Increase graph depth for 2nd+ reasoning attempts, up to max of 3
                 context_graph_depth = min(3, int(graph_depth) + step) if graph_depth < 3 and step > 0 else graph_depth
-                regen_result = _generate_sql_with_llm(
-                    question=question,
-                    llm=llm,
-                    conn_params=conn_params,
-                    generate_sql_prompt=generate_sql_prompt,
-                    current_context=_build_sql_generation_context(
-                        conn_params=conn_params,
-                        schema=schema,
-                        concept=concept,
-                        concept_metadata=concept_metadata,
-                        graph_depth=context_graph_depth,
-                        include_tags=include_tags,
-                        exclude_properties=exclude_properties,
-                        db_is_case_sensitive=db_is_case_sensitive,
-                        max_limit=max_limit),
-                    note=evaluation_note,
-                    should_validate_sql=should_validate_sql,
-                    timeout=timeout,
-                    debug=debug,
-                )
                 
-                usage_metadata[f'generate_sql_reasoning_step_{step + 1}'] = {
-                    "approximate": regen_result['apx_token_count'],
-                    **regen_result['usage_metadata'],
-                }
-                if debug and 'p_hash' in regen_result:
-                    usage_metadata[f'generate_sql_reasoning_step_{step + 1}']['p_hash'] = regen_result['p_hash']
+                # Regenerate SQL with validation retries
+                # Always validate during reasoning to ensure quality, regardless of global should_validate_sql flag
+                validation_iteration = 0
+                regen_is_valid = False
+                regen_error = ''
+                regen_sql = None
+                
+                while validation_iteration < retries and (regen_sql is None or not regen_is_valid):
+                    validation_iteration += 1
+                    validation_err_txt = f"\nThe regenerated SQL (`{regen_sql}`) was invalid with error: {regen_error}. Please generate a corrected query." if regen_error and "snowflake" not in llm._llm_type else ""
+                    
+                    regen_result = _generate_sql_with_llm(
+                        question=question,
+                        llm=llm,
+                        conn_params=conn_params,
+                        generate_sql_prompt=generate_sql_prompt,
+                        current_context=_build_sql_generation_context(
+                            conn_params=conn_params,
+                            schema=schema,
+                            concept=concept,
+                            concept_metadata=concept_metadata,
+                            graph_depth=context_graph_depth,
+                            include_tags=include_tags,
+                            exclude_properties=exclude_properties,
+                            db_is_case_sensitive=db_is_case_sensitive,
+                            max_limit=max_limit),
+                        note=evaluation_note + validation_err_txt,
+                        should_validate_sql=True,  # Always validate during reasoning
+                        timeout=timeout,
+                        debug=debug,
+                    )
+                    
+                    regen_sql = regen_result['sql']
+                    regen_is_valid = regen_result['is_valid']
+                    regen_error = regen_result['error']
+                    
+                    # Track token usage for each validation iteration
+                    if validation_iteration == 1:
+                        usage_metadata[f'generate_sql_reasoning_step_{step + 1}'] = {
+                            "approximate": regen_result['apx_token_count'],
+                            **regen_result['usage_metadata'],
+                        }
+                        if debug and 'p_hash' in regen_result:
+                            usage_metadata[f'generate_sql_reasoning_step_{step + 1}']['p_hash'] = regen_result['p_hash']
+                    else:
+                        usage_metadata[f'generate_sql_reasoning_step_{step + 1}_validation_{validation_iteration}'] = {
+                            "approximate": regen_result['apx_token_count'],
+                            **regen_result['usage_metadata'],
+                        }
+                        if debug and 'p_hash' in regen_result:
+                            usage_metadata[f'generate_sql_reasoning_step_{step + 1}_validation_{validation_iteration}']['p_hash'] = regen_result['p_hash']
                 
-                sql_query = regen_result['sql']
-                is_sql_valid = regen_result['is_valid']
-                error = regen_result['error']
+                sql_query = regen_sql
+                is_sql_valid = regen_is_valid
+                error = regen_error
                 
             except TimeoutError as e:
                 raise Exception(f"LLM call timed out: {str(e)}")

{langchain_timbr-2.1.11 → langchain_timbr-2.1.13}/src/langchain_timbr/utils/timbr_utils.py

@@ -241,24 +241,36 @@ def get_tags(conn_params: dict, include_tags: Optional[Any] = None) -> dict:
     }
 
 
-def _should_ignore_list(list: list) -> bool:
+def _should_ignore_list(list: list[Any] | None) -> bool:
     return bool(list and len(list) == 1 and (list[0].lower() in ['none', 'null']))
 
 
-def _should_select_all(list: list) -> bool:
+def _should_select_all(list: list[Any] | None) -> bool:
     return bool(list and len(list) == 1 and list[0] == '*')
 
 
+def _has_dtimbr_permissions(conn_params: dict) -> bool:
+    has_perms = True
+    dtimbr_query = "SHOW TABLES IN dtimbr"
+    try:
+        dtimbr_tables = run_query(dtimbr_query, conn_params)
+        has_perms = len(dtimbr_tables) > 0
+    except Exception:
+        has_perms = False
+
+    return has_perms
+
+
 @cache_with_version_check
 def get_concepts(
     conn_params,
-    concepts_list: Optional[list] = None,
-    views_list: Optional[list] = None,
+    concepts_list: Optional[list[Any]] = None,
+    views_list: Optional[list[Any]] = None,
     include_logic_concepts: Optional[bool] = False,
 ) -> dict:
     """Fetch concepts (or views) from timbr.sys_concepts and/or timbr.sys_views."""
     joined_views = ','.join(f"'{v}'" for v in views_list) if views_list else ''
-    should_ignore_concepts = _should_ignore_list(concepts_list)
+    should_ignore_concepts = _should_ignore_list(concepts_list) or not _has_dtimbr_permissions(conn_params)
     should_ignore_views = _should_ignore_list(views_list)
 
     filter_concepts = " WHERE concept IN (SELECT DISTINCT concept FROM timbr.sys_concept_properties)" if not include_logic_concepts else ""

{langchain_timbr-2.1.11 → langchain_timbr-2.1.13}/tests/conftest.py

@@ -13,6 +13,8 @@ def config():
         "timbr_url": os.environ.get("TIMBR_URL", "https://demo-env.timbr.ai"),
         "timbr_token": os.environ.get("TIMBR_TOKEN"),
         "timbr_ontology": os.environ.get("TIMBR_ONTOLOGY", "supply_metrics_llm_tests"),
+        "timbr_token_no_dtimbr_perms": os.environ.get("TIMBR_TOKEN_NO_DTIMBR_PERMS"),
+        "timbr_ontology_no_dtimbr_perms": os.environ.get("TIMBR_ONTOLOGY_NO_DTIMBR_PERMS", "timbr_calls"),
         "test_prompt": os.environ.get("TEST_PROMPT", "What are the total sales for consumer customers?"),
         "test_prompt_2": os.environ.get("TEST_PROMPT_2", "Get all customers"),
         "test_prompt_3": os.environ.get("TEST_PROMPT_3", "Get all products and materials"),

{langchain_timbr-2.1.11 → langchain_timbr-2.1.13}/tests/integration/test_langchain_chains.py

@@ -402,4 +402,17 @@ class TestGenerateAnswerChain:
         assert "answer" in result, "Chain should return an 'answer'"
         assert result["answer"], "Answer should not be empty"
         assert chain.usage_metadata_key in result, "Chain should return 'generate_answer_usage_metadata'"
-        assert len(result[chain.usage_metadata_key]) == 1 and 'answer_question' in result[chain.usage_metadata_key], "Generate answer chain usage metadata should contain only 'answer_question'"
+        assert len(result[chain.usage_metadata_key]) == 1 and 'answer_question' in result[chain.usage_metadata_key], "Generate answer chain usage metadata should contain only 'answer_question'"
+
+    def test_generate_timbr_sql_with_no_dtimbr_perms(self, llm, config):
+        """Test SQL generation with a user that lacks dtimbr schema permissions."""
+        chain = GenerateTimbrSqlChain(
+            llm=llm,
+            url=config["timbr_url"],
+            token=config["timbr_token_no_dtimbr_perms"],
+            ontology=config["timbr_ontology_no_dtimbr_perms"],
+            verify_ssl=config["verify_ssl"],
+        )
+        result = chain.invoke({ "prompt": "all calls" })
+        print("GenerateTimbrSqlChain with concepts_list=['plant'] result:", result)
+        assert "error" in result and "User doesn't have access to query Knowledge Graph schema: dtimbr" in result["error"], "Should return permission error message"

{langchain_timbr-2.1.11 → langchain_timbr-2.1.13}/tests/integration/test_langgraph_nodes.py

@@ -29,7 +29,7 @@ class TestLangGraphNodes:
         # Create a test state payload.
         state = {
             "prompt": config["test_prompt"],
-            "messages": [{ "content": config["test_prompt"] }],
+            # "messages": [{ "content": config["test_prompt"] }],
         }
         result = node(state)
         print("IdentifyConceptNode result:", result)
@@ -111,3 +111,24 @@ class TestLangGraphNodes:
         print("GenerateResponseNode result:", result)
         assert "answer" in result, "Result should contain 'answer'"
         assert result["answer"], "Answer should not be empty"
+
+    def test_execute_node_with_state_graph(self, llm, config):
+        """Test basic ExecuteSemanticQueryNode functionality."""
+        from langgraph.graph import StateGraph
+        state = StateGraph(dict)
+        state.messages = [{"content": config["test_prompt"]}]
+
+        execute_query_node = ExecuteSemanticQueryNode(
+            llm=llm,
+            url=config["timbr_url"],
+            token=config["timbr_token"],
+            ontology=config["timbr_ontology"],
+            verify_ssl=config["verify_ssl"],
+        )
+
+        output = execute_query_node(state)
+
+        print("ExecuteSemanticQueryNode result:", output)
+        assert "rows" in output, "Result should contain 'rows'"
+        assert isinstance(output["rows"], list), "'rows' should be a list"
+        assert output["sql"], "SQL should be present in the result"