langchain-timbr 1.5.0__py3-none-any.whl

langchain_timbr/utils/timbr_utils.py

@@ -0,0 +1,475 @@
+from typing import Optional, Any
+import time
+from pytimbr_api import timbr_http_connector
+from functools import wraps
+
+from ..config import cache_timeout, ignore_tags, ignore_tags_prefix
+from .general import to_boolean
+
+# Cache dictionary
+_cache = {}
+_ontology_version = None
+_last_version_check = 0
+
+def clear_cache():
+    """Clear the cache and reset the ontology version."""
+    global _cache, _ontology_version
+    # with cache_lock:
+    _cache.clear()
+    _ontology_version = None
+
+
+def _get_ontology_version(conn_params) -> str:
+    """Fetch the current ontology version."""
+    query = "SHOW VERSION"
+    res = run_query(query, conn_params)
+    return res[0].get("id") if res else "unknown"
+
+
+def _serialize_cache_key(*args, **kwargs):
+    """Serialize arguments into a hashable cache key."""
+    def serialize(obj):
+        if isinstance(obj, dict):
+            return tuple(sorted((k, serialize(v)) for k, v in obj.items()))
+        elif isinstance(obj, list):
+            return tuple(serialize(x) for x in obj)
+        elif isinstance(obj, (str, int, float, bool, type(None))):
+            return obj
+        raise TypeError(f"Unsupported type for caching: {type(obj)}")
+
+    return (tuple(serialize(arg) for arg in args), tuple((k, serialize(v)) for k, v in kwargs.items()))
+
+
+def cache_with_version_check(func):
+    """Decorator to cache function results and invalidate if ontology version changes."""
+
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        global _ontology_version, _last_version_check
+
+        now = time.time()
+        if (now - _last_version_check) > cache_timeout:
+            conn_params = kwargs.get("conn_params") or args[-1]
+            current_version = _get_ontology_version(conn_params)
+
+            # If version changed, clear cache and set new version
+            if _ontology_version != current_version:
+                clear_cache()
+                _ontology_version = current_version
+
+            _last_version_check = now
+        
+        # Generate a cache key based on function name and arguments
+        cache_key = (func.__name__, _serialize_cache_key(*args, **kwargs))
+        if cache_key not in _cache or not _cache[cache_key]:
+            # Call the function and store the result in the cache
+            _cache[cache_key] = func(*args, **kwargs)
+
+        return _cache[cache_key]
+
+    return wrapper
+
+
+def run_query(sql: str, conn_params: dict, llm_prompt: Optional[str] = None) -> list[list]:
+    if not conn_params:
+        raise("Please provide connection params.")
+
+    query = sql
+    if llm_prompt:
+        clean_prompt = llm_prompt.replace('\r\n', ' ').replace('\n', ' ').replace('?', '')
+        query = f"-- LLM: {clean_prompt}\n{sql}"
+
+    results = timbr_http_connector.run_query(
+        query=query,
+        **conn_params,
+    )
+
+    return results
+
+
+def get_ontologies(conn_params: dict) -> list[str]:
+    query = "SELECT ontology FROM timbr.sys_ontologies"
+    res = run_query(query, conn_params)
+    return [row.get('ontology') for row in res]
+
+
+def get_datasources(conn_params: dict, filter_active: Optional[bool] = False) -> list[dict]:
+    query = "SHOW DATASOURCES"
+    res = run_query(query, conn_params)
+    if filter_active:
+        res = [row for row in res if to_boolean(row.get('is_active'))]
+    
+    return res
+
+
+def validate_sql(sql: str, conn_params: dict) -> tuple[bool, str]:
+    if not sql:
+        raise Exception("Please provide SQL to validate.")
+    
+    explain_res = None
+    query_res = None
+    error = None
+
+    try:
+        explain_sql = f"EXPLAIN {sql}"
+        explain_res = run_query(explain_sql, conn_params)
+        
+        query_sql = f"SELECT * FROM ({sql.replace(';', '')}) explainable_query WHERE 1=0"
+        query_res = run_query(query_sql, conn_params)
+    except Exception as e:
+        error = str(getattr(e, 'doc', e))
+
+    return to_boolean(explain_res and explain_res[0].get('PLAN') and query_res is not None), error
+
+
+def _should_ignore_tag(tag_name: str) -> bool:
+    if not tag_name:
+        return True
+    
+    tag_name_lower = tag_name.lower()
+    if tag_name_lower in ignore_tags:
+        return True
+    
+    for prefix in ignore_tags_prefix:
+        if tag_name_lower.startswith(prefix.lower()):
+            return True
+            
+    return False
+
+
+def _prepare_tags_dict(
+    type: Optional[str] = 'concept',
+    tags_list: Optional[list] = [],
+    include_tags: Optional[str] = '',
+) -> dict:
+    tags_dict = {}
+    if not include_tags:
+        return tags_dict # currently empty
+    
+    for tag in tags_list:
+        # Make sure that the tag is of the correct type
+        if type != tag.get('target_type'):
+            continue
+
+        tag_name = tag.get('tag_name')
+
+        # Check if the tag is included
+        if (include_tags != '*' and tag_name not in include_tags) or _should_ignore_tag(tag_name):
+            continue
+        
+        key = tag.get('target_name')
+        tag_value = tag.get('tag_value')
+
+        if key not in tags_dict:
+            tags_dict[key] = {}
+        
+        tags_dict[key][tag_name] = tag_value
+        
+    return tags_dict
+
+
+@cache_with_version_check
+def get_tags(conn_params: dict, include_tags: Optional[Any] = None) -> dict:
+    if not to_boolean(include_tags):
+        return {
+            "concept_tags": {},
+            "view_tags": {},
+            "property_tags": {},
+            # "relationship_tags": {},
+        }
+
+    query = "SHOW TAGS"
+    ontology_tags = run_query(query, conn_params)
+
+    return {
+        "concept_tags": _prepare_tags_dict('concept', ontology_tags, include_tags),
+        "view_tags": _prepare_tags_dict('ontology view', ontology_tags, include_tags),
+        "property_tags": _prepare_tags_dict('property', ontology_tags, include_tags),
+        # "relationship_tags": _prepare_tags_dict('relationship', ontology_tags, include_tags),
+    }
+
+
+def _should_ignore_list(list: list) -> bool:
+    return bool(list and len(list) == 1 and (list[0] == 'none' or list[0] == 'null'))
+
+
+def _should_select_all(list: list) -> bool:
+    return list and len(list) == 1 and list[0] == '*'
+
+
+@cache_with_version_check
+def get_concepts(
+    conn_params,
+    concepts_list: Optional[list] = None,
+    views_list: Optional[list] = 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_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 ""
+    if concepts_list:
+        if should_ignore_concepts:
+            filter_concepts = " WHERE 1 = 0"
+        elif _should_select_all(concepts_list):
+            filter_concepts = ""
+        else:
+            joined_concepts = ','.join(f"'{c}'" for c in concepts_list) if concepts_list else ''
+            filter_concepts = f" WHERE concept IN ({joined_concepts})" if concepts_list else ""
+
+    filter_views = f" WHERE view_name IN ({joined_views})" if views_list else ""
+    if should_ignore_views:
+        filter_views = " WHERE 1 = 0"
+    elif _should_select_all(views_list):
+        filter_views = ""
+
+    # if there is concepts_list and not views - filter only concepts
+    # if there is views_list and not concepts - filter only views
+    # if there is both or none - union the two tables
+    if concepts_list and not should_ignore_concepts and not views_list:
+        # Only fetch concepts
+        query = f"""
+            SELECT concept, description, 'false' AS is_view 
+            FROM timbr.sys_concepts{filter_concepts}
+            ORDER BY is_view ASC
+        """.strip()
+    elif views_list and not should_ignore_views and not concepts_list:
+        # Only fetch views
+        query = f"""
+            SELECT view_name AS concept, description, 'true' AS is_view
+            FROM timbr.sys_views{filter_views}
+            ORDER BY is_view ASC
+        """.strip()
+    else:
+        # Both or neither => union the two tables (existing logic)
+        query = f"""
+            SELECT * FROM (
+                SELECT concept, description, 'false' AS is_view 
+                FROM timbr.sys_concepts{filter_concepts}
+                UNION ALL
+                SELECT view_name AS concept, description, 'true' AS is_view 
+                FROM timbr.sys_views{filter_views}
+            ) AS combined
+            ORDER BY is_view ASC
+        """.strip()
+
+    res = run_query(query, conn_params)
+    uniq_concepts = {}
+    for row in res:
+        concept = row.get('concept')
+        if concept not in uniq_concepts and concept != 'thing':
+            uniq_concepts[concept] = row
+
+    return uniq_concepts
+
+
+def _generate_column_relationship_description(column_name):
+    """
+    Generates a concise description for a column used in text-to-SQL generation.
+
+    Expected column name formats:
+      relationship_name[target_concept].property_name
+      or
+      relationship_name[target_concept].relationship_name[target_concept].property_name
+      (and potentially more nested relationships)
+
+    For example:
+      "includes_product[product].contains[material].material_name"
+
+    Output example:
+      "This column represents the material name from table material using the relationship contains from table product from relationship includes product."
+    """
+
+    try:
+        # Split the column name into parts using the period as a delimiter.
+        parts = column_name.split('.')
+        # The final part is the property name; replace underscores with spaces.
+        property_name = parts[-1].replace('_', ' ')
+
+        # Extract relationships (each part before the final property)
+        relationships = []
+        for part in parts[:-1]:
+            if '[' in part and ']' in part:
+                relationship, target_concept = part.split('[')
+                target_concept = target_concept.rstrip(']')
+                # Replace underscores with spaces.
+                relationship = relationship.replace('_', ' ')
+                target_concept = target_concept.replace('_', ' ')
+                relationships.append((relationship, target_concept))
+
+        col_type = "column"
+        if column_name.startswith("measure."):
+            col_type = "measure"
+
+        # Build the description.
+        if relationships:
+            # The final table is taken from the target of the last relationship.
+            final_table = relationships[-1][1]
+            description = f"This {col_type} represents the {property_name} from table {final_table}"
+            if len(relationships) == 1:
+                # Only one relationship in the chain.
+                description += f" using the relationship {relationships[0][0]}."
+            else:
+                # For two or more relationships:
+                # The last relationship is applied on the table from the previous relationship.
+                # For example, for two relationships:
+                #   relationships[0] = ("includes product", "product")
+                #   relationships[1] = ("contains", "material")
+                # We want: "using the relationship contains from table product from relationship includes product."
+                last_rel, _ = relationships[-1]
+                base_table = relationships[-2][1]
+                derivation = f" using the relationship {last_rel} from table {base_table}"
+                # For any additional relationships (if more than two), append them in order.
+                for i in range(len(relationships) - 2, -1, -1):
+                    derivation += f" from relationship {relationships[i][0]}"
+                description += derivation + "."
+        else:
+            description = f"This {col_type} represents the {property_name}."
+
+        return description
+    except Exception as exp:
+      return ""
+
+@cache_with_version_check
+def get_relationships_description(conn_params: dict) -> dict:
+    """Fetch relationships data."""
+    query = f"""
+        SELECT 
+            relationship_name,
+            description
+        FROM `timbr`.`SYS_CONCEPT_RELATIONSHIPS`
+        WHERE description is not null
+    """.strip()
+
+    res = run_query(query, conn_params)
+    relationships_desc = {}
+    for row in res:
+        relationships_desc[row['relationship_name']] = row['description']
+    
+    return relationships_desc
+
+@cache_with_version_check
+def get_properties_description(conn_params: dict) -> dict:
+    query = f"""
+        SELECT property_name, description
+        FROM `timbr`.`SYS_PROPERTIES`
+        WHERE description is not null
+    """.strip()
+
+    res = run_query(query, conn_params)
+    properties_desc = {}
+    for row in res:
+        properties_desc[row['property_name']] = row['description']
+    
+    return properties_desc
+
+
+def _add_relationship_column(
+    relationship_name: str,
+    relationship_desc: str,
+    col_dict: dict,
+    relationships: dict,
+) -> None:
+    """Add a column to the specified relationship."""
+    col_name = col_dict.get('name')
+    if col_name:
+        if relationship_name not in relationships:
+            is_transitive = '*' in col_name
+            relationships[relationship_name] = {
+                "relationship_name": relationship_name,
+                "description": relationship_desc,
+                "columns": [],
+                "measures": [],
+                "is_transitive": is_transitive,
+            }
+
+        if col_name.startswith('measure.'):
+            relationships[relationship_name]['measures'].append(col_dict)
+        else:
+            relationships[relationship_name]['columns'].append(col_dict)
+
+@cache_with_version_check
+def get_concept_properties(
+    concept_name: str,
+    conn_params: dict,
+    properties_desc: dict,
+    relationships_desc: dict,
+    schema: Optional[str] = 'dtimbr',
+    graph_depth: Optional[int] = 1,
+) -> dict:
+    rows = []
+    desc_query = f"describe concept `{schema}`.`{concept_name}`"
+    if schema == 'dtimbr':
+        desc_query += f" options (graph_depth='{graph_depth}')"
+
+    try:
+        rows = run_query(desc_query, conn_params)
+    except Exception as e:
+        # skipping new describe concept syntax
+        pass
+
+    if not rows:
+        legacy_desc_query = f"desc `{schema}`.`{concept_name}`"
+        try:
+            rows = run_query(legacy_desc_query, conn_params)
+        except Exception as e:
+            print(f"Error describing concept using legacy desc stmt: {e}")
+
+    relationships = {}
+    columns = []
+    measures = []
+    
+    for column in rows:
+        col_name = column.get('col_name')
+        comment = properties_desc.get(col_name)
+
+        if col_name:
+            if "_type_of_" in col_name:
+                comment = f"if this value is 1, the row is of type {col_name.split('_type_of_')[1]}"
+            # elif (comment is None or comment == "") and "[" in col_name and "]" in col_name:
+            #     comment = _generate_column_relationship_description(col_name)
+            elif col_name.startswith("~"):
+                rel_name = col_name[1:].split('[')[0]
+                comment = comment + "; " if comment else ''
+                comment = comment + f"This columns means the inverse of `{rel_name}`"
+            
+            if "." in col_name and (comment is None or comment == ""): 
+                    comment = properties_desc.get(col_name.split(".")[-1])
+
+            if '[' in col_name:
+                # This is a relationship column
+                rel_path, rel_col_name = col_name.rsplit('.', 1) if '.' in col_name else col_name.rsplit('_', 1) if '_' in col_name else col_name
+                rel_name = rel_path.split('[', 1)[0]
+
+                if rel_name:
+                    if rel_name.startswith('measure.'):
+                        rel_name = rel_name.replace('measure.', '')
+            
+                    comment = properties_desc.get(rel_col_name, '')
+
+                    rel_col_dict = {
+                        'name': col_name,
+                        'col_name': rel_col_name,
+                        'type': column.get('data_type', 'string').lower(),
+                        'data_type': column.get('data_type', 'string').lower(),
+                        'comment': comment,
+                    }
+                    _add_relationship_column(
+                        relationship_name=rel_name,
+                        relationship_desc=relationships_desc.get(rel_name, ''),
+                        col_dict=rel_col_dict,
+                        relationships=relationships
+                    )
+
+            elif col_name.startswith("measure."):
+                measures.append({ **column, 'comment': comment })
+            else:
+                columns.append({ **column, 'comment': comment })
+    return {
+        "columns": columns,
+        "measures": measures,
+        "relationships": relationships,
+    }
+

langchain_timbr-1.5.0.dist-info/METADATA

@@ -0,0 +1,103 @@
+Metadata-Version: 2.4
+Name: langchain-timbr
+Version: 1.5.0
+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/
+Project-URL: Source, https://github.com/WPSemantix/langchain-timbr
+Project-URL: Issues, https://github.com/WPSemantix/langchain-timbr/issues
+Author-email: Bar Cohen <barco@timbr.ai>
+License: MIT
+License-File: LICENSE
+Keywords: Agents,Knowledge Graph,LLM,LangChain,LangGraph,SQL,Semantic Layer,Timbr
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: <3.13,>=3.9
+Requires-Dist: cryptography>=44.0.3
+Requires-Dist: langchain-community>=0.3.20
+Requires-Dist: langchain-core>=0.3.58
+Requires-Dist: langchain>=0.3.25
+Requires-Dist: langgraph>=0.3.20
+Requires-Dist: pydantic==2.10.4
+Requires-Dist: pytimbr-api>=2.0.0
+Requires-Dist: tiktoken==0.8.0
+Requires-Dist: transformers>=4.51.3
+Provides-Extra: all
+Requires-Dist: anthropic==0.42.0; extra == 'all'
+Requires-Dist: google-generativeai==0.8.4; extra == 'all'
+Requires-Dist: langchain-anthropic>=0.3.1; extra == 'all'
+Requires-Dist: langchain-google-genai>=2.0.9; extra == 'all'
+Requires-Dist: langchain-openai>=0.3.16; extra == 'all'
+Requires-Dist: langchain-tests>=0.3.20; extra == 'all'
+Requires-Dist: openai==1.77.0; extra == 'all'
+Requires-Dist: pyarrow<19.0.0; extra == 'all'
+Requires-Dist: pytest==8.3.4; extra == 'all'
+Requires-Dist: snowflake-snowpark-python>=1.6.0; extra == 'all'
+Requires-Dist: snowflake>=0.8.0; extra == 'all'
+Requires-Dist: uvicorn==0.34.0; extra == 'all'
+Provides-Extra: anthropic
+Requires-Dist: anthropic==0.42.0; extra == 'anthropic'
+Requires-Dist: langchain-anthropic>=0.3.1; extra == 'anthropic'
+Provides-Extra: dev
+Requires-Dist: langchain-tests>=0.3.20; extra == 'dev'
+Requires-Dist: pyarrow<19.0.0; extra == 'dev'
+Requires-Dist: pytest==8.3.4; extra == 'dev'
+Requires-Dist: uvicorn==0.34.0; extra == 'dev'
+Provides-Extra: google
+Requires-Dist: google-generativeai==0.8.4; extra == 'google'
+Requires-Dist: langchain-google-genai>=2.0.9; extra == 'google'
+Provides-Extra: openai
+Requires-Dist: langchain-openai>=0.3.16; extra == 'openai'
+Requires-Dist: openai==1.77.0; extra == 'openai'
+Provides-Extra: snowflake
+Requires-Dist: snowflake-snowpark-python>=1.6.0; extra == 'snowflake'
+Requires-Dist: snowflake>=0.8.0; extra == 'snowflake'
+Description-Content-Type: text/markdown
+
+![Timbr logo description](https://timbr.ai/wp-content/uploads/2025/01/logotimbrai230125.png)
+
+[![FOSSA Status](https://app.fossa.com/api/projects/git%2Bgithub.com%2FWPSemantix%2Flangchain-timbr.svg?type=shield&issueType=security)](https://app.fossa.com/projects/git%2Bgithub.com%2FWPSemantix%2Flangchain-timbr?ref=badge_shield&issueType=security)
+[![FOSSA Status](https://app.fossa.com/api/projects/git%2Bgithub.com%2FWPSemantix%2Flangchain-timbr.svg?type=shield&issueType=license)](https://app.fossa.com/projects/git%2Bgithub.com%2FWPSemantix%2Flangchain-timbr?ref=badge_shield&issueType=license)
+
+[![Python 3.9](https://img.shields.io/badge/python-3.9-blue)](https://www.python.org/downloads/release/python-3921/)
+[![Python 3.10](https://img.shields.io/badge/python-3.10-blue.svg)](https://www.python.org/downloads/release/python-31017/)
+[![Python 3.11](https://img.shields.io/badge/python-3.11-blue.svg)](https://www.python.org/downloads/release/python-31112/)
+[![Python 3.12](https://img.shields.io/badge/python-3.12-blue.svg)](https://www.python.org/downloads/release/python-3129/)
+
+# Timbr Langchain LLM SDK
+
+Timbr langchain LLM SDK is a Python SDK that extends LangChain and LangGraph with custom agents, chains, and nodes for seamless integration with the Timbr semantic layer. It enables converting natural language prompts into optimized semantic-SQL queries and executing them directly against your data.
+
+## Dependencies
+- Access to a timbr-server
+- Python from 3.9.13 or newer
+
+## Installation
+
+### Using pip
+```bash
+python -m pip install langchain-timbr
+```
+
+### Using pip from github
+```bash
+pip install git+https://github.com/WPSemantix/langchain-timbr
+```
+
+## Documentation
+
+For comprehensive documentation and usage examples, please visit:
+
+- [Timbr LangChain Documentation](https://docs.timbr.ai/doc/docs/integration/langchain-sdk)
+- [Timbr LangGraph Documentation](https://docs.timbr.ai/doc/docs/integration/langgraph-sdk)
+
+## Configuration
+
+The SDK requires several environment variables to be configured. See [`src/langchain_timbr/config.py`](src/langchain_timbr/config.py) for all available configuration options.

langchain_timbr-1.5.0.dist-info/RECORD

@@ -0,0 +1,27 @@
+langchain_timbr/__init__.py,sha256=wPcZEQieE8Bool0TOH4uync5U-jcpEe9g6YjUqwyirg,747
+langchain_timbr/config.py,sha256=NOMjSpo0TVkWT8BdbiGSADU08iknF2bRltFLwQRhpwk,832
+langchain_timbr/timbr_llm_connector.py,sha256=OXRttlEOJf-dTyilnXR6b6Cgl_cWDYrXGXQfmDV6vc8,13206
+langchain_timbr/langchain/__init__.py,sha256=ejcsZKP9PK0j4WrrCCcvBXpDpP-TeRiVb21OIUJqix8,580
+langchain_timbr/langchain/execute_timbr_query_chain.py,sha256=we1qjMS2JdBPRkGMJTzyHkpY3yW62wlh3PF3bTkEe8U,13883
+langchain_timbr/langchain/generate_answer_chain.py,sha256=3q_Fe2tclZsdH0PFkNdZtO4Xe2WQQoxg4sekFic5zt4,3260
+langchain_timbr/langchain/generate_timbr_sql_chain.py,sha256=-RZcdJ1lsivOE6zAm_hyg9txaINMGHWnGmkZepCg2Dk,7458
+langchain_timbr/langchain/identify_concept_chain.py,sha256=m3Lzb0PVeSeE7YpfhjB1OY0x9jcR6a_lTYg5YTTDhIw,5588
+langchain_timbr/langchain/timbr_sql_agent.py,sha256=F-HVqziHS7bVxWTkmvrkseRP5uZTuHQ2JoZNorQR4J8,18025
+langchain_timbr/langchain/validate_timbr_sql_chain.py,sha256=SPW7zimqunZZLRD5d-trglL9RkqrWOy2vjkBc19CWhE,7919
+langchain_timbr/langgraph/__init__.py,sha256=mKBFd0x01jWpRujUWe-suX3FFhenPoDxrvzs8I0mum0,457
+langchain_timbr/langgraph/execute_timbr_query_node.py,sha256=ZL-HsBer073VmkJv59qFCNYJyKOgB8-Ziij4EEBD39c,5263
+langchain_timbr/langgraph/generate_response_node.py,sha256=gChNFSPjK9lKwblgWTia6ETxhY5aIbgGsEykyIlGd90,2065
+langchain_timbr/langgraph/generate_timbr_sql_node.py,sha256=qyL7uqB5k-Bv8rE12f2Ub7wlcAw-pQibEPP1SvFKLu0,4638
+langchain_timbr/langgraph/identify_concept_node.py,sha256=ot9TFdRg8FA9JYVrtHLVi5k0vmUHUfL4ptQDFYYqOoA,3376
+langchain_timbr/langgraph/validate_timbr_query_node.py,sha256=TypUs60OaBhOx9Ceq-15qNVuuAvfrFBjQsPRjWK1StQ,4469
+langchain_timbr/llm_wrapper/llm_wrapper.py,sha256=sNMEqhtZx4S0ZKJCyg8OSE3fAWu1xI6Bp_GoRs7k4dI,6801
+langchain_timbr/llm_wrapper/timbr_llm_wrapper.py,sha256=sDqDOz0qu8b4WWlagjNceswMVyvEJ8yBWZq2etBh-T0,1362
+langchain_timbr/utils/general.py,sha256=753GNpYiyxhfYq59Bi8qvCyuHmTrD1fobcm6U2jZAF4,2394
+langchain_timbr/utils/prompt_service.py,sha256=pJcBz3MKR51ajdU9gkif1r9_K7FxYbpWBiTkKA0A2q0,11144
+langchain_timbr/utils/temperature_supported_models.json,sha256=e8j9O-68eCJhEK_NWowh3C6FE7UXFbR9icjDQfJBkdM,1596
+langchain_timbr/utils/timbr_llm_utils.py,sha256=Gpp3nKG1MiwNBpl2Uua3pmKyxd1OEirRLW0kkxI473E,22462
+langchain_timbr/utils/timbr_utils.py,sha256=p21DwTGhF4iKTLDQBkeBaJDFcXt-Hpu1ij8xzQt00Ng,16958
+langchain_timbr-1.5.0.dist-info/METADATA,sha256=rL_614qtOxRauyvTcl0g6rCQaj80_IZ1lDMkqn167v8,5056
+langchain_timbr-1.5.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+langchain_timbr-1.5.0.dist-info/licenses/LICENSE,sha256=0ITGFk2alkC7-e--bRGtuzDrv62USIiVyV2Crf3_L_0,1065
+langchain_timbr-1.5.0.dist-info/RECORD,,

langchain_timbr-1.5.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

langchain_timbr-1.5.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Timbr.ai
+
+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.