tellaro-query-language 0.2.16__py3-none-any.whl → 0.2.17__py3-none-any.whl

{tellaro_query_language-0.2.16.dist-info → tellaro_query_language-0.2.17.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tellaro-query-language
-Version: 0.2.16
+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.16.dist-info → tellaro_query_language-0.2.17.dist-info}/RECORD

@@ -22,10 +22,10 @@ tql/exceptions.py,sha256=GVssdBp9134Wyk1bWbcLQFU9U8yQKl5zzquTTrM22A0,5620
 tql/field_type_inference.py,sha256=KOazjp8CK6s9vwOcFkQrdOwcazOwHqSIhYgX8hWCiDo,9700
 tql/geoip_normalizer.py,sha256=tvie-5xevJEeLp2KmjoXDjYdND8AvyVE7lCO8qgUzGY,10486
 tql/mutator_analyzer.py,sha256=OWx3k5lK5aFHWU9Ez6DaIhenEZDxj9CbB0vM71xqUTw,55670
-tql/mutators/__init__.py,sha256=eTK8sRw4KXXnTZTn5ETIqwcaIek5rSUIVyZsxTwNNHA,6966
+tql/mutators/__init__.py,sha256=Y33ugaBdXoYIH2O1AqgTvaHR-DaHDXbgcEOLuB9w4Lk,7609
 tql/mutators/base.py,sha256=4Ze_x1sTO11OILXfcF2XN7ttyHcZ4gwn96UXFMMaC6M,2523
 tql/mutators/dns.py,sha256=F0xlDLTRlkE-4j_1QUsaXWP_AnmBsLk1KdOyuRnu6ZI,15593
-tql/mutators/encoding.py,sha256=yt12BJrHAIJfBesP8VOSfVlvJqB1yOmEeT_8QDPvNN8,7985
+tql/mutators/encoding.py,sha256=Ne2vCyrFax80eq_0S7m3-zhmm-iFMLAx30ZCw5A11Mo,15090
 tql/mutators/geo.py,sha256=H-_5oDvuYaAG8Re17RkGjzCc6Z07YHd7Cr95g6JbnyE,16188
 tql/mutators/list.py,sha256=949ZrKKhL4INkH2Od8bq7Ey80kFX_23PEfRKueG82cU,7084
 tql/mutators/network.py,sha256=1lZpmKt1GoTfNxiXUmSXkTwJIzPQZnQEgU7ojpBSm3A,5458
@@ -52,8 +52,8 @@ tql/stats_evaluator.py,sha256=2qnjeH5Qx14qpHDS_YJn9jRPeoPUfkeiYJabBagdfRs,36126
 tql/stats_transformer.py,sha256=MT-4rDWZSySgn4Fuq9H0c-mvwFYLM6FqWpPv2rHX-rE,7588
 tql/streaming_file_processor.py,sha256=cftWhYcvUo984P3ALf2CO3FoCQPJPe_2s2HLcXTp5UQ,12437
 tql/validators.py,sha256=e9MlX-zQ_O3M8YP8vXyMjKU8iiJMTh6mMK0iv0_4gTY,3771
-tellaro_query_language-0.2.16.dist-info/METADATA,sha256=0Xsjjf81jqs_VQSIQ8EC4bC3V5iTeZsIfp1PhtMtX9s,21892
-tellaro_query_language-0.2.16.dist-info/WHEEL,sha256=3ny-bZhpXrU6vSQ1UPG34FoxZBp3lVcvK0LkgUz6VLk,88
-tellaro_query_language-0.2.16.dist-info/entry_points.txt,sha256=D0lbIGUYuDyfcYeqju1rWcMBFzft4sZtfIlw5uPNx5g,181
-tellaro_query_language-0.2.16.dist-info/licenses/LICENSE,sha256=eWf8lkuXlVX_8WiDpUgQvzxc1cxCeVne_e6P-pVJpwM,3038
-tellaro_query_language-0.2.16.dist-info/RECORD,,
+tellaro_query_language-0.2.17.dist-info/METADATA,sha256=EUmPRjAdMbUKsTM8V7GQY1kkdjIcvQYSJzGDqGTSPl0,21892
+tellaro_query_language-0.2.17.dist-info/WHEEL,sha256=3ny-bZhpXrU6vSQ1UPG34FoxZBp3lVcvK0LkgUz6VLk,88
+tellaro_query_language-0.2.17.dist-info/entry_points.txt,sha256=D0lbIGUYuDyfcYeqju1rWcMBFzft4sZtfIlw5uPNx5g,181
+tellaro_query_language-0.2.17.dist-info/licenses/LICENSE,sha256=eWf8lkuXlVX_8WiDpUgQvzxc1cxCeVne_e6P-pVJpwM,3038
+tellaro_query_language-0.2.17.dist-info/RECORD,,

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":

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