tellaro-query-language 0.2.1__tar.gz → 0.2.3__tar.gz

{tellaro_query_language-0.2.1 → tellaro_query_language-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tellaro-query-language
-Version: 0.2.1
+Version: 0.2.3
 Summary: A flexible, human-friendly query language for searching and filtering structured data
 Home-page: https://github.com/tellaro/tellaro-query-language
 License: MIT
@@ -24,6 +24,7 @@ Requires-Dist: opensearch-dsl (>=2.1.0,<3.0.0) ; extra == "opensearch"
 Requires-Dist: opensearch-py (>=2.4.2,<3.0.0) ; extra == "opensearch"
 Requires-Dist: pyparsing (>=3.2.1,<4.0.0)
 Requires-Dist: setuptools (>=80.0.0,<81.0.0)
+Requires-Dist: urllib3 (>=2.5.0,<3.0.0)
 Project-URL: Documentation, https://github.com/tellaro/tellaro-query-language/tree/main/docs
 Project-URL: Repository, https://github.com/tellaro/tellaro-query-language
 Description-Content-Type: text/markdown

{tellaro_query_language-0.2.1 → tellaro_query_language-0.2.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "tellaro-query-language"
-version = "0.2.1"
+version = "0.2.3"
 description = "A flexible, human-friendly query language for searching and filtering structured data"
 authors = ["Justin Henderson <justin@tellaro.io>"]
 license = "MIT"
@@ -39,6 +39,7 @@ dnspython = "^2.7.0"
 opensearch-py = {version = "^2.4.2", optional = true}
 opensearch-dsl = {version = "^2.1.0", optional = true}
 maxminddb = "^2.7.0"
+urllib3 = "^2.5.0"
 
 [tool.poetry.extras]
 opensearch = ["opensearch-py", "opensearch-dsl"]
@@ -94,3 +95,22 @@ line_length = 120
 filterwarnings = [
     "ignore:Unverified HTTPS request:urllib3.exceptions.InsecureRequestWarning",
 ]
+# Only collect tests from these directories
+testpaths = [
+    "tests",
+]
+# Don't collect from these directories
+norecursedirs = [
+    ".*",
+    "build",
+    "dist",
+    "*.egg",
+    "venv",
+    "env",
+    "__pycache__",
+    "playground",
+]
+# Custom markers
+markers = [
+    "integration: marks tests as integration tests (deselect with '-m \"not integration\"')",
+]

{tellaro_query_language-0.2.1 → tellaro_query_language-0.2.3}/src/tql/__init__.py

@@ -28,7 +28,7 @@ from .opensearch_mappings import (
     get_sample_data_from_index,
 )
 
-__version__ = "0.1.0"
+__version__ = "0.2.2"
 __all__ = [
     "TQL",
     "TQLParseError",

tellaro_query_language-0.2.3/src/tql/cache/base.py

@@ -0,0 +1,97 @@
+"""Base cache infrastructure for TQL.
+
+This module provides the base CacheManager class that defines the caching
+interface used throughout TQL. Concrete implementations include LocalCacheManager
+for in-memory caching and RedisCacheManager for distributed caching.
+"""
+
+from typing import Any, Dict, Optional
+
+
+class CacheManager:
+    """Base class for cache management.
+
+    This class defines the interface for all cache implementations in TQL.
+    Subclasses should override these methods to provide actual caching functionality.
+
+    The base implementation provides no-op defaults that can be safely used when
+    caching is disabled or not needed.
+
+    Example:
+        >>> cache = LocalCacheManager()
+        >>> cache.set("user:123", {"name": "Alice", "age": 30}, ttl=3600)
+        >>> user = cache.get("user:123")
+        >>> cache.delete("user:123")
+    """
+
+    def get(self, key: str) -> Optional[Any]:
+        """Retrieve a value from the cache.
+
+        Args:
+            key: The cache key to look up. Should be a string identifier.
+
+        Returns:
+            The cached value if it exists and hasn't expired, None otherwise.
+
+        Example:
+            >>> value = cache.get("my_key")
+            >>> if value is not None:
+            ...     print(f"Found: {value}")
+        """
+        return None
+
+    def set(self, key: str, value: Any, ttl: Optional[int] = None) -> None:
+        """Store a value in the cache.
+
+        Args:
+            key: The cache key under which to store the value.
+            value: The value to cache. Can be any Python object.
+            ttl: Time-to-live in seconds. If None or 0, the value never expires.
+
+        Example:
+            >>> cache.set("config", {"debug": True}, ttl=300)  # Cache for 5 minutes
+            >>> cache.set("permanent", {"version": "1.0"})  # Never expires
+        """
+
+    def delete(self, key: str) -> None:
+        """Remove a value from the cache.
+
+        Args:
+            key: The cache key to delete.
+
+        Example:
+            >>> cache.delete("expired_key")
+        """
+
+    def clear_pattern(self, pattern: str) -> int:  # pylint: disable=unused-argument
+        """Clear all keys matching a pattern.
+
+        Args:
+            pattern: A pattern string to match keys. Format depends on implementation.
+                    For Redis: supports wildcards like "user:*" or "session:?123"
+                    For Local: basic string matching
+
+        Returns:
+            The number of keys that were deleted.
+
+        Example:
+            >>> count = cache.clear_pattern("temp:*")
+            >>> print(f"Cleared {count} temporary keys")
+        """
+        return 0
+
+    def get_stats(self) -> Dict[str, Any]:
+        """Get cache statistics and metrics.
+
+        Returns:
+            Dictionary containing cache statistics such as:
+            - hit_rate: Cache hit rate percentage
+            - miss_rate: Cache miss rate percentage
+            - size: Number of items in cache
+            - memory_usage: Memory used by cache (if available)
+
+        Example:
+            >>> stats = cache.get_stats()
+            >>> print(f"Hit rate: {stats.get('hit_rate', 0)}%")
+        """
+        return {}

tellaro_query_language-0.2.3/src/tql/cache/memory.py

@@ -0,0 +1,171 @@
+"""In-memory cache implementation for TQL.
+
+This module provides a simple in-memory cache with TTL (time-to-live) support
+and basic LRU (Least Recently Used) eviction when the cache reaches its size limit.
+"""
+
+import time
+from typing import Any, Dict, Optional
+
+from .base import CacheManager
+
+
+class LocalCacheManager(CacheManager):
+    """Local in-memory cache with TTL and LRU eviction.
+
+    This implementation provides thread-safe in-memory caching suitable for
+    single-process applications. For distributed caching across multiple
+    processes or servers, use RedisCacheManager instead.
+
+    Features:
+        - TTL-based expiration
+        - LRU eviction when cache is full
+        - Hit/miss statistics tracking
+        - Pattern-based key clearing
+
+    Args:
+        max_size: Maximum number of items to store (default: 10000)
+        default_ttl: Default time-to-live in seconds (default: 3600 = 1 hour)
+
+    Example:
+        >>> cache = LocalCacheManager(max_size=1000, default_ttl=600)
+        >>> cache.set("user:123", {"name": "Alice"}, ttl=300)
+        >>> user = cache.get("user:123")
+        >>> stats = cache.get_stats()
+        >>> print(f"Hit rate: {stats['hit_rate']:.2%}")
+
+    Attributes:
+        max_size: Maximum cache size
+        default_ttl: Default TTL for cached items
+    """
+
+    def __init__(self, max_size: int = 10000, default_ttl: int = 3600):
+        """Initialize the local cache.
+
+        Args:
+            max_size: Maximum number of items to cache before eviction starts.
+            default_ttl: Default expiration time in seconds for cached items.
+        """
+        self.max_size = max_size
+        self.default_ttl = default_ttl
+        self._cache: Dict[str, Any] = {}
+        self._expiry: Dict[str, float] = {}
+        self._hits = 0
+        self._misses = 0
+
+    def get(self, key: str) -> Optional[Any]:
+        """Retrieve value from cache if not expired.
+
+        Args:
+            key: The cache key to retrieve.
+
+        Returns:
+            The cached value if present and not expired, None otherwise.
+
+        Note:
+            This method automatically removes expired keys when accessed.
+            Hit/miss statistics are updated on each call.
+        """
+        if key in self._cache:
+            expiry = self._expiry.get(key, float('inf'))
+            if expiry == 0 or expiry > time.time():
+                self._hits += 1
+                return self._cache[key]
+            else:
+                # Expired - clean up
+                del self._cache[key]
+                del self._expiry[key]
+        self._misses += 1
+        return None
+
+    def set(self, key: str, value: Any, ttl: Optional[int] = None) -> None:
+        """Store value in cache with optional TTL.
+
+        Args:
+            key: The cache key under which to store the value.
+            value: The value to cache (any Python object).
+            ttl: Time-to-live in seconds. If None, uses default_ttl.
+                 If 0, the item never expires.
+
+        Note:
+            When the cache is full (reaches max_size), the oldest item
+            is evicted to make room for the new one (LRU eviction).
+        """
+        if len(self._cache) >= self.max_size and key not in self._cache:
+            # Simple eviction: remove oldest (first in dict)
+            oldest_key = next(iter(self._cache))
+            del self._cache[oldest_key]
+            self._expiry.pop(oldest_key, None)
+
+        self._cache[key] = value
+        if ttl == 0:
+            # Never expires
+            self._expiry[key] = 0
+        else:
+            expiry_time = time.time() + (ttl if ttl is not None else self.default_ttl)
+            self._expiry[key] = expiry_time
+
+    def delete(self, key: str) -> None:
+        """Remove value from cache.
+
+        Args:
+            key: The cache key to delete.
+
+        Note:
+            If the key doesn't exist, this method does nothing (no error raised).
+        """
+        self._cache.pop(key, None)
+        self._expiry.pop(key, None)
+
+    def clear_pattern(self, pattern: str) -> int:
+        """Clear all keys matching a glob pattern.
+
+        Args:
+            pattern: A glob pattern to match keys. Supports wildcards:
+                    - '*' matches any sequence of characters
+                    - '?' matches any single character
+                    - '[seq]' matches any character in seq
+                    - '[!seq]' matches any character not in seq
+
+        Returns:
+            The number of keys that were deleted.
+
+        Example:
+            >>> cache.set("user:123", data1)
+            >>> cache.set("user:456", data2)
+            >>> cache.set("session:789", data3)
+            >>> count = cache.clear_pattern("user:*")  # Deletes user:123 and user:456
+            >>> print(count)  # 2
+        """
+        import fnmatch
+
+        keys_to_delete = [k for k in self._cache.keys() if fnmatch.fnmatch(k, pattern)]
+        for key in keys_to_delete:
+            del self._cache[key]
+            self._expiry.pop(key, None)
+        return len(keys_to_delete)
+
+    def get_stats(self) -> Dict[str, Any]:
+        """Get cache performance statistics.
+
+        Returns:
+            Dictionary containing:
+            - hits: Number of successful cache retrievals
+            - misses: Number of cache misses
+            - hit_rate: Ratio of hits to total requests (0.0 to 1.0)
+            - size: Current number of items in cache
+            - max_size: Maximum cache capacity
+
+        Example:
+            >>> stats = cache.get_stats()
+            >>> print(f"Cache is {stats['hit_rate']:.2%} effective")
+            >>> print(f"Using {stats['size']}/{stats['max_size']} slots")
+        """
+        total_requests = self._hits + self._misses
+        return {
+            "hits": self._hits,
+            "misses": self._misses,
+            "hit_rate": self._hits / total_requests if total_requests > 0 else 0.0,
+            "size": len(self._cache),
+            "max_size": self.max_size,
+        }

{tellaro_query_language-0.2.1 → tellaro_query_language-0.2.3}/src/tql/core.py

@@ -100,8 +100,25 @@ class TQL:
                     # This is an OpenSearch-style mapping, map field to itself
                     self._simple_mappings[k] = k
                 else:
-                    # Extract the first key as the simple mapping
-                    self._simple_mappings[k] = next(iter(v.keys()))
+                    # Intelligent field mapping extraction for complex mappings
+                    # Priority: 1) Key matching field name, 2) Key without dots (primary field), 3) First key
+
+                    if k in v:
+                        # Field name exists as key in mapping (e.g., {"username": {"username": "keyword", ...}})
+                        self._simple_mappings[k] = k
+                    else:
+                        # Find primary field (keys without dots, not starting with underscore)
+                        primary_fields = [
+                            field_key for field_key in v.keys()
+                            if '.' not in field_key and not field_key.startswith('_')
+                        ]
+
+                        if primary_fields:
+                            # Use first primary field
+                            self._simple_mappings[k] = primary_fields[0]
+                        else:
+                            # Fallback to first key (maintain backward compatibility)
+                            self._simple_mappings[k] = next(iter(v.keys()))
             else:
                 # Default to mapping field to itself
                 self._simple_mappings[k] = k

{tellaro_query_language-0.2.1 → tellaro_query_language-0.2.3}/src/tql/core_components/opensearch_operations.py

@@ -239,7 +239,7 @@ class OpenSearchOperations:
             analysis_result = self.analyze_opensearch_query(query)
             has_mutators = isinstance(analysis_result, MutatorAnalysisResult)
             needs_post_processing_for_stats = (
-                has_mutators and bool(analysis_result.post_processing_requirements) if has_mutators else False
+                has_mutators and bool(analysis_result.post_processing_requirements) if has_mutators else False  # type: ignore[union-attr]
             )
 
             # Handle stats queries differently
@@ -258,7 +258,7 @@ class OpenSearchOperations:
                 if filter_ast:
                     # Use the optimized AST if we have mutators
                     if has_mutators and needs_post_processing_for_stats:
-                        filter_query = backend.convert(analysis_result.optimized_ast.get("filter", filter_ast))["query"]
+                        filter_query = backend.convert(analysis_result.optimized_ast.get("filter", filter_ast))["query"]  # type: ignore[union-attr]
                     else:
                         filter_query = backend.convert(filter_ast)["query"]
                 else:
@@ -529,6 +529,8 @@ class OpenSearchOperations:
                 stats_evaluator = TQLStatsEvaluator()
 
                 # Execute the stats aggregation in memory
+                if stats_ast_for_post_processing is None:
+                    raise ValueError("Stats AST is None but phase2 processing was requested")
                 stats_results = stats_evaluator.evaluate_stats(filtered_docs, stats_ast_for_post_processing, {})
 
                 # Format response for stats-only (no documents)
@@ -547,7 +549,7 @@ class OpenSearchOperations:
                     "performance_impact": {
                         "overhead_ms": 0,  # Would need timing to calculate
                         "documents_processed": len(all_documents),
-                        "mutators_applied": len(analysis_result.post_processing_requirements) if has_mutators else 0,
+                        "mutators_applied": len(analysis_result.post_processing_requirements) if has_mutators else 0,  # type: ignore[union-attr]
                     },
                     "opensearch_query": complete_opensearch_query,
                 }
@@ -580,6 +582,8 @@ class OpenSearchOperations:
                 translator = OpenSearchStatsTranslator()
 
                 # Transform the response using the translator
+                if stats_ast is None:
+                    raise ValueError("Stats AST is None but grouping was detected")
                 transformed_response = translator.transform_response(response, stats_ast)
 
                 # The transformed response already has the correct structure
@@ -925,6 +929,21 @@ class OpenSearchOperations:
         # Get opensearch total before filtering
         opensearch_total = total_hits
 
+        # Track optimization features used in this query
+        optimizations_applied = []
+        if scan_all:
+            optimizations_applied.append("scroll_api")
+        if needs_phase2 and pagination_stats and pagination_stats.get("pages_checked", 0) > 1:
+            optimizations_applied.append("auto_pagination")
+        if request_cache:
+            optimizations_applied.append("request_cache")
+        if preference:
+            optimizations_applied.append("preference_routing")
+        if routing:
+            optimizations_applied.append("custom_routing")
+        if terminate_after:
+            optimizations_applied.append("early_termination")
+
         result = {
             "results": results,
             "total": len(results),
@@ -934,7 +953,7 @@ class OpenSearchOperations:
             "health_status": health_status,
             "health_reasons": health_reasons,
             "performance_impact": performance_impact,
-            "optimizations_applied": [],  # TODO: Track actual optimizations  # noqa: W0511
+            "optimizations_applied": optimizations_applied,
             "opensearch_query": (
                 complete_opensearch_query if "complete_opensearch_query" in locals() else {}
             ),  # Include the full query body

{tellaro_query_language-0.2.1 → tellaro_query_language-0.2.3}/src/tql/evaluator.py

@@ -350,6 +350,8 @@ class TQLEvaluator:
                 return left_missing or right_missing
             elif node_type == "unary_op":
                 # Don't recurse through NOT operators - they handle missing fields themselves
+                # The NOT operator has special logic at lines 213-254 that handles missing fields correctly
+                # Recursing here would cause double-handling and incorrect results
                 return False
             elif node_type == "collection_op":
                 field_name = node["field"]

{tellaro_query_language-0.2.1 → tellaro_query_language-0.2.3}/src/tql/evaluator_components/value_comparison.py

@@ -6,6 +6,7 @@ operator implementations, and special cases like CIDR matching.
 
 import ipaddress
 import re
+from functools import lru_cache
 from typing import Any
 
 
@@ -15,6 +16,23 @@ class ValueComparator:
     # Sentinel value to distinguish missing fields from None values
     _MISSING_FIELD = object()
 
+    @staticmethod
+    @lru_cache(maxsize=256)
+    def _compile_regex(pattern: str) -> re.Pattern:
+        """Compile and cache regex patterns for performance.
+
+        Args:
+            pattern: Regex pattern string
+
+        Returns:
+            Compiled regex pattern
+
+        Note:
+            Uses LRU cache with max 256 patterns. This significantly improves
+            performance when the same regex patterns are used repeatedly in queries.
+        """
+        return re.compile(pattern)
+
     def compare_values(self, field_value: Any, operator: str, expected_value: Any) -> bool:  # noqa: C901
         """Compare a field value against an expected value using the given operator.
 
@@ -49,9 +67,17 @@ class ValueComparator:
                 return False
 
         # Handle None field values (field exists but is None)
+        # IMPORTANT: None is a valid value, distinct from missing fields.
+        # For 'exists' operator: This code path should NOT be reached because 'exists'
+        # checks field presence in the record, not the value. The evaluator handles
+        # 'exists' before calling compare_values. If we reach here with None, it means
+        # the field exists but has None value, which should NOT match 'exists'.
         if field_value is None:
             if operator in ["exists"]:
-                return True  # Field exists, even if value is None
+                # Field key exists in record but value is None
+                # Semantics: 'exists' means "field has a non-null value"
+                # This matches database behavior where NULL != EXISTS
+                return False  # None value does not satisfy 'exists'
             elif operator in ["is"]:
                 # Check for null comparison - expected_value can be None or "null"
                 return expected_value is None or (isinstance(expected_value, str) and expected_value.lower() == "null")
@@ -59,6 +85,10 @@ class ValueComparator:
                 return False
 
         # Convert numeric strings to numbers for comparison
+        # IMPORTANT: Store original values to check if conversion succeeded
+        field_value_original = field_value
+        expected_value_original = expected_value
+
         field_value = self._convert_numeric(field_value)
         expected_value = self._convert_numeric(expected_value)
 
@@ -68,6 +98,20 @@ class ValueComparator:
         if isinstance(field_value, str) and field_value.lower() in ["true", "false"]:
             field_value = field_value.lower() == "true"
 
+        # Type compatibility check for numeric operators
+        # If operator requires numeric comparison, both values must be numeric
+        # Exception: Arrays are handled specially in the operator logic below
+        if operator in ["gt", "gte", "lt", "lte", ">", ">=", "<", "<="]:
+            # Skip check if field_value is an array - handled by array logic below
+            if not isinstance(field_value, (list, tuple)):
+                field_is_numeric = isinstance(field_value, (int, float)) and not isinstance(field_value, bool)
+                expected_is_numeric = isinstance(expected_value, (int, float)) and not isinstance(expected_value, bool)
+
+                if not (field_is_numeric and expected_is_numeric):
+                    # At least one value failed numeric conversion
+                    # Cannot perform numeric comparison - return False
+                    return False
+
         try:
             if operator in ["eq", "="]:
                 # Handle array fields - check if ANY element equals expected value
@@ -104,27 +148,30 @@ class ValueComparator:
                 if isinstance(expected_value, list) and len(expected_value) == 1:
                     expected_value = expected_value[0]
                 # Handle list fields by checking if ANY element contains the expected value
+                # Case-insensitive comparison to match post-processor behavior
                 if isinstance(field_value, list):
                     # For arrays, check if ANY element contains the expected value
-                    return any(str(expected_value) in str(elem) for elem in field_value)
+                    return any(str(expected_value).lower() in str(elem).lower() for elem in field_value)
                 else:
-                    return str(expected_value) in str(field_value)
+                    return str(expected_value).lower() in str(field_value).lower()
             elif operator == "startswith":
                 # Unwrap single-element lists for string operators
                 if isinstance(expected_value, list) and len(expected_value) == 1:
                     expected_value = expected_value[0]
                 # Handle array fields - check if ANY element starts with expected value
+                # Case-insensitive comparison to match post-processor behavior
                 if isinstance(field_value, (list, tuple)):
-                    return any(str(elem).startswith(str(expected_value)) for elem in field_value)
-                return str(field_value).startswith(str(expected_value))
+                    return any(str(elem).lower().startswith(str(expected_value).lower()) for elem in field_value)
+                return str(field_value).lower().startswith(str(expected_value).lower())
             elif operator == "endswith":
                 # Unwrap single-element lists for string operators
                 if isinstance(expected_value, list) and len(expected_value) == 1:
                     expected_value = expected_value[0]
                 # Handle array fields - check if ANY element ends with expected value
+                # Case-insensitive comparison to match post-processor behavior
                 if isinstance(field_value, (list, tuple)):
-                    return any(str(elem).endswith(str(expected_value)) for elem in field_value)
-                return str(field_value).endswith(str(expected_value))
+                    return any(str(elem).lower().endswith(str(expected_value).lower()) for elem in field_value)
+                return str(field_value).lower().endswith(str(expected_value).lower())
             elif operator == "in":
                 if isinstance(expected_value, list):
                     if len(expected_value) == 1 and isinstance(field_value, list):
@@ -143,7 +190,13 @@ class ValueComparator:
                 # Unwrap single-element lists for string operators
                 if isinstance(expected_value, list) and len(expected_value) == 1:
                     expected_value = expected_value[0]
-                return bool(re.search(str(expected_value), str(field_value)))
+                # Use cached regex compilation for performance
+                try:
+                    pattern = self._compile_regex(str(expected_value))
+                    return bool(pattern.search(str(field_value)))
+                except (re.error, TypeError):
+                    # Invalid regex pattern, fall back to no match
+                    return False
             elif operator == "cidr":
                 # Unwrap single-element lists for CIDR
                 if isinstance(expected_value, list) and len(expected_value) == 1:
@@ -194,22 +247,31 @@ class ValueComparator:
                 # Unwrap single-element lists for string operators
                 if isinstance(expected_value, list) and len(expected_value) == 1:
                     expected_value = expected_value[0]
-                return str(expected_value) not in str(field_value)
+                # Case-insensitive comparison to match post-processor behavior
+                return str(expected_value).lower() not in str(field_value).lower()
             elif operator == "not_startswith":
                 # Unwrap single-element lists for string operators
                 if isinstance(expected_value, list) and len(expected_value) == 1:
                     expected_value = expected_value[0]
-                return not str(field_value).startswith(str(expected_value))
+                # Case-insensitive comparison to match post-processor behavior
+                return not str(field_value).lower().startswith(str(expected_value).lower())
             elif operator == "not_endswith":
                 # Unwrap single-element lists for string operators
                 if isinstance(expected_value, list) and len(expected_value) == 1:
                     expected_value = expected_value[0]
-                return not str(field_value).endswith(str(expected_value))
+                # Case-insensitive comparison to match post-processor behavior
+                return not str(field_value).lower().endswith(str(expected_value).lower())
             elif operator == "not_regexp":
                 # Unwrap single-element lists for string operators
                 if isinstance(expected_value, list) and len(expected_value) == 1:
                     expected_value = expected_value[0]
-                return not bool(re.search(str(expected_value), str(field_value)))
+                # Use cached regex compilation for performance
+                try:
+                    pattern = self._compile_regex(str(expected_value))
+                    return not bool(pattern.search(str(field_value)))
+                except (re.error, TypeError):
+                    # Invalid regex pattern, fall back to match (not regexp succeeds)
+                    return True
             elif operator == "not_cidr":
                 # Unwrap single-element lists for CIDR
                 if isinstance(expected_value, list) and len(expected_value) == 1:

{tellaro_query_language-0.2.1 → tellaro_query_language-0.2.3}/src/tql/mutator_analyzer.py

@@ -491,7 +491,7 @@ class MutatorAnalyzer:
                     for param_name, param_value in geo_params.items():
                         mutator_params.append([param_name, param_value])
 
-                    geo_mutator = {"name": "geoip_lookup"}
+                    geo_mutator: Dict[str, Any] = {"name": "geoip_lookup"}
                     if mutator_params:
                         geo_mutator["params"] = mutator_params
 
@@ -539,7 +539,7 @@ class MutatorAnalyzer:
                     for param_name, param_value in nslookup_params.items():
                         mutator_params.append([param_name, param_value])
 
-                    nslookup_mutator = {"name": "nslookup"}
+                    nslookup_mutator: Dict[str, Any] = {"name": "nslookup"}
                     if mutator_params:
                         nslookup_mutator["params"] = mutator_params
 

{tellaro_query_language-0.2.1 → tellaro_query_language-0.2.3}/src/tql/opensearch_mappings.py

@@ -52,7 +52,7 @@ def extract_field_mappings_from_opensearch(
     try:
         # Extract field names from the TQL query
         field_names = tql_instance.extract_fields(tql_query)
-        logger.info(f"Extracted {len(field_names)} fields from TQL query: {field_names}")
+        logger.debug(f"Extracted {len(field_names)} fields from TQL query: {field_names}")
 
         if not field_names:
             logger.warning("No fields found in TQL query")
@@ -68,7 +68,7 @@ def extract_field_mappings_from_opensearch(
         # Extract and convert mappings to TQL format
         tql_mappings = _convert_opensearch_mappings_to_tql_format(mapping_response, field_names)
 
-        logger.info(f"Successfully converted mappings for {len(tql_mappings)} fields")
+        logger.debug(f"Successfully converted mappings for {len(tql_mappings)} fields")
         return tql_mappings
 
     except Exception as e: