Copy_of_Final_sound_comp.ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "source": [
        "#to-do list:\n",
        "#add wav to mp3 function to audio recorder interface \n",
        "#fix an error where uploading multiple files and one files is corrupt an error arise\n",
        "#change to way of how function work so that it track the exact file it wirks with insted of working with what inside temp\n",
        "#add introudaction tab and a name for the project\n",
        "\n"
      ],
      "metadata": {
        "id": "bsGoldUZdRxN"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "A5TtjF32Sm1p",
        "outputId": "48d2e68e-8aeb-416b-fde6-9e72bb12ac34"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/drive\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "eFvVtwiuCQNm",
        "cellView": "form"
      },
      "outputs": [],
      "source": [
        "#@title install requiered lib\n",
        "!python -m pip install encodec\n",
        "!pip install gradio\n",
        "!pip install torchaudio==0.11.0\n",
        "!pip install pydub\n",
        "!git clone https://github.com/facebookresearch/encodec.git\n",
        "%cd /content/encodec"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {
        "id": "7x-WCZyZjp6A"
      },
      "outputs": [],
      "source": [
        "#@title functions\n",
        "import gradio as gr\n",
        "import time as t\n",
        "import shutil\n",
        "import subprocess\n",
        "from scipy.io.wavfile import write\n",
        "import os\n",
        "import numpy as np\n",
        "from datetime import datetime\n",
        "from os import path\n",
        "import re\n",
        "from pydub import AudioSegment\n",
        "os.makedirs(\"garbge\",exist_ok=True)\n",
        "os.makedirs(\"input/temp\",exist_ok=True)\n",
        "os.makedirs(\"compressed/temp\",exist_ok=True)\n",
        "os.makedirs('decompressed/temp',exist_ok=True)\n",
        "def compress(audio):\n",
        "  try:\n",
        "    print(audio[0].name)\n",
        "  except:\n",
        "     \n",
        "    np.save(\"garbge/1.npy\",np.zeros((512,512)))\n",
        "    return 'The operation failed for unkonwn or corrupt input type','garbge/1.npy'\n",
        "  sounds=['mp3','wav','ogg']\n",
        "  print(\"done uploading\")\n",
        "  #file_name=audio.orig_name\n",
        "  input_files_sizes=[]\n",
        "  file_name=[]\n",
        "  for i in audio:\n",
        "    names=\"\"\n",
        "    selfix=i.orig_name.split(\".\")[-1]\n",
        "\n",
        "    names=re.sub('[^a-zA-Z1-9]+', '', i.orig_name.split(\".\")[0])\n",
        "    names=names+\".\"+selfix\n",
        "    print(names,names.split(\".\")[-1], names.split(\".\")[-1] in sounds)\n",
        "    if not names.split(\".\")[-1] in sounds:\n",
        "        np.save('garbge/1.npy',np.zeros((512,512)))\n",
        "\n",
        "        return f'The file {names} is not combaiable','garbge/1.npy'\n",
        "    file_size = os.path.getsize(i.name)\n",
        "    input_files_sizes.append(file_size)\n",
        "    shutil.copyfile(i.name ,\"input/temp/\"+ names)\n",
        "    shutil.copyfile(i.name ,\"input/\"+ names)\n",
        "    file_name.append(names)\n",
        "  text=\"\"\"\"\"\"\n",
        "  print(\"p1\")\n",
        "  input_data=os.listdir('input/temp')\n",
        "  try:\n",
        "    input_data.remove('.ipynb_checkpoints')\n",
        "  except:\n",
        "    pass\n",
        "  output_ecdc=[ i.split(\".\")[0] for i in input_data ]\n",
        "\n",
        "  for i , j in zip(input_data,output_ecdc):\n",
        "      text=text+f\"\"\"python -m encodec input/temp/{i} compressed/temp/compressed_{j}.ecdc -f\n",
        "  \"\"\"\n",
        "  t1=t.time()\n",
        "  print(text,output_ecdc,input_data)\n",
        "  print(\"started compressing\")\n",
        "  curent_st=subprocess.call(text, shell=True,stderr=subprocess.STDOUT)\n",
        "  t2=t.time()\n",
        "  print('fininshed compression')\n",
        "\n",
        "  ####\n",
        "\n",
        "\n",
        "  if curent_st==1:\n",
        "    np.save('garbge/1.npy',np.zeros((512,512)))\n",
        "\n",
        "\n",
        "    return 'The operation failed for unkonwn or corrupt input type','garbge/1.npy'\n",
        "  input_data=os.listdir('compressed/temp')\n",
        "  try:\n",
        "    input_data.remove('.ipynb_checkpoints')\n",
        "  except:\n",
        "    pass\n",
        "  \n",
        "  for k in input_data:\n",
        "    shutil.copyfile('compressed/temp/'+k ,\"compressed/\"+k)\n",
        "  input_data=os.listdir('input/temp')\n",
        "  try:\n",
        "    input_data.remove('.ipynb_checkpoints')\n",
        "  except:\n",
        "    pass\n",
        "  for i in input_data:\n",
        "    os.remove('input/temp/'+i)\n",
        "  output_list=[f'compressed/temp/compressed_{i}.ecdc' for i in output_ecdc]\n",
        "  print(output_list)\n",
        "  output_files_sizes=[os.path.getsize(f'compressed/temp/compressed_{i}.ecdc') for i in output_ecdc]\n",
        "  print(output_files_sizes)\n",
        "\n",
        "  comp_ratio=[float(100-(i/(j/100))) for j,i in zip(input_files_sizes,output_files_sizes) ]\n",
        "  print(comp_ratio)\n",
        "\n",
        "  details=\"\"\"\"\"\"\n",
        "  for i,j,k,m in zip(file_name,input_files_sizes,output_files_sizes,comp_ratio):\n",
        "    details =details+i+'\\n'+f'time to complete the compression {round(t2-t1,2)} s \\n  file size before compresion {round(j/1024,2)} kb \\n file size after compression {round(k/1024,2)}  kb  \\n ratio of space saved {round(m,2) } % \\n'\n",
        "  print(details)\n",
        "  return details,output_list\n",
        "\n",
        "def decompress(file_name):\n",
        "  \n",
        "  text=\"\"\"\"\"\"\n",
        "  input_data=os.listdir('compressed/temp')\n",
        "  try:\n",
        "    input_data.remove('.ipynb_checkpoints')\n",
        "  except:\n",
        "    pass\n",
        "  if len(input_data)==0:\n",
        "    np.save(\"garbge/1.npy\",np.zeros((512,512)))\n",
        "    return 'The operation failed for unkonwn or corrupt input type','garbge/1.npy'\n",
        "  output_ecdc=[ i.split(\".\")[0] for i in input_data ]\n",
        "\n",
        "  for i , j in zip(input_data,output_ecdc):\n",
        "      text=text+f\"\"\"python -m encodec compressed/temp/{i} decompressed/temp/decompressed_{j}.wav -f\n",
        "  \"\"\"\n",
        "  t1=t.time()\n",
        "  cur_st=subprocess.call(text, shell=True,stderr=subprocess.STDOUT)\n",
        "  t2=t.time()\n",
        "  if cur_st==1:\n",
        "    np.save('garbge/1.npy',np.zeros((512,512)))\n",
        "\n",
        "\n",
        "    return 'The operation failed for unkonwn or corrupt input type','garbge/1.npy'\n",
        "  input_data=os.listdir('compressed/temp')\n",
        "  try:\n",
        "    input_data.remove('.ipynb_checkpoints')\n",
        "  except:\n",
        "    pass\n",
        "\n",
        "\n",
        "  # files\n",
        "  input_data_dec=os.listdir(\"decompressed/temp\")\n",
        "  try:\n",
        "    input_data_dec.remove('.ipynb_checkpoints')\n",
        "  except:\n",
        "    pass\n",
        "  for i in   input_data_dec:                                                                       \n",
        "    src = f\"decompressed/temp/{i}\"\n",
        "    dst = f\"decompressed/{i.split('.')[0]}.mp3\"\n",
        "    sound = AudioSegment.from_mp3(src)\n",
        "    sound.export(dst, format=\"mp3\")\n",
        "  # convert wav to mp3                                                            \n",
        "  \n",
        "  for k in input_data:\n",
        "    os.remove('compressed/temp/'+k)\n",
        "  output_list=[f'decompressed/decompressed_{i}.mp3' for i in output_ecdc]\n",
        "  return f'time to complete Decompression {round(t2-t1,2)} s',output_list\n",
        "\n",
        "def decompress_1(audio):\n",
        "  try:\n",
        "    print(audio[0].name)\n",
        "  except:\n",
        "     \n",
        "    np.save(\"garbge/1.npy\",np.zeros((512,512)))\n",
        "    return 'The operation failed for unkonwn or corrupt input type','garbge/1.npy'\n",
        "  file_name=[]\n",
        "  for i in audio:\n",
        "    names=\"\"\n",
        "    selfix=i.orig_name.split(\".\")[-1]\n",
        "    names=re.sub('[^a-zA-Z1-9]+', '', i.orig_name.split(\".\")[0])\n",
        "    names=names+\".\"+selfix\n",
        "    if not names.split(\".\")[1]=='ecdc':\n",
        "      np.save('garbge/1.npy',np.zeros((512,512)))\n",
        "      return f\"This file {i.orig_name} is not compatiable \",'garbge/1.npy'\n",
        "  \n",
        "    shutil.copyfile(i.name ,\"input/temp/\"+ names)\n",
        "    shutil.copyfile(i.name ,\"input/\"+names)\n",
        "    file_name.append(names)\n",
        "  text=\"\"\"\"\"\"\n",
        "\n",
        "  input_data=os.listdir('input/temp')\n",
        "  try:\n",
        "    input_data.remove('.ipynb_checkpoints')\n",
        "  except:\n",
        "    pass\n",
        "  output_ecdc=[ i.split(\".\")[0] for i in input_data ]\n",
        "  print(input_data,output_ecdc)\n",
        "  for i , j in zip(input_data,output_ecdc):\n",
        "      text=text+f\"\"\"python -m encodec input/temp/{i} decompressed/temp/decompressed_{j}.wav -f\n",
        "  \"\"\"\n",
        "  t1=t.time()\n",
        "  cur_st=subprocess.call(text, shell=True,stderr=subprocess.STDOUT)\n",
        "  t2=t.time()\n",
        "\n",
        "\n",
        "  if cur_st==1:\n",
        "    np.save('garbge/1.npy',np.zeros((512,512)))\n",
        "\n",
        "\n",
        "    return 'The operation failed for unkonwn or corrupt input type','garbge/1.npy'\n",
        "  input_data=os.listdir('input/temp')\n",
        "  try:\n",
        "    input_data.remove('.ipynb_checkpoints')\n",
        "  except:\n",
        "    pass\n",
        "  for k in input_data:\n",
        "    os.remove('input/temp/'+k)\n",
        "  input_data_dec=os.listdir('decompressed/temp')\n",
        "  try:\n",
        "    input_data.remove('.ipynb_checkpoints')\n",
        "  except:\n",
        "    pass\n",
        "  for i in   input_data_dec:                                                                       \n",
        "    src = f\"decompressed/temp/{i}\"\n",
        "    dst = f\"decompressed/{i.split('.')[0]}.mp3\"\n",
        "    sound = AudioSegment.from_mp3(src)\n",
        "    sound.export(dst, format=\"mp3\")\n",
        "  # convert wav to mp3                                                            \n",
        "  \n",
        " \n",
        "  output_list=[f'decompressed/decompressed_{i}.mp3' for i in output_ecdc]\n",
        "  return f'time to complete compression {round(t2-t1,2)} s',output_list\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "def compress_play(audio):\n",
        "  try:\n",
        "    print(audio.name)\n",
        "  except:\n",
        "     \n",
        "    np.save(\"garbge/1.npy\",np.zeros((512,512)))\n",
        "    return 'The operation failed for unkonwn or corrupt input type','garbge/1.npy'\n",
        "  sounds=['mp3','wav','ogg']\n",
        "  print(\"done uploading\")\n",
        "  names=\"\"\n",
        "  selfix=audio.orig_name.split(\".\")[-1]\n",
        "  names=re.sub('[^a-zA-Z1-9]+', '', audio.orig_name.split(\".\")[0])\n",
        "  names=names+\".\"+selfix\n",
        "  if not names.split(\".\")[-1] in sounds:\n",
        "        np.save('garbge/1.npy',np.zeros((512,512)))\n",
        "\n",
        "        return f'The file {names} is not combaiable','garbge/1.npy'\n",
        "  file_name=[]\n",
        "  input_files_sizes=[os.path.getsize(audio.name)]\n",
        "  shutil.copyfile(audio.name ,\"input/temp/\"+ names)\n",
        "  shutil.copyfile(audio.name ,\"input/\"+ names)\n",
        "  file_name.append(names)\n",
        "  text=\"\"\"\"\"\"\n",
        "  \n",
        "  input_data=os.listdir('input/temp')\n",
        "  try:\n",
        "    input_data.remove('.ipynb_checkpoints')\n",
        "  except:\n",
        "    pass\n",
        "  output_ecdc=[ i.split(\".\")[0] for i in input_data ]\n",
        "\n",
        "  for i , j in zip(input_data,output_ecdc):\n",
        "      text=text+f\"\"\"python -m encodec input/temp/{i} compressed/temp/compressed_{j}.ecdc -f\n",
        "  \"\"\"\n",
        "  \n",
        "  print('started compressing')\n",
        "  t1=t.time()\n",
        "  print(text,output_ecdc,input_data)\n",
        "  cur_st=subprocess.call(text, shell=True,stderr=subprocess.STDOUT)\n",
        "  t2=t.time()\n",
        "  print(\"done compressing\")\n",
        "  input_data=os.listdir('compressed/temp')\n",
        "  try:\n",
        "    input_data.remove('.ipynb_checkpoints')\n",
        "  except:\n",
        "    pass\n",
        "\n",
        "  if cur_st==1:\n",
        "    np.save('garbge/1.npy',np.zeros((512,512)))\n",
        "\n",
        "\n",
        "    return 'The operation failed for unkonwn or corrupt input type','garbge/1.npy'\n",
        "  ####\n",
        "  input_data=os.listdir('compressed/temp')\n",
        "  try:\n",
        "    input_data.remove('.ipynb_checkpoints')\n",
        "  except:\n",
        "    pass\n",
        "  for k in input_data:\n",
        "    shutil.copyfile('compressed/temp/'+k ,\"compressed/\"+k)\n",
        "  input_data=os.listdir('input/temp')\n",
        "  try:\n",
        "    input_data.remove('.ipynb_checkpoints')\n",
        "  except:\n",
        "    pass\n",
        "  for i in input_data:\n",
        "    os.remove('input/temp/'+i)\n",
        "  output_list=[f'compressed/temp/compressed_{i}.ecdc' for i in output_ecdc]\n",
        "  output_files_sizes=[os.path.getsize(f'compressed/temp/compressed_{i}.ecdc') for i in output_ecdc]\n",
        "  details=\"\"\"\"\"\"\n",
        "  comp_ratio=[float(100-(i/(j/100))) for j,i in zip(input_files_sizes,output_files_sizes) ]\n",
        "  for i,j,k,m in zip(file_name,input_files_sizes,output_files_sizes,comp_ratio):\n",
        "    details =details+i+'\\n'+f'time to complete the compression {round(t2-t1,2)} s \\n  file size before compresion {round(j/1024,2)} kb \\n file size after compression {round(k/1024,2)}  kb  \\n ratio of space saved {round(m,2) } % \\n'\n",
        "\n",
        "  return details,output_list\n",
        "\n",
        "def decompress_play(file_name):\n",
        " \n",
        "  text=\"\"\"\"\"\"\n",
        "  input_data=os.listdir('compressed/temp')\n",
        "  try:\n",
        "    input_data.remove('.ipynb_checkpoints')\n",
        "  except:\n",
        "    pass\n",
        "\n",
        "  if len(input_data)==0:\n",
        "    np.save('garbge/1.npy',np.zeros((512,512)))\n",
        "\n",
        "\n",
        "    return 'The operation failed for unkonwn or corrupt input type','garbge/1.npy','garbge/1.npy'\n",
        "  output_ecdc=[ i.split(\".\")[0] for i in input_data ]\n",
        "\n",
        "  for i , j in zip(input_data,output_ecdc):\n",
        "      text=text+f\"\"\"python -m encodec compressed/temp/{i} decompressed/temp/decompressed_{j}.wav -f\n",
        "  \"\"\"\n",
        "  t1=t.time()\n",
        "  cur_st=subprocess.call(text, shell=True,stderr=subprocess.STDOUT)\n",
        "  t2=t.time()\n",
        "  input_data=os.listdir('compressed/temp')\n",
        "  try:\n",
        "    input_data.remove('.ipynb_checkpoints')\n",
        "  except:\n",
        "    pass\n",
        "  for k in input_data:\n",
        "    os.remove('compressed/temp/'+k)\n",
        "\n",
        "  input_data_dec=os.listdir(\"decompressed/temp\")\n",
        "  try:\n",
        "    input_data_dec.remove('.ipynb_checkpoints')\n",
        "  except:\n",
        "    pass\n",
        "  for i in   input_data_dec:                                                                       \n",
        "    src = f\"decompressed/temp/{i}\"\n",
        "    dst = f\"decompressed/{i.split('.')[0]}.mp3\"\n",
        "    sound = AudioSegment.from_mp3(src)\n",
        "    sound.export(dst, format=\"mp3\")\n",
        "  # convert wav to mp3                                                            \n",
        "  \n",
        "\n",
        "\n",
        "  output_list=[f'decompressed/decompressed_{i}.mp3' for i in output_ecdc]\n",
        "  \n",
        "  return f'time to complete decompression {round(t2-t1,2)} s',output_list[0],output_list[0]\n",
        "\n",
        "def decompress_1_play(audio):\n",
        "  try:\n",
        "    print(audio.name)\n",
        "  except:\n",
        "     \n",
        "    np.save(\"garbge/1.npy\",np.zeros((512,512)))\n",
        "    return 'The operation failed for unkonwn or corrupt input type','garbge/1.npy','garbge/1.npy'\n",
        "  sounds=['mp3','wav','ogg']\n",
        "  print(\"done uploading\")\n",
        "  names=\"\"\n",
        "  selfix=audio.orig_name.split(\".\")[-1]\n",
        "  names=re.sub('[^a-zA-Z1-9]+', '', audio.orig_name.split(\".\")[0])\n",
        "  names=names+\".\"+selfix\n",
        "  if not names.split(\".\")[1]=='ecdc':  \n",
        "        np.save('garbge/1.npy',np.zeros((512,512)))\n",
        "\n",
        "        return f'The file {names} is not combaiable','garbge/1.npy','garbge/1.npy'\n",
        "  file_name=[]\n",
        "\n",
        "  \n",
        "\n",
        "  shutil.copyfile(audio.name ,\"input/temp/\"+ names)\n",
        "  shutil.copyfile(audio.name ,\"input/\"+ names)\n",
        "  file_name.append(names)\n",
        "  text=\"\"\"\"\"\"\n",
        "\n",
        "  input_data=os.listdir('input/temp')\n",
        "  try:\n",
        "    input_data.remove('.ipynb_checkpoints')\n",
        "  except:\n",
        "    pass\n",
        "  output_ecdc=[ i.split(\".\")[0] for i in input_data ]\n",
        "  print(input_data,output_ecdc)\n",
        "  for i , j in zip(input_data,output_ecdc):\n",
        "      text=text+f\"\"\"python -m encodec input/temp/{i} decompressed/temp/decompressed_{j}.wav -f\n",
        "  \"\"\"\n",
        "  t1=t.time()\n",
        "  cur_st= subprocess.call(text, shell=True,stderr=subprocess.STDOUT)\n",
        "  t2=t.time()\n",
        "  if cur_st==1:\n",
        "    np.save('garbge/1.npy',np.zeros((512,512)))\n",
        "\n",
        "\n",
        "    return 'The operation failed for unkonwn or corrupt input type','garbge/1.npy','garbge/1.npy'\n",
        "  input_data=os.listdir('input/temp')\n",
        "  try:\n",
        "    input_data.remove('.ipynb_checkpoints')\n",
        "  except:\n",
        "    pass\n",
        "  for k in input_data:\n",
        "    os.remove('input/temp/'+k)\n",
        "  input_data_dec=os.listdir(\"decompressed/temp\")\n",
        "  try:\n",
        "    input_data_dec.remove('.ipynb_checkpoints')\n",
        "  except:\n",
        "    pass\n",
        "\n",
        "  for i in   input_data_dec:                                                                       \n",
        "    src = f\"decompressed/temp/{i}\"\n",
        "    dst = f\"decompressed/{i.split('.')[0]}.mp3\"\n",
        "    sound = AudioSegment.from_mp3(src)\n",
        "    sound.export(dst, format=\"mp3\")\n",
        "  # convert wav to mp3                                                            \n",
        "  input_data=os.listdir('compressed/temp')\n",
        "  try:\n",
        "    input_data.remove('.ipynb_checkpoints')\n",
        "  except:\n",
        "    pass\n",
        "  for k in input_data:\n",
        "    os.remove('compressed/temp/'+k)\n",
        "  output_list=[f'decompressed/decompressed_{i}.mp3' for i in output_ecdc]\n",
        "\n",
        "  return f'time to complete decompression {round(t2-t1,2)} s',output_list[0],output_list[0]\n",
        "def large_comp(audio):\n",
        "\n",
        "  print(\"done uploading\")\n",
        "  #file_name=audio.orig_name\n",
        "  selfix=audio.split(\".\")[-1]\n",
        "  names=\"\"\n",
        "  names=re.sub('[^a-zA-Z1-9]+', '', audio.split(\".\")[0])\n",
        "  names=names+\".\"+selfix\n",
        "  file_name=[names]\n",
        "  shutil.copyfile(f\"/content/drive/MyDrive/sounds/{audio}\",\"input/temp/\"+ f'{names}')\n",
        "  shutil.copyfile(\"input/temp/\"+ f'{names}',\"input/\"+ f'{names}')\n",
        "  input_files_sizes=[os.path.getsize(f\"input/temp/{names}\")]\n",
        "\n",
        "  text=\"\"\"\"\"\"\n",
        "  \n",
        "  input_data=file_name\n",
        "  try:\n",
        "    input_data.remove('.ipynb_checkpoints')\n",
        "  except:\n",
        "    pass\n",
        "  output_ecdc=[ i.split(\".\")[0] for i in input_data ]\n",
        "\n",
        "  for i , j in zip(input_data,output_ecdc):\n",
        "      text=text+f\"\"\"python -m encodec input/temp/{i} compressed/temp/compressed_{j}.ecdc -f\n",
        "  \"\"\"\n",
        "  print('started compressing')\n",
        "  t1=t.time()\n",
        "  curt_st=subprocess.call(text, shell=True,stderr=subprocess.STDOUT)\n",
        "  t2=t.time()\n",
        "  print(\"done compressing\")\n",
        "  if curt_st==1:\n",
        "    np.save('garbge/1.npy',np.zeros((512,512)))\n",
        "\n",
        "\n",
        "    return \"\",'The operation failed for unkonwn or corrupt input type','garbge/1.npy','garbge/1.npy','garbge/1.npy'\n",
        "  ####\n",
        "  input_data=[i for i in os.listdir('compressed/temp') if i!=\".ipynb_checkpoints\"]\n",
        " \n",
        "  for k in input_data:\n",
        "    shutil.copyfile('compressed/temp/'+k ,\"compressed/\"+k)\n",
        "  input_data=os.listdir('input/temp')\n",
        "  try:\n",
        "      input_data.remove('.ipynb_checkpoints')\n",
        "  except:\n",
        "      pass\n",
        "  for i in input_data:\n",
        "    os.remove('input/temp/'+i)\n",
        "  output_list_COMP=[f'compressed/compressed_{i}.ecdc' for i in output_ecdc]\n",
        "  output_files_sizes=[os.path.getsize(f'compressed/temp/compressed_{i}.ecdc') for i in output_ecdc]\n",
        "  details=\"\"\"\"\"\"\n",
        "  comp_ratio=[float(100-(i/(j/100))) for j,i in zip(input_files_sizes,output_files_sizes) ]\n",
        "  for i,j,k,m in zip(file_name,input_files_sizes,output_files_sizes,comp_ratio):\n",
        "    details =details+i+'\\n'+f'time to complete the compression {round(t2-t1,2)} s \\n  file size before compresion {round(j/1024,2)} kb \\n file size after compression {round(k/1024,2)}  kb  \\n ratio of space saved {round(m,2) } % \\n'\n",
        "  text=\"\"\"\"\"\"\n",
        "\n",
        "\n",
        "  for i , j in zip(output_ecdc,output_ecdc):\n",
        "      text=text+f\"\"\"python -m encodec compressed/temp/compressed_{i}.ecdc decompressed/temp/decompressed_{j}.wav -f\n",
        "  \"\"\"\n",
        "  t1=t.time()\n",
        "  print('started_decompresings')\n",
        "  curt_st=subprocess.call(text, shell=True,stderr=subprocess.STDOUT)\n",
        "  t2=t.time()\n",
        "  if curt_st==1:\n",
        "    np.save('garbge/1.npy',np.zeros((512,512)))\n",
        "\n",
        "\n",
        "    return \"\",'The operation failed for unkonwn or corrupt input type','garbge/1.npy','garbge/1.npy','garbge/1.npy'\n",
        "  print('done decompressing')\n",
        "  input_data=os.listdir('compressed/temp')\n",
        "  print(input_data)\n",
        "  input_data_dec=os.listdir('decompressed/temp')\n",
        "  try:\n",
        "    input_data_dec.remove('.ipynb_checkpoints')\n",
        "  except:\n",
        "    pass\n",
        "  try:\n",
        "    input_data.remove('.ipynb_checkpoints')\n",
        "  except:\n",
        "    pass\n",
        "  print(input_data)\n",
        "  for i in   input_data_dec:                                                                       \n",
        "    src = f\"decompressed/temp/{i}\"\n",
        "    dst = f\"decompressed/{i.split('.')[0]}.mp3\"\n",
        "    sound = AudioSegment.from_mp3(src)\n",
        "    sound.export(dst, format=\"mp3\")\n",
        "  print(input_data)\n",
        "\n",
        "  for k in input_data:\n",
        "      os.remove('compressed/temp/'+k)\n",
        "\n",
        "  output_list=[f'decompressed/decompressed_{i}.mp3' for i in output_ecdc]\n",
        "  print(output_list)\n",
        "  print(details)\n",
        "  print(f'time to complete decompression {round(t2-t1,2)} s')\n",
        "  print(output_list_COMP[0])\n",
        "  print(output_list[0])\n",
        "\n",
        "  return details,f'time to complete decompression {round(t2-t1,2)} s',output_list_COMP[0],output_list[0],output_list[0]\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "metadata": {
        "collapsed": true,
        "id": "3N9V7xYJHirX",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 896
        },
        "outputId": "0b24a4bf-e0e0-4eec-dc2b-3b7b03cd2f88"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Colab notebook detected. This cell will run indefinitely so that you can see errors and logs. To turn off, set debug=False in launch().\n",
            "Note: opening Chrome Inspector may crash demo inside Colab notebooks.\n",
            "\n",
            "To create a public link, set `share=True` in `launch()`.\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ],
            "application/javascript": [
              "(async (port, path, width, height, cache, element) => {\n",
              "                        if (!google.colab.kernel.accessAllowed && !cache) {\n",
              "                            return;\n",
              "                        }\n",
              "                        element.appendChild(document.createTextNode(''));\n",
              "                        const url = await google.colab.kernel.proxyPort(port, {cache});\n",
              "\n",
              "                        const external_link = document.createElement('div');\n",
              "                        external_link.innerHTML = `\n",
              "                            <div style=\"font-family: monospace; margin-bottom: 0.5rem\">\n",
              "                                Running on <a href=${new URL(path, url).toString()} target=\"_blank\">\n",
              "                                    https://localhost:${port}${path}\n",
              "                                </a>\n",
              "                            </div>\n",
              "                        `;\n",
              "                        element.appendChild(external_link);\n",
              "\n",
              "                        const iframe = document.createElement('iframe');\n",
              "                        iframe.src = new URL(path, url).toString();\n",
              "                        iframe.height = height;\n",
              "                        iframe.allow = \"autoplay; camera; microphone; clipboard-read; clipboard-write;\"\n",
              "                        iframe.width = width;\n",
              "                        iframe.style.border = 0;\n",
              "                        element.appendChild(iframe);\n",
              "                    })(7860, \"/\", \"100%\", 500, false, window.element)"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "/tmp/setuper3lxe4o.cfg\n",
            "done uploading\n",
            "/tmp/architecture7u_sjgvy.ecdc\n",
            "done uploading\n",
            "['architecture.ecdc'] ['architecture']\n",
            "/tmp/setup_z1mkmv3.cfg\n",
            "done uploading\n",
            "/tmp/architecturezhcq1atd.wav\n",
            "done uploading\n",
            "started compressing\n",
            "python -m encodec input/temp/architecture.ecdc compressed/temp/compressed_architecture.ecdc -f\n",
            "  python -m encodec input/temp/architecture.wav compressed/temp/compressed_architecture.ecdc -f\n",
            "   ['architecture', 'architecture'] ['architecture.ecdc', 'architecture.wav']\n",
            "done compressing\n",
            "Keyboard interruption in main thread... closing server.\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": []
          },
          "metadata": {},
          "execution_count": 16
        }
      ],
      "source": [
        "#@title interface\n",
        "accepted_selfixs=['mp3','wav','ogg','m4a']\n",
        "sound_files=[i for i in os.listdir('/content/drive/MyDrive/sounds') if i.split(\".\")[1] in accepted_selfixs]\n",
        "\n",
        "\n",
        "with gr.Blocks() as demo:\n",
        "  \n",
        "  gr.Markdown(\"\"\"<center>   <span style=\"font-family:Times New Roman; color:red;font-size:4em;\">         Audio compression using neural networks</span>\n",
        "                \"\"\")\n",
        "        \n",
        "\n",
        "  with gr.Tab(\" Compress And Decompress \"):\n",
        "    with gr.Row():\n",
        "        with gr.Column():\n",
        "            input = gr.File(label=\"insert multiple  files\",file_count='multiple')\n",
        "        with gr.Column():\n",
        "            comp = gr.Button(value=\"Compress\")\n",
        "            decomp = gr.Button(value=\"DeCompress\")\n",
        "    with gr.Row():\n",
        "            output_text_com = gr.Textbox(label=\"Compression details\")\n",
        "    with gr.Row():\n",
        "            output_text_decom = gr.Textbox(label=\"DeCompression details\")\n",
        "    with gr.Row():\n",
        "        with gr.Column():\n",
        "            output_file=gr.File(label=\"ecdc file\",file_count='multiple')\n",
        "        with gr.Column():\n",
        "            output_file_1=gr.File(label=\"wav file\")\n",
        "    with gr.Row():\n",
        "        with gr.Column():\n",
        "            input_1 = gr.File(label=\"insert file\",file_count='multiple')\n",
        "        with gr.Column():\n",
        "            decomp_1 = gr.Button(value=\"DeCompress\")\n",
        "    with gr.Row():\n",
        "        with gr.Column():\n",
        "            output_text_1_decom = gr.Textbox(label=\"DeCompression details\")\n",
        "        with gr.Column():\n",
        "            output_file_2=gr.File(label=\"wav file\")\n",
        "    \n",
        "  with gr.Tab(\" Compress And Decompress and play \"):\n",
        "    with gr.Row():\n",
        "        with gr.Column():\n",
        "            input_play = gr.File(label=\"insert file\",file_count='single')\n",
        "        with gr.Column():\n",
        "            comp_play = gr.Button(value=\"Compress\")\n",
        "            decomp_play = gr.Button(value=\"DeCompress\")\n",
        "    with gr.Row():\n",
        "        \n",
        "\n",
        "            output_text_play_com = gr.Textbox(label=\"Compression details\")\n",
        "    with gr.Row():\n",
        "        \n",
        "\n",
        "            output_text_play_decom = gr.Textbox(label=\"DeCompression details\")\n",
        "    with gr.Row():\n",
        "        with gr.Column():\n",
        "            output_file_play=gr.File(label=\"ecdc file\")\n",
        "        with gr.Column():\n",
        "            output_file_1_play=gr.Audio(label=\"wav file\")\n",
        "            output_file_11_play=gr.File(label='wav file')\n",
        "    with gr.Row():\n",
        "        with gr.Column():\n",
        "            input_1_play = gr.File(label=\"insert file\",file_count='single')\n",
        "        with gr.Column():\n",
        "            decomp_1_play = gr.Button(value=\"DeCompress\")\n",
        "    with gr.Row():\n",
        "        with gr.Column():\n",
        "            output_text_1_play_decom = gr.Textbox(label=\"Decompression Details\")\n",
        "        with gr.Column():\n",
        "            output_file_2_play=gr.Audio(label=\"wav file\")    \n",
        "            output_file_22_play=gr.File(label=\"wav file\")    \n",
        "\n",
        "  with gr.Tab(\"large files\"):\n",
        "    with gr.Row():\n",
        "      with gr.Column():\n",
        "        large_input=gr.Dropdown(sound_files)\n",
        "      with gr.Column():\n",
        "        large_comp1=gr.Button(label='compress files')\n",
        "    with gr.Row():\n",
        "      l_text=gr.Textbox(label=\"Compression details\")\n",
        "      l_text_2=gr.Textbox(label=\"DeCompression details\")\n",
        "      l_file=gr.File(label='ecdc file')\n",
        "      l_wav_file=gr.Audio(label='wav file')\n",
        "      l_file_file=gr.File(label='wav file')\n",
        "    comp.click(compress, inputs=input, outputs=[output_text_com,output_file] )\n",
        "    decomp.click(decompress, inputs=output_file, outputs=[output_text_decom,output_file_1] )\n",
        "    decomp_1.click(decompress_1, inputs=input_1, outputs=[output_text_1_decom,output_file_2] )\n",
        "\n",
        "    comp_play.click(compress_play, inputs=input_play, outputs=[output_text_play_com,output_file_play] )\n",
        "    decomp_play.click(decompress_play, inputs=output_file_play, outputs=[output_text_play_decom,output_file_1_play,output_file_11_play] )\n",
        "    decomp_1_play.click(decompress_1_play, inputs=input_1_play, outputs=[output_text_1_play_decom,output_file_2_play,output_file_22_play] )\n",
        "    large_comp1.click(large_comp,inputs=large_input,outputs=[l_text,l_text_2,l_file,l_wav_file,l_file_file])\n",
        "\n",
        "demo..queue().launch(debug=True)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "GTUWIvS7hR0z"
      },
      "outputs": [],
      "source": [
        "#@title record audio interface \n",
        "import gradio as gr\n",
        "import numpy as np\n",
        "from scipy.io.wavfile import write\n",
        "from datetime import datetime\n",
        "import gradio as gr\n",
        "import time as t\n",
        "import shutil\n",
        "import subprocess\n",
        "from scipy.io.wavfile import write\n",
        "import os\n",
        "import numpy as np\n",
        "from datetime import datetime\n",
        "os.makedirs(\"input/temp\",exist_ok=True)\n",
        "os.makedirs(\"compressed/temp\",exist_ok=True)\n",
        "os.makedirs('decompressed',exist_ok=True)\n",
        "def reverse_audio(audio):\n",
        "  sr,data=audio\n",
        "  now = datetime.now()\n",
        "\n",
        "  current_time = now.strftime(\"%H:%M:%S\")\n",
        "  temp_name=str(current_time).replace(\":\",\"_\")\n",
        "  write(f\"input/temp/record_{temp_name}.wav\", sr, data.astype(np.int32))\n",
        "  print(\"done uploading\")\n",
        "  #file_name=audio.orig_name\n",
        "  file_name=[f'record_{temp_name}.wav']\n",
        "  input_files_sizes=[os.path.getsize(f\"input/temp/record_{temp_name}.wav\")]\n",
        "  shutil.copyfile(f\"input/temp/record_{temp_name}.wav\",\"input/\"+ f'record_{temp_name}.wav')\n",
        "  text=\"\"\"\"\"\"\n",
        "  \n",
        "  input_data=os.listdir('input/temp')\n",
        "  try:\n",
        "    input_data.remove('.ipynb_checkpoints')\n",
        "  except:\n",
        "    pass\n",
        "  output_ecdc=[ i.split(\".\")[0] for i in input_data ]\n",
        "\n",
        "  for i , j in zip(input_data,output_ecdc):\n",
        "      text=text+f\"\"\"python -m encodec input/temp/{i} compressed/temp/compressed_{j}.ecdc -f\n",
        "  \"\"\"\n",
        "  print('started compressing')\n",
        "  t1=t.time()\n",
        "  subprocess.call(text, shell=True,stderr=subprocess.STDOUT)\n",
        "  t2=t.time()\n",
        "  print(\"done compressing\")\n",
        "  \n",
        "  ####\n",
        "  input_data=os.listdir('compressed/temp')\n",
        "  try:\n",
        "    input_data.remove('.ipynb_checkpoints')\n",
        "  except:\n",
        "    pass\n",
        "  for k in input_data:\n",
        "    shutil.copyfile('compressed/temp/'+k ,\"compressed/\"+k)\n",
        "  input_data=os.listdir('input/temp')\n",
        "\n",
        "  for i in input_data:\n",
        "    os.remove('input/temp/'+i)\n",
        "  output_list_COMP=[f'compressed/compressed_{i}.ecdc' for i in output_ecdc]\n",
        "  output_files_sizes=[os.path.getsize(f'compressed/temp/compressed_{i}.ecdc') for i in output_ecdc]\n",
        "  details=\"\"\"\"\"\"\n",
        "  comp_ratio=[float(100-(j/(i/100))) for j,i in zip(input_files_sizes,output_files_sizes) ]\n",
        "  for i,j,k,m in zip(file_name,input_files_sizes,output_files_sizes,comp_ratio):\n",
        "    details =details+i+'\\n'+f'time to complete the compression {round(t2-t1,2)} s \\n  file size before compresion {round(j/1024,2)} kb \\n file size after compression {round(k/1024,2)}  kb  \\n ratio of space saved {round(m,2) } % \\n'\n",
        "  text=\"\"\"\"\"\"\n",
        "  input_data=os.listdir('compressed/temp')\n",
        "  try:\n",
        "    input_data.remove('.ipynb_checkpoints')\n",
        "  except:\n",
        "    pass\n",
        "  output_ecdc=[ i.split(\".\")[0] for i in input_data ]\n",
        "\n",
        "  for i , j in zip(input_data,output_ecdc):\n",
        "      text=text+f\"\"\"python -m encodec compressed/temp/{i} decompressed/decompressed_{j}.wav -f\n",
        "  \"\"\"\n",
        "  t1=t.time()\n",
        "  subprocess.call(text, shell=True,stderr=subprocess.STDOUT)\n",
        "  t2=t.time()\n",
        "  input_data=os.listdir('compressed/temp')\n",
        "  try:\n",
        "    input_data.remove('.ipynb_checkpoints')\n",
        "  except:\n",
        "    pass\n",
        "  for k in input_data:\n",
        "    os.remove('compressed/temp/'+k)\n",
        "  output_list=[f'decompressed/decompressed_{i}.wav' for i in output_ecdc]\n",
        "  \n",
        "   \n",
        "\n",
        "  return details,f'time to complete decompression {round(t2-t1,2)} s',output_list_COMP[0],output_list[0]\n",
        "\n",
        "demo = gr.Interface(fn=reverse_audio, \n",
        "                    inputs=\"microphone\", \n",
        "                    outputs=['text','text','file',\"audio\"] )\n",
        "demo.queue().launch(debug=True)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!pip3 freeze > requirements.txt"
      ],
      "metadata": {
        "id": "3LE4YVFOeL3y"
      },
      "execution_count": null,
      "outputs": []
    }
  ],
  "metadata": {
    "colab": {
      "provenance": []
    },
    "gpuClass": "standard",
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}