tellaro-query-language 0.2.15__tar.gz → 0.2.17__tar.gz

{tellaro_query_language-0.2.15 → tellaro_query_language-0.2.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tellaro-query-language
-Version: 0.2.15
+Version: 0.2.17
 Summary: A flexible, human-friendly query language for searching and filtering structured data
 License: Proprietary
 License-File: LICENSE

{tellaro_query_language-0.2.15 → tellaro_query_language-0.2.17}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "tellaro-query-language"
-version = "0.2.15"
+version = "0.2.17"
 description = "A flexible, human-friendly query language for searching and filtering structured data"
 authors = ["Justin Henderson <justin@tellaro.io>"]
 license = "Proprietary"

{tellaro_query_language-0.2.15 → tellaro_query_language-0.2.17}/src/tql/mutators/__init__.py

@@ -13,7 +13,15 @@ from ..cache import CacheManager, LocalCacheManager, RedisCacheManager
 # Import all mutator classes
 from .base import BaseMutator, append_to_result
 from .dns import NSLookupMutator
-from .encoding import Base64DecodeMutator, Base64EncodeMutator, URLDecodeMutator
+from .encoding import (
+    Base64DecodeMutator,
+    Base64EncodeMutator,
+    HexDecodeMutator,
+    HexEncodeMutator,
+    Md5Mutator,
+    Sha256Mutator,
+    URLDecodeMutator,
+)
 from .geo import GeoIPLookupMutator, GeoIPResolver
 from .list import (
     AllMutator,
@@ -44,6 +52,10 @@ __all__ = [
     "Base64EncodeMutator",
     "Base64DecodeMutator",
     "URLDecodeMutator",
+    "HexEncodeMutator",
+    "HexDecodeMutator",
+    "Md5Mutator",
+    "Sha256Mutator",
     # Security mutators
     "RefangMutator",
     "DefangMutator",
@@ -91,6 +103,10 @@ ALLOWED_MUTATORS: Dict[str, Optional[Dict[str, type]]] = {
     "b64encode": {"field": str},
     "b64decode": {"field": str},
     "urldecode": {"field": str},
+    "hexencode": {"field": str},
+    "hexdecode": {"field": str},
+    "md5": {"field": str},
+    "sha256": {"field": str},
     # List evaluation mutators
     "any": None,
     "all": None,
@@ -124,6 +140,10 @@ ENRICHMENT_MUTATORS = {
     "b64encode",
     "b64decode",
     "urldecode",
+    "hexencode",
+    "hexdecode",
+    "md5",
+    "sha256",
 }
 
 
@@ -180,6 +200,14 @@ def create_mutator(name: str, params: Optional[List[List[Any]]] = None) -> BaseM
         return Base64DecodeMutator(params_dict)
     elif key == "urldecode":
         return URLDecodeMutator(params_dict)
+    elif key == "hexencode":
+        return HexEncodeMutator(params_dict)
+    elif key == "hexdecode":
+        return HexDecodeMutator(params_dict)
+    elif key == "md5":
+        return Md5Mutator(params_dict)
+    elif key == "sha256":
+        return Sha256Mutator(params_dict)
     elif key == "is_private":
         return IsPrivateMutator(params_dict)
     elif key == "is_global":

{tellaro_query_language-0.2.15 → tellaro_query_language-0.2.17}/src/tql/mutators/encoding.py

@@ -216,3 +216,200 @@ class URLDecodeMutator(BaseMutator):
         else:
             # Return the decoded value directly
             return decoded_value
+
+
+class HexEncodeMutator(BaseMutator):
+    """
+    Mutator that encodes string values to hexadecimal.
+
+    Converts strings to their hexadecimal representation.
+    Supports encoding individual strings or lists of strings.
+
+    Parameters:
+        field: Optional field to store the encoded value
+    """
+
+    def __init__(self, params: Optional[Dict[str, Any]] = None) -> None:
+        super().__init__(params)
+        self.is_enrichment = True
+
+    def apply(self, field_name: str, record: Dict[str, Any], value: Any) -> Any:
+        """Apply the hex encode transformation."""
+        append_field = self.params.get("field")
+
+        # Handle different input types
+        encoded_value: Any
+        if value is None:
+            encoded_value = None
+        elif isinstance(value, str):
+            encoded_value = value.encode("utf-8").hex()
+        elif isinstance(value, bytes):
+            encoded_value = value.hex()
+        elif isinstance(value, list):
+            encoded_value = []
+            for item in value:
+                if isinstance(item, str):
+                    encoded_value.append(item.encode("utf-8").hex())
+                elif isinstance(item, bytes):
+                    encoded_value.append(item.hex())
+                elif item is None:
+                    encoded_value.append(None)
+                else:
+                    encoded_value.append(str(item).encode("utf-8").hex())
+        else:
+            encoded_value = str(value).encode("utf-8").hex()
+
+        # If field is specified, add to record and return original value
+        if append_field:
+            append_to_result(record, append_field, encoded_value)
+            return value
+        return encoded_value
+
+
+class HexDecodeMutator(BaseMutator):
+    """
+    Mutator that decodes hexadecimal string values.
+
+    Converts hexadecimal strings back to their original string representation.
+    Supports decoding individual strings or lists of strings.
+
+    Parameters:
+        field: Optional field to store the decoded value
+    """
+
+    def __init__(self, params: Optional[Dict[str, Any]] = None) -> None:
+        super().__init__(params)
+        self.is_enrichment = True
+
+    def apply(self, field_name: str, record: Dict[str, Any], value: Any) -> Any:  # noqa: C901
+        """Apply the hex decode transformation."""
+        append_field = self.params.get("field")
+
+        def _decode_hex(s: str) -> Optional[str]:
+            """Decode a hex string, returning None on failure."""
+            try:
+                return bytes.fromhex(s).decode("utf-8")
+            except (ValueError, UnicodeDecodeError):  # noqa: B014
+                return None
+
+        # Handle different input types
+        decoded_value: Any
+        if value is None:
+            decoded_value = None
+        elif isinstance(value, str):
+            decoded_value = _decode_hex(value)
+        elif isinstance(value, list):
+            decoded_value = []
+            for item in value:
+                if isinstance(item, str):
+                    decoded_value.append(_decode_hex(item))
+                else:
+                    decoded_value.append(item)
+        else:
+            decoded_value = _decode_hex(str(value))
+
+        # If field is specified, add to record and return original value
+        if append_field:
+            append_to_result(record, append_field, decoded_value)
+            return value
+        return decoded_value
+
+
+class Md5Mutator(BaseMutator):
+    """
+    Mutator that calculates MD5 hash of string values.
+
+    Computes the MD5 hash (as a hexadecimal string) of the input.
+    Supports hashing individual strings or lists of strings.
+
+    Parameters:
+        field: Optional field to store the hash value
+    """
+
+    def __init__(self, params: Optional[Dict[str, Any]] = None) -> None:
+        super().__init__(params)
+        self.is_enrichment = True
+
+    def apply(self, field_name: str, record: Dict[str, Any], value: Any) -> Any:
+        """Apply the MD5 hash transformation."""
+        import hashlib
+
+        append_field = self.params.get("field")
+
+        # Handle different input types
+        hashed_value: Any
+        if value is None:
+            hashed_value = None
+        elif isinstance(value, str):
+            hashed_value = hashlib.md5(value.encode("utf-8")).hexdigest()
+        elif isinstance(value, bytes):
+            hashed_value = hashlib.md5(value).hexdigest()
+        elif isinstance(value, list):
+            hashed_value = []
+            for item in value:
+                if isinstance(item, str):
+                    hashed_value.append(hashlib.md5(item.encode("utf-8")).hexdigest())
+                elif isinstance(item, bytes):
+                    hashed_value.append(hashlib.md5(item).hexdigest())
+                elif item is None:
+                    hashed_value.append(None)
+                else:
+                    hashed_value.append(hashlib.md5(str(item).encode("utf-8")).hexdigest())
+        else:
+            hashed_value = hashlib.md5(str(value).encode("utf-8")).hexdigest()
+
+        # If field is specified, add to record and return original value
+        if append_field:
+            append_to_result(record, append_field, hashed_value)
+            return value
+        return hashed_value
+
+
+class Sha256Mutator(BaseMutator):
+    """
+    Mutator that calculates SHA256 hash of string values.
+
+    Computes the SHA256 hash (as a hexadecimal string) of the input.
+    Supports hashing individual strings or lists of strings.
+
+    Parameters:
+        field: Optional field to store the hash value
+    """
+
+    def __init__(self, params: Optional[Dict[str, Any]] = None) -> None:
+        super().__init__(params)
+        self.is_enrichment = True
+
+    def apply(self, field_name: str, record: Dict[str, Any], value: Any) -> Any:
+        """Apply the SHA256 hash transformation."""
+        import hashlib
+
+        append_field = self.params.get("field")
+
+        # Handle different input types
+        hashed_value: Any
+        if value is None:
+            hashed_value = None
+        elif isinstance(value, str):
+            hashed_value = hashlib.sha256(value.encode("utf-8")).hexdigest()
+        elif isinstance(value, bytes):
+            hashed_value = hashlib.sha256(value).hexdigest()
+        elif isinstance(value, list):
+            hashed_value = []
+            for item in value:
+                if isinstance(item, str):
+                    hashed_value.append(hashlib.sha256(item.encode("utf-8")).hexdigest())
+                elif isinstance(item, bytes):
+                    hashed_value.append(hashlib.sha256(item).hexdigest())
+                elif item is None:
+                    hashed_value.append(None)
+                else:
+                    hashed_value.append(hashlib.sha256(str(item).encode("utf-8")).hexdigest())
+        else:
+            hashed_value = hashlib.sha256(str(value).encode("utf-8")).hexdigest()
+
+        # If field is specified, add to record and return original value
+        if append_field:
+            append_to_result(record, append_field, hashed_value)
+            return value
+        return hashed_value