bit_manip.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "from PIL import Image\n",
    "import numpy as tf\n",
    "import random\n",
    "import json"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "# File upload\n",
    "def get_image_matrix(filename):\n",
    "    im = Image.open(filename)\n",
    "    return tf.array(im)\n",
    "\n",
    "def write_image_matrix(matrix, filename):\n",
    "    im = Image.fromarray(matrix, \"RGB\")\n",
    "    im.save(filename)\n",
    "    return True\n",
    "\n",
    "def byte_difference(original_byte, wanted_byte):\n",
    "    mask = wanted_byte & 3\n",
    "    cleared_original = original_byte & 252\n",
    "    return cleared_original | mask\n",
    "\n",
    "def split_byte(byte):\n",
    "    quad1 = (byte & 192) >> 6\n",
    "    quad2 = (byte & 48) >> 4\n",
    "    quad3 = (byte & 12) >> 2\n",
    "    quad4 = byte & 3\n",
    "    return [quad1, quad2, quad3, quad4]\n",
    "\n",
    "def get_bytes(filename):\n",
    "    with open(filename, \"rb\") as f:\n",
    "        bytes_read = f.read()\n",
    "    return bytes_read\n",
    "\n",
    "def get_split_bytes(byte_arr):\n",
    "    byte_chunks = []\n",
    "    [byte_chunks.extend(split_byte(byte)) for byte in byte_arr]\n",
    "    return byte_chunks\n",
    "\n",
    "def overwrite_bytes(img_matrix, byte_chunks):\n",
    "    x, y, z = img_matrix.shape\n",
    "    i = 0\n",
    "    for xi in range(x):\n",
    "        for yi in range(y):\n",
    "            for zi in range(z):\n",
    "                try:\n",
    "                    img_matrix[xi][yi][zi] = byte_difference(img_matrix[xi][yi][zi], byte_chunks[i])\n",
    "                    i += 1\n",
    "                except IndexError:\n",
    "                    img_matrix[xi][yi][zi] = byte_difference(img_matrix[xi][yi][zi], 0)\n",
    "    return img_matrix\n",
    "                    \n",
    "def get_phile_matrices(byte_chunks):\n",
    "    skeleton_imgs = []\n",
    "    \n",
    "    total_chunk_len = len(byte_chunks)\n",
    "    total_embed_len = 0\n",
    "    while total_embed_len < total_chunk_len:\n",
    "        new_img = download_random_img()\n",
    "        skeleton_imgs.append(new_img)\n",
    "        total_embed_len += new_img.size\n",
    "        \n",
    "    philes = []\n",
    "    start = 0\n",
    "    end = None\n",
    "    for skeleton in skeleton_imgs:\n",
    "        end  = start + skeleton.size\n",
    "        philes.append(overwrite_bytes(skeleton, byte_chunks[start: end]))\n",
    "        start = end\n",
    "        \n",
    "    return philes\n",
    "\n",
    "def download_random_img():\n",
    "    img_num = random.randint(1, 42)\n",
    "    img_name = f\"{str(img_num)}.png\"\n",
    "    if img_num < 10:\n",
    "        img_name = \"0\" + img_name\n",
    "        \n",
    "    return get_image_matrix(f\"./skeleton_image_bank/{img_name}\")\n",
    "\n",
    "def write_philes(phile_matrices, original_file_name):\n",
    "    philenames = []\n",
    "    i = 0\n",
    "    for phile in phile_matrices:\n",
    "        name = f\"{original_file_name}_{i}.png\"\n",
    "        write_image_matrix(phile, name)\n",
    "        i += 1\n",
    "        philenames.append(name)\n",
    "    return philenames\n",
    "\n",
    "def file_to_phile(filename):\n",
    "    file_byte_chunks = get_split_bytes(get_bytes(filename))\n",
    "    phile_matrices = get_phile_matrices(file_byte_chunks)\n",
    "    philenames = write_philes(phile_matrices, filename)\n",
    "    return philenames\n",
    "\n",
    "# File download\n",
    "def extract_byte_chunk(byte):\n",
    "    return byte & 3\n",
    "\n",
    "def extract_chunks_from_phile(img_matrix):\n",
    "    byte_chunks = []\n",
    "    x, y, z = img_matrix.shape\n",
    "    for xi in range(x):\n",
    "        for yi in range(y):\n",
    "            for zi in range(z):\n",
    "                byte = img_matrix[xi][yi][zi]\n",
    "                byte_chunks.append(extract_byte_chunk(byte))\n",
    "    return byte_chunks\n",
    "\n",
    "def rechunk(byte_chunk_arr):\n",
    "    final_chunk_arr = []\n",
    "    for i in range(int(tf.floor(len(byte_chunk_arr) / 4))):\n",
    "        quad1 = byte_chunk_arr[(4 * i)]\n",
    "        quad2 = byte_chunk_arr[(4 * i) + 1]\n",
    "        quad3 = byte_chunk_arr[(4 * i) + 2]\n",
    "        quad4 = byte_chunk_arr[(4 * i) + 3]\n",
    "        \n",
    "        full_byte = (quad1 << 6) | (quad2 << 4) | (quad3 << 2) | (quad4)\n",
    "        final_chunk_arr.append(full_byte)\n",
    "        \n",
    "    # TODO: You may need to fix this part to include the final missing byte\n",
    "    return final_chunk_arr\n",
    "\n",
    "def write_to_file(byte_arr, filename):\n",
    "    with open(filename, \"w+b\") as f:\n",
    "        f.write(bytearray(byte_arr))\n",
    "    return True\n",
    "    \n",
    "def phile_to_file(phile_arr, filename=None):\n",
    "    if not filename:\n",
    "        filename = \"_\".join(phile_arr[0].split(\"_\")[0: -1])\n",
    "    \n",
    "    full_byte_arr = []\n",
    "    \n",
    "    for phile in phile_arr:\n",
    "        img_matrix = get_image_matrix(phile)\n",
    "        file_chunks = extract_chunks_from_phile(img_matrix)\n",
    "        full_byte_arr.extend(file_chunks)\n",
    "\n",
    "    final_byte_arr = rechunk(full_byte_arr)\n",
    "    write_to_file(final_byte_arr, filename)\n",
    "    return True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_index(album):\n",
    "    # TODO: Google API call. Should return the index number\n",
    "    pass\n",
    "\n",
    "def get_dictionary(album):\n",
    "    # TODO: Google API call. Should return a dictionary mapping of the filesystem\n",
    "    pass\n",
    "\n",
    "def save_tmp_file(file_data, filename):\n",
    "    with open(filename, \"w+b\") as f:\n",
    "        f.write(bytearray(file_data))\n",
    "    return True\n",
    "        \n",
    "def upload_to_gp(philename, album, api_key):\n",
    "    # TODO: Use Photos API to upload the phile to the album\n",
    "    pass\n",
    "\n",
    "def download_from_gp(philename, album, api_key):\n",
    "    # TODO: Use Photos API to download the phile from the album\n",
    "\n",
    "def dict_to_json(dictionary):\n",
    "    with open('dict.json', 'w') as f:\n",
    "        json.dump(dictionary, f)\n",
    "    return True\n",
    "\n",
    "def json_to_dict(json_name):\n",
    "    with open(json_name) as f\n",
    "        data = json.load(f)\n",
    "    return data\n",
    "        \n",
    "def upload_philes(request):\n",
    "    request = request.get_json()\n",
    "    filenames = request[\"filenames\"]\n",
    "    file_data = request[\"data\"]\n",
    "    album_name = request[\"album\"]\n",
    "    api_key = request[\"key\"]\n",
    "    \n",
    "    filesystem = {}\n",
    "    \n",
    "    for file in filenames:\n",
    "        write_to_file(file_data, filename)\n",
    "        philelist = file_to_phile(filename)\n",
    "        filesystem[filename] = philelist\n",
    "    \n",
    "        for phile in philelist:\n",
    "            upload_to_gp(phile, album_name, api_key)\n",
    "            \n",
    "    dict_to_json(filesystem, \"dict.json\")\n",
    "    dict_philes = file_to_phile(\"dict.json\")\n",
    "    \n",
    "    for phile in dict_philes:\n",
    "        upload_to_gp(phile, album_name, api_key)\n",
    "        \n",
    "    with open(\"index.txt\", \"w+\") as f:\n",
    "        f.write(str(len(dict_philes)))\n",
    "        \n",
    "    index = file_to_phile(\"index.txt\")\n",
    "    \n",
    "    upload_to_gp(index, album_name, api_key)\n",
    "    \n",
    "def download_phile(request):\n",
    "    request = request.get_json()\n",
    "    filename = request[\"filename\"]\n",
    "    album_name = request[\"album\"]\n",
    "    api_key = request[\"key\"]\n",
    "    \n",
    "    download_from_gp(\"index.txt_0.png\", album_name, api_key)\n",
    "    phile_to_file([\"index.txt_0.png\"], \"index.txt\")\n",
    "    \n",
    "    with open(\"index.txt\") as f:\n",
    "        dict_num = int(f.read())\n",
    "        \n",
    "    dict_philes = [f\"dict.json_{i}.png\" i in range(dict_num)]\n",
    "    for phile in dict_philes:\n",
    "        download_from_gp(phile, album_name, api_key)\n",
    "        \n",
    "    phile_to_file(dict_philes)\n",
    "    \n",
    "    filesystem = json_to_dict(\"dict.json\")\n",
    "    \n",
    "    if filename not in filesystem:\n",
    "        return \"Error! File not found :(\"\n",
    "    \n",
    "    philenames = filesystem[filename]\n",
    "    \n",
    "    for phile in philenames:\n",
    "        download_from_gp(phile, album_name, api_key)\n",
    "        \n",
    "    phile_to_file(philenames)\n",
    "    \n",
    "    return filename"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0test.txttestimage.jpg bsf_audio.wav_4.png    fs.txt\r\n",
      "README.md              bsf_audio.wav_5.png    \u001b[34mgcp_cloud_functions\u001b[m\u001b[m\r\n",
      "Untitled.ipynb         bsf_audio.wav_6.png    index.png\r\n",
      "Untitled1.ipynb        bsf_audio.wav_7.png    index.txt\r\n",
      "bsf_audio.wav          bsf_audio.wav_8.png    samplemp3.mp3\r\n",
      "bsf_audio.wav_0.png    bsf_audio.wav_9.png    \u001b[34mskeleton_image_bank\u001b[m\u001b[m\r\n",
      "bsf_audio.wav_1.png    bsf_audio_ORIGINAL.wav test.txt\r\n",
      "bsf_audio.wav_10.png   bsf_final_mixed.wav    tester.ipynb\r\n",
      "bsf_audio.wav_2.png    dict.png               testimage.jpg\r\n",
      "bsf_audio.wav_3.png    dict_0.png             testimage.png\r\n"
     ]
    }
   ],
   "source": [
    "!ls"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "philenames = file_to_phile(\"bsf_audio.wav\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 0, 1, 2, 1, 0, 3, 3, 1, 1]\n",
      "[1, 0, 1, 2, 1, 0, 3, 3, 1, 1]\n",
      "[1, 0, 1, 2, 1, 0, 3, 3, 1, 1]\n",
      "[1, 0, 1, 2, 1, 0, 3, 3, 1, 1]\n",
      "[1, 0, 1, 2, 1, 0, 3, 3, 1, 1]\n",
      "[1, 0, 1, 2, 1, 0, 3, 3, 1, 1]\n",
      "[1, 0, 1, 2, 1, 0, 3, 3, 1, 1]\n",
      "[1, 0, 1, 2, 1, 0, 3, 3, 1, 1]\n",
      "[1, 0, 1, 2, 1, 0, 3, 3, 1, 1]\n",
      "[1, 0, 1, 2, 1, 0, 3, 3, 1, 1]\n",
      "[1, 0, 1, 2, 1, 0, 3, 3, 1, 1]\n"
     ]
    }
   ],
   "source": [
    "phile_to_file(philenames)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "udpn = [\"./upload_then_download/\" + p for p in philenames]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "phile_to_file(udpn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'NEW./upload_then_download/bsf_audio.wav'"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"NEW\" + \"_\".join(udpn[0].split(\"_\")[0: -1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"_\".join('bsf_audio.wav_10.png'.split(\"_\")[0:-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "int(tf.floor(823 / 4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "205 * 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "test = [1, 2, 3, 4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_philes = file_to_phile(\"testa.txt\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['testa.txt_0.png']"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_philes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "phile_to_file(test_philes, \"this_works.txt\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}