Added leetspeak function encoding to encode_text (#264)

Summary:
Pull Request resolved: #264

Added leetspeak text encoding function to the enode_text interface and tested comprehensively. Word method level test covers character level test as leetspeak works on character level

Differential Revision: D76058699

Author: sharanvamsi

augly/tests/text_tests/functional_unit_test.py

@@ -38,39 +38,39 @@ def test_apply_lambda(self) -> None:
         augmented_apply_lambda = txtaugs.apply_lambda(self.texts)
         self.assertTrue(augmented_apply_lambda[0] == self.texts[0])
 
-    def test_change_case(self) -> None:
-        augmented_words = txtaugs.change_case(self.texts[0], cadence=3.0, case="upper")
-        self.assertTrue(
-            augmented_words[0]
-            == "THE quick brown 'FOX' couldn't jump OVER the green, GRASSY hill.",
-        )
-
-    def test_contractions(self) -> None:
-        augmented_words = txtaugs.contractions(
-            "I would call him but I do not know where he has gone", aug_p=0.7
-        )
-        self.assertTrue(
-            augmented_words[0] == "I would call him but I don't know where he's gone"
-        )
-
-    def test_encode_text_base64_sentence(self) -> None:
+    def test_base64_sentence(self) -> None:
         augmented_words = txtaugs.encode_text(
             "Hello, world!", 1, 1, 1.0, Method.SENTENCE, Encoding.BASE64
         )
         self.assertEqual(augmented_words[0], "SGVsbG8sIHdvcmxkIQ==")
 
-    def test_encode_text_base64_word(self) -> None:
+    def test_base64_word(self) -> None:
         augmented_words_word = txtaugs.encode_text(
             "Hello, world!", 1, 1, 1.0, Method.WORD, Encoding.BASE64
         )
         self.assertEqual(augmented_words_word[0], "SGVsbG8=, world!")
 
-    def test_encode_text_base64_char(self) -> None:
+    def test_base64_char(self) -> None:
         augmented_words_char = txtaugs.encode_text(
             "Hello, world!", 1, 1, 1.0, Method.CHAR, Encoding.BASE64
         )
         self.assertEqual(augmented_words_char[0], "SA==ello LA== dw==orld IQ==")
 
+    def test_change_case(self) -> None:
+        augmented_words = txtaugs.change_case(self.texts[0], cadence=3.0, case="upper")
+        self.assertTrue(
+            augmented_words[0]
+            == "THE quick brown 'FOX' couldn't jump OVER the green, GRASSY hill.",
+        )
+
+    def test_contractions(self) -> None:
+        augmented_words = txtaugs.contractions(
+            "I would call him but I do not know where he has gone", aug_p=0.7
+        )
+        self.assertTrue(
+            augmented_words[0] == "I would call him but I don't know where he's gone"
+        )
+
     def test_get_baseline(self) -> None:
         augmented_baseline = txtaugs.get_baseline(self.texts)
         self.assertTrue(
@@ -272,6 +272,18 @@ def test_insert_zero_width_chars(self) -> None:
             ],
         )
 
+    def test_leetspeak_sentence(self) -> None:
+        augmented_words = txtaugs.encode_text(
+            "Hello, world!", 1, 1, 1.0, Method.SENTENCE, Encoding.LEETSPEAK
+        )
+        self.assertEqual(augmented_words[0], "h3110, w0r1d!")
+
+    def test_leetspeak_word(self) -> None:
+        augmented_words = txtaugs.encode_text(
+            "Hello, world!", 1, 1, 1.0, Method.WORD, Encoding.LEETSPEAK
+        )
+        self.assertEqual(augmented_words[0], "h3110, world!")
+
     def test_merge_words(self) -> None:
         augmented_split_words = txtaugs.merge_words(self.texts, aug_word_p=0.3, n=1)
         self.assertTrue(

augly/tests/text_tests/transforms_unit_test.py

@@ -138,7 +138,7 @@ def test_Compose(self) -> None:
             are_equal_metadata(self.metadata, self.expected_metadata["compose"]),
         )
 
-    def test_EncodeText_Base64_Sentence(self) -> None:
+    def test_Base64_Sentence(self) -> None:
         augmented_text = txtaugs.EncodeTextTransform(
             aug_min=1,
             aug_max=1,
@@ -158,7 +158,7 @@ def test_EncodeText_Base64_Sentence(self) -> None:
             are_equal_metadata(self.metadata, self.expected_metadata["encode_text"])
         )
 
-    def test_EncodeText_Base64_Word(self) -> None:
+    def test_Base64_Word(self) -> None:
         self.metadata = []
 
         augmented_text = txtaugs.EncodeTextTransform(
@@ -180,7 +180,7 @@ def test_EncodeText_Base64_Word(self) -> None:
         metadata_expected[0]["encoder"] = Encoding.BASE64
         self.assertTrue(are_equal_metadata(self.metadata, metadata_expected))
 
-    def test_EncodeText_Base64_Char(self) -> None:
+    def test_Base64_Char(self) -> None:
         self.metadata = []
 
         augmented_text = txtaugs.EncodeTextTransform(
@@ -291,6 +291,48 @@ def test_InsertZeroWidthChars(self) -> None:
             ),
         )
 
+    def test_LeetSpeak_Sentence(self) -> None:
+        augmented_text = txtaugs.EncodeTextTransform(
+            aug_min=1,
+            aug_max=1,
+            aug_p=1.0,
+            method=Method.SENTENCE,
+            encoder=Encoding.LEETSPEAK,
+            n=1,
+            p=1.0,
+        )(
+            ["Hello, world!"],
+            metadata=self.metadata,
+        )
+
+        self.assertTrue(augmented_text[0] == "h3110, w0r1d!")
+        self.expected_metadata["encode_text"][0]["encoder"] = Encoding.LEETSPEAK
+        self.assertTrue(
+            are_equal_metadata(self.metadata, self.expected_metadata["encode_text"])
+        )
+
+    def test_Leetspeak_Word(self) -> None:
+        self.metadata = []
+
+        augmented_text = txtaugs.EncodeTextTransform(
+            aug_min=1,
+            aug_max=1,
+            aug_p=1.0,
+            method=Method.WORD,
+            encoder=Encoding.LEETSPEAK,
+            n=1,
+            p=1.0,
+        )(
+            ["Hello, world!"],
+            metadata=self.metadata,
+        )
+        self.assertEqual(augmented_text[0], "h3110, world!")
+
+        metadata_expected = deepcopy(self.expected_metadata["encode_text"])
+        metadata_expected[0]["method"] = "word"
+        metadata_expected[0]["encoder"] = Encoding.LEETSPEAK
+        self.assertTrue(are_equal_metadata(self.metadata, metadata_expected))
+
     def test_MergeWords(self) -> None:
         aug_merge_words = txtaugs.MergeWords(aug_word_p=0.3)(
             self.texts, metadata=self.metadata

augly/text/augmenters/__init__.py

@@ -17,6 +17,7 @@
 from augly.text.augmenters.fun_fonts import FunFontsAugmenter
 from augly.text.augmenters.insert_text import InsertTextAugmenter
 from augly.text.augmenters.insertion import InsertionAugmenter
+from augly.text.augmenters.leetspeak import LeetSpeak
 from augly.text.augmenters.letter_replacement import LetterReplacementAugmenter
 from augly.text.augmenters.text_replacement import TextReplacementAugmenter
 from augly.text.augmenters.typo import TypoAugmenter
@@ -35,6 +36,7 @@
     "FunFontsAugmenter",
     "InsertTextAugmenter",
     "InsertionAugmenter",
+    "LeetSpeak",
     "LetterReplacementAugmenter",
     "WordsAugmenter",
     "TextReplacementAugmenter",

augly/text/augmenters/leetspeak.py

@@ -0,0 +1,50 @@
+#!/usr/bin/env python3
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+import random
+
+from augly.text.augmenters.encode_text_strategy import EncodeTextAugmentation
+from augly.text.augmenters.utils import Encoding
+from nlpaug.util import Method
+
+
+class LeetSpeak(EncodeTextAugmentation):
+    def __init__(
+        self,
+        aug_min: int,
+        aug_max: int,
+        aug_p: float,
+        method: Method,
+    ):
+        super().__init__(
+            name="LeetSpeak",
+            aug_min=aug_min,
+            aug_max=aug_max,
+            aug_p=aug_p,
+            encoder=Encoding.LEETSPEAK,
+            method=str(method),
+        )
+        assert 0 <= aug_min <= aug_max
+        assert 0 <= aug_p <= 1
+
+    def encode(self, input_string: str) -> str:
+        leet_map = {
+            "a": ["4", "@"],
+            "b": ["8"],
+            "e": ["3"],
+            "g": ["6"],
+            "i": ["1", "!"],
+            "l": ["1"],
+            "o": ["0"],
+            "s": ["5", "$"],
+            "t": ["7", "+"],
+            "z": ["2"],
+        }
+        input_string = input_string.lower()
+        return "".join(
+            random.choice(leet_map.get(char, [char])) for char in input_string
+        )

augly/text/augmenters/utils.py

@@ -274,3 +274,4 @@ def get_aug_idxes(
 
 class Encoding(Enum):
     BASE64 = "base64"
+    LEETSPEAK = "leetspeak"

augly/text/functional.py

@@ -212,7 +212,8 @@ def encode_text(
         texts = [texts]
     if encoder == Encoding.BASE64:
         encoder_strategy = a.Base64(aug_min, aug_max, aug_p, method)
-    # pyre-ignore
+    else:
+        encoder_strategy = a.LeetSpeak(aug_min, aug_max, aug_p, method)
     encoder_context = a.EncodeText(encoder_strategy)
     aug_texts = encoder_context.augmenter(texts)
 

augly/text/intensity.py

@@ -38,6 +38,8 @@ def encode_text_intensity(
 ) -> float:
     if encoder == Encoding.BASE64:
         return base64_intensity(method, aug_p, aug_max)
+    elif encoder == Encoding.LEETSPEAK:
+        return leetspeak_intensity(method, aug_p, aug_max)
     else:
         raise NotImplementedError(
             f"Intensity function for encoder {encoder} is not implemented"
@@ -76,6 +78,12 @@ def insert_zero_width_chars_intensity(
     return char_insertion_intensity_helper(granularity, cadence)
 
 
+def leetspeak_intensity(method: Method, aug_p: float, aug_max: int, **kwargs) -> float:
+    return (
+        100.0 if method == Method.SENTENCE else replace_intensity_helper(aug_p, aug_max)
+    )
+
+
 def merge_words_intensity(aug_word_p: float, aug_word_max: int, **kwargs) -> float:
     return replace_intensity_helper(aug_word_p, aug_word_max)