Updated DupliPy to version 0.2.4.

Author: Infinitode

duplipy/__init__.py

@@ -1,5 +1,5 @@
 import duplipy
-from .formatting import remove_stopwords, remove_numbers, remove_whitespace, normalize_whitespace, separate_symbols, remove_special_characters, standardize_text, tokenize_text, stem_words, lemmatize_words, pos_tag, remove_profanity_from_text, remove_sensitive_info_from_text, remove_hate_speech_from_text
-from .replication import replace_word_with_synonym, augment_text_with_synonyms, load_text_file, augment_file_with_synonyms, insert_random_word, delete_random_word, insert_synonym, paraphrase, flip_horizontal, flip_vertical, rotate, random_rotation, resize, crop, random_crop, shuffle_words
+from .formatting import remove_stopwords, remove_numbers, remove_whitespace, normalize_whitespace, separate_symbols, remove_special_characters, standardize_text, tokenize_text, stem_words, lemmatize_words, pos_tag, remove_profanity_from_text, remove_sensitive_info_from_text, remove_hate_speech_from_text, post_format_text
+from .replication import replace_word_with_synonym, augment_text_with_synonyms, load_text_file, augment_file_with_synonyms, insert_random_word, delete_random_word, insert_synonym, paraphrase, flip_horizontal, flip_vertical, rotate, random_rotation, resize, crop, random_crop, shuffle_words, random_flip, random_color_jitter, noise_overlay
 from .similarity import edit_distance_score, bleu_score, jaccard_similarity_score
 from .text_analysis import analyze_sentiment

duplipy/formatting.py

@@ -16,9 +16,9 @@
 - `remove_profanity_from_text(text)`: Remove profane words from the input text.
 - `remove_sensitive_info_from_text(text)`: Remove sensitive information from the input text.
 - `remove_hate_speech_from_text(text)`: Remove hate speech or offensive speech from the input text.
+- `post_format_text(text)`: Post-format the text using regex.
 """
 
-
 import string
 import re
 import nltk
@@ -306,4 +306,23 @@ def remove_hate_speech_from_text(text):
             cleaned_sentences.append(sentence)
     cleaned_text = ' '.join(cleaned_sentences)
 
-    return cleaned_text
+    return cleaned_text
+
+def post_format_text(text):
+    """
+    Post-format the text using regex.
+
+    This function post-formats the text by removing extra spaces and ensuring
+    proper punctuation spacing.
+
+    Parameters:
+    - `text` (str): The input text to be post-formatted.
+
+    Returns:
+    - `str`: The post-formatted text.
+    """
+    # Remove extra spaces
+    text = re.sub(r'\s+', ' ', text)
+    # Ensure proper punctuation spacing
+    text = re.sub(r'\s([.,!?;:])', r'\1', text)
+    return text

duplipy/replication.py

@@ -18,6 +18,9 @@
 - `crop(image, box)`: Crop the input image to the specified rectangular region.
 - `random_crop(image, size)`: Randomly crop a region from the input image.
 - `shuffle_words(text)`: Randomly shuffle the order of words in each sentence.
+- `random_flip(image, horizontal, vertical)`: Randomly flip the input image horizontally and/or vertically.
+- `random_color_jitter(image, brightness, contrast, saturation, hue)`: Randomly adjust the brightness, contrast, saturation, and hue of the input image.
+- `noise_overlay(image, noise_factor, noise_type, grain_factor)`: Overlay noise on the input image.
 """
 
 import random
@@ -26,6 +29,7 @@
 from nltk.corpus import wordnet
 from PIL import Image
 import tqdm
+from PIL import ImageEnhance
 
 nltk.download("wordnet", quiet=True)
 nltk.download("averaged_perceptron_tagger", quiet=True)
@@ -370,4 +374,94 @@ def shuffle_words(text):
             shuffled_sentence = ' '.join(shuffled_words)
             shuffled_text.append(shuffled_sentence)
             pbar.update(1)
-    return shuffled_text
+    return shuffled_text
+
+def random_flip(image, horizontal=True, vertical=True):
+    """
+    Randomly flip the input image horizontally and/or vertically.
+
+    Parameters:
+    - `image` (PIL.Image.Image): The input image to be flipped.
+    - `horizontal` (bool): Whether to flip the image horizontally.
+    - `vertical` (bool): Whether to flip the image vertically.
+
+    Returns:
+    - `PIL.Image.Image`: The randomly flipped image.
+    """
+    if horizontal and vertical:
+        flip = random.choice([Image.FLIP_LEFT_RIGHT, Image.FLIP_TOP_BOTTOM, Image.ROTATE_180])
+    elif horizontal:
+        flip = Image.FLIP_LEFT_RIGHT
+    elif vertical:
+        flip = Image.FLIP_TOP_BOTTOM
+    else:
+        return image
+
+    return image.transpose(flip)
+
+def random_color_jitter(image, brightness=0.2, contrast=0.2, saturation=0.2, hue=0.1):
+    """
+    Randomly adjust the brightness, contrast, saturation, and hue of the input image.
+
+    Parameters:
+    - `image` (PIL.Image.Image): The input image to be color-jittered.
+    - `brightness` (float): The maximum factor to adjust brightness.
+    - `contrast` (float): The maximum factor to adjust contrast.
+    - `saturation` (float): The maximum factor to adjust saturation.
+    - `hue` (float): The maximum factor to adjust hue.
+
+    Returns:
+    - `PIL.Image.Image`: The color-jittered image.
+    """
+    image = ImageEnhance.Brightness(image).enhance(1 + random.uniform(-brightness, brightness))
+    image = ImageEnhance.Contrast(image).enhance(1 + random.uniform(-contrast, contrast))
+    image = ImageEnhance.Color(image).enhance(1 + random.uniform(-saturation, saturation))
+
+    h, s, v = image.convert("HSV").split()
+    hue_factor = int(255 * random.uniform(-hue, hue))
+    h = h.point(lambda i: (i + hue_factor) % 256)
+    image = Image.merge("HSV", (h, s, v)).convert("RGB")
+
+    return image
+
+def noise_overlay(image, noise_factor=0.1, noise_type="gaussian", grain_factor=0.0):
+    """
+    Overlay noise on the input image.
+
+    Parameters:
+        - `image` (PIL.Image.Image): The input image to overlay noise on.
+        - `noise_factor` (float): The factor to control the intensity of the noise (0.0 to 1.0).
+        - `noise_type` (str): The type of noise to overlay ("gaussian", "salt_and_pepper"). Defaults to "gaussian".
+        - `grain_factor` (float): The factor to control the graininess of the noise (0.0 to 1.0). Defaults to 0.0.
+
+    Returns:
+        - `PIL.Image.Image`: The image with overlaid noise.
+    """
+    noise = Image.new("RGB", image.size)
+
+    if noise_type == "gaussian":
+        # Generate random Gaussian noise with mean 128 and standard deviation proportional to noise_factor
+        for x in range(noise.width):
+            for y in range(noise.height):
+                noise_value = int(128 + random.gauss(0, noise_factor * 255))
+                noise.putpixel((x, y), (noise_value, noise_value, noise_value))
+    elif noise_type == "salt_and_pepper":
+        # Generate salt and pepper noise with probability proportional to noise_factor
+        for x in range(noise.width):
+            for y in range(noise.height):
+                if random.random() < noise_factor:
+                    noise_value = 0 if random.random() < 0.5 else 255
+                    noise.putpixel((x, y), (noise_value, noise_value, noise_value))
+    else:
+        raise ValueError(f"Invalid noise type: {noise_type}")
+
+    # Add grain effect by scaling random noise and blending with original image
+    grain_noise = Image.new("RGB", image.size)
+    for x in range(grain_noise.width):
+        for y in range(grain_noise.height):
+            noise_value = int(random.uniform(-grain_factor * 255, grain_factor * 255))
+            grain_noise.putpixel((x, y), (noise_value, noise_value, noise_value))
+
+    blended_noise = Image.blend(noise, grain_noise, grain_factor)
+
+    return Image.blend(image, blended_noise, noise_factor)

readme.md

@@ -1,4 +1,4 @@
-# DupliPy 0.2.3
+# DupliPy 0.2.4
 ![Python Version](https://img.shields.io/badge/python-3.12-blue.svg)
 ![Code Size](https://img.shields.io/github/languages/code-size/infinitode/duplipy)
 ![Downloads](https://pepy.tech/badge/duplipy)
@@ -7,6 +7,11 @@
 
 An open source Python library for text formatting, augmentation, and similarity calculation tasks in NLP, the package now also includes additional methods for image augmentation.
 
+## Changes in DupliPy 0.2.4
+
+- Created new functions in `duplipy.replication` for image augmentation: `random_flip`, `random_color_jitter`, and `noise_overlay`.
+- Created a new function (`post_format_text`) for post-formatting after DupliPy processing or augmentation tasks that cleans up extra whitespace and normalizes punctuation spacing.
+
 ## Changes to DupliPy 0.2.3
 
 Duplipy now utilizes another one of our Python packages, called ValX, which provides quick methods we can use to clean and format our text data before training in preprocessing steps.

test_duplipy.py

@@ -18,4 +18,8 @@
 print("Edit distance score between Hi and Hello: ", edit_distance_score("hi", "hello"))
 print("BLEU score calculation: ", bleu_score("Hello, how are you?", "Hi, how are you doing?"))
 
-print("Analyze sentiment: ", analyze_sentiment(text))
+print("Analyze sentiment: ", analyze_sentiment(text))
+
+textFormatting = "This is a test sentence ,John, how are you  ?  It  has a few words in it . It is a test sentence ."
+
+print(post_format_text(textFormatting))

test_image_augmentation.py

@@ -1,7 +1,7 @@
 import unittest
 import os
 from PIL import Image
-from duplipy.replication import flip_horizontal, flip_vertical, rotate, random_rotation, resize, crop, random_crop
+from duplipy.replication import flip_horizontal, flip_vertical, rotate, random_rotation, resize, crop, random_crop, random_flip, random_color_jitter, noise_overlay
 
 class TestImageAugmentation(unittest.TestCase):
 
@@ -48,6 +48,21 @@ def test_random_crop(self):
         self.assertTrue(isinstance(random_cropped_image, Image.Image))
         self.assertEqual(random_cropped_image.size, (50, 50))
 
+    def test_random_flip(self):
+        random_flipped_image = random_flip(self.test_image)
+        self.assertTrue(isinstance(random_flipped_image, Image.Image))
+        self.assertEqual(random_flipped_image.size, self.test_image.size)
+
+    def test_random_color_jitter(self):
+        jittered_image = random_color_jitter(self.test_image, brightness=0.5, contrast=0.5, saturation=0.5, hue=0.5)
+        self.assertTrue(isinstance(jittered_image, Image.Image))
+        self.assertEqual(jittered_image.size, self.test_image.size)
+
+    def test_noise_overlay(self):
+        noisy_image = noise_overlay(self.test_image, noise_factor=0.5)
+        self.assertTrue(isinstance(noisy_image, Image.Image))
+        self.assertEqual(noisy_image.size, self.test_image.size)
+
 
 if __name__ == "__main__":
     unittest.main()