#61: Adding underscores to denote what methods and functions in stega…

…nographer are private.

steganographer/steganographer.py

@@ -4,7 +4,7 @@
 import os.path
 
 
-def unpack_image(pixels):
+def _unpack_image(pixels):
     """Flatten out pixels and returns a tuple. The first entry is the size of each pixel."""
     unpacked_pixels = []
 
@@ -18,7 +18,7 @@ def unpack_image(pixels):
         return 1, bytes(pixels)
 
 
-def pack_image(pixels):
+def _pack_image(pixels):
     """Do create 2d list of pixels and return the list."""
     packed_pixels = []
     pixel_length = pixels[0]
@@ -29,7 +29,7 @@ def pack_image(pixels):
     return packed_pixels
 
 
-def open_bin_file(fname):
+def _open_bin_file(fname):
     """Reads the file fname and returns bytes for all of its data."""
     try:
         fimage = open(fname, 'rb')
@@ -42,7 +42,7 @@ def open_bin_file(fname):
         sys.exit()
 
 
-def write_bin_file(fname, data):
+def _write_bin_file(fname, data):
     """Create a file fname and writes the passed in data to it."""
     try:
         fdirty = open(fname, 'wb')
@@ -53,24 +53,24 @@ def write_bin_file(fname, data):
         sys.exit()
 
 
-def open_image_file(fname):
+def _open_image_file(fname):
     """Reads the file fname and returns bytes for all it's data."""
     try:
         img = Image.open(fname)
         pixels = list(img.getdata())
-        return unpack_image(pixels)
+        return _unpack_image(pixels)
 
     except FileNotFoundError:
         print("Could not read file", fname)
         sys.exit()
 
 
-def write_image_file(fname, og_fname, data):
+def _write_image_file(fname, og_fname, data):
     """Create a image fname and writes the passed in data to it. Returns name of image created."""
     try:
         ogim = Image.open(og_fname)
         img = Image.new(ogim.mode, ogim.size)
-        img.putdata(pack_image(data))
+        img.putdata(_pack_image(data))
         fname_no_ext, _ = os.path.splitext(fname)
         img.save(fname_no_ext + '.png', 'png')
         return fname_no_ext + '.png'
@@ -83,58 +83,58 @@ def write_image_file(fname, og_fname, data):
 class Steganographer:
     """Takes care of hiding a revealing messages in images."""
 
-    BYTELEN = 8
+    _BYTELEN = 8
 
-    def hide_byte(self, clean_data, val):
+    def _hide_byte(self, clean_data, val):
         """
         Hides a byte val in data. Returns bytes.
 
         Expects a bytes of length 8 and a character value. Will return a bytes with the character's bits hidden
         in the least significant bit.
         """
         hidden_data = bytearray(len(clean_data))
-        mask = 1 << (self.BYTELEN - 1)
+        mask = 1 << (self._BYTELEN - 1)
 
         for i in range(len(hidden_data)):
             masked_bit = val & (mask >> i)
 
             if masked_bit > 0:
-                masked_bit >>= self.BYTELEN - 1 - i
+                masked_bit >>= self._BYTELEN - 1 - i
                 hidden_data[i] = clean_data[i] | masked_bit
             else:
-                masked_bit = ~(mask >> (self.BYTELEN - 1))
+                masked_bit = ~(mask >> (self._BYTELEN - 1))
                 hidden_data[i] = clean_data[i] & masked_bit
 
         return bytes(hidden_data)
 
-    def reveal_byte(self, hidden_data):
+    def _reveal_byte(self, hidden_data):
         """Expects a bytes of length 8. Will pull out the least significant bit from each byte and return them."""
         revealed_data = bytearray(1)
 
         for i in range(len(hidden_data)):
             least_sig_bit = hidden_data[i] & 1
-            revealed_data[0] |= least_sig_bit << (self.BYTELEN - 1 - i)
+            revealed_data[0] |= least_sig_bit << (self._BYTELEN - 1 - i)
 
         return bytes(revealed_data)
 
-    def hide_string(self, clean_data, val):
+    def _hide_string(self, clean_data, val):
         """
         Hides a string val in clean_data. Returns a bytes.
 
         Expects a bytes of any length and a string value. Will return a bytes with the string's bits hidden
         in the least significant bits. Adds null terminator to the end of the string.
         """
         val += '\0'
-        return self.hide_data(clean_data, bytes(val, 'utf-8'))
+        return self._hide_data(clean_data, bytes(val, 'utf-8'))
 
-    def reveal_string(self, hidden_data):
+    def _reveal_string(self, hidden_data):
         """
         Returns a string hidden in hidden_data.
 
         Expects a bytes of any length. Will pull out the least significant bits from each byte and return them as
         a string.
         """
-        revealed_data = self.reveal_data(hidden_data)
+        revealed_data = self._reveal_data(hidden_data)
         null_pos = 0
 
         for i in range(len(revealed_data)):
@@ -153,7 +153,7 @@ def reveal_string(self, hidden_data):
 
         return revealed_string
 
-    def hide_data(self, clean_data, val):
+    def _hide_data(self, clean_data, val):
         """
         Hides val inside clean_data. Returns a bytes.
 
@@ -162,32 +162,32 @@ def hide_data(self, clean_data, val):
         """
         hidden_data = bytearray()
 
-        for data_index, str_index in zip(range(0, len(clean_data), self.BYTELEN), range(len(val))):
-            clean_byte = clean_data[data_index:data_index + self.BYTELEN]
-            hidden_byte = self.hide_byte(clean_byte, val[str_index])
+        for data_index, str_index in zip(range(0, len(clean_data), self._BYTELEN), range(len(val))):
+            clean_byte = clean_data[data_index:data_index + self._BYTELEN]
+            hidden_byte = self._hide_byte(clean_byte, val[str_index])
             hidden_data.extend(hidden_byte)
 
         hidden_data = hidden_data + clean_data[len(hidden_data):]
 
         return bytes(hidden_data)
 
-    def reveal_data(self, hidden_data):
+    def _reveal_data(self, hidden_data):
         """
         Returns the data hidden in hidden_data.
 
         Expects a bytes hidden_data of any length. Will pull out the least significant bits from each byte and
         return them as a bytes.
         """
-        revealed_data_len = len(hidden_data) // self.BYTELEN
+        revealed_data_len = len(hidden_data) // self._BYTELEN
         revealed_data = bytearray()
 
-        for i in range(0, revealed_data_len * self.BYTELEN, self.BYTELEN):
-            revealed_data.extend(self.reveal_byte(hidden_data[i:i + self.BYTELEN]))
+        for i in range(0, revealed_data_len * self._BYTELEN, self._BYTELEN):
+            revealed_data.extend(self._reveal_byte(hidden_data[i:i + self._BYTELEN]))
 
-        revealed_data_len_remainder = len(hidden_data) % self.BYTELEN
+        revealed_data_len_remainder = len(hidden_data) % self._BYTELEN
 
         if revealed_data_len_remainder > 0:
-            revealed_data.extend(self.reveal_byte(hidden_data[-1 * revealed_data_len_remainder:]))
+            revealed_data.extend(self._reveal_byte(hidden_data[-1 * revealed_data_len_remainder:]))
 
         return bytes(revealed_data)
 
@@ -198,20 +198,20 @@ def steganographer_hide(self, clean_image_file, text, dirty_image_file=''):
         Takes in a clean image file name, a dirty image file name and text that will be hidden. Hides the text in
         clean_image_file and outputs it to dirty_image_file.
         """
-        clean_data = open_image_file(clean_image_file)
-        dirty_data = (clean_data[0], self.hide_string(clean_data[1], text))
+        clean_data = _open_image_file(clean_image_file)
+        dirty_data = (clean_data[0], self._hide_string(clean_data[1], text))
 
         if dirty_image_file == '':
             clean_name = clean_image_file.split('.')[0]
             clean_extension = clean_image_file.split('.')[1]
             dirty_image_file = clean_name + "Steganogrified." + clean_extension
 
-        output_file = write_image_file(dirty_image_file, clean_image_file, dirty_data)
+        output_file = _write_image_file(dirty_image_file, clean_image_file, dirty_data)
 
         return output_file
 
     def steganographer_reveal(self, fimage):
         """Reveals whatever string is hidden in the fimage."""
-        dirty_data = open_image_file(fimage)
-        revealed_string = self.reveal_string(dirty_data[1])
+        dirty_data = _open_image_file(fimage)
+        revealed_string = self._reveal_string(dirty_data[1])
         return revealed_string