Auto_python_book.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "view-in-github"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/akiitr/python0/blob/master/Auto_python_book.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "vn8zSEEQUimw"
      },
      "source": [
        "##Automating Boring stuff with python cheat sheet! [Go here](https://drive.google.com/file/d/11sMQwfAER1dN63bhP1yqVinzXWlxXvt3/view) "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "n85gDg8kqXor"
      },
      "source": [
        "###Designing A GUI for the application of the Lomash sir project"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 369
        },
        "colab_type": "code",
        "id": "DDfYVxacOiXT",
        "outputId": "43ae3d5e-16b3-464f-9d18-7905c46750c3"
      },
      "outputs": [
        {
          "ename": "TclError",
          "evalue": "ignored",
          "output_type": "error",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTclError\u001b[0m                                  Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-1-36fb5fd932e5>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;31m#creating a base window of desired size\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m \u001b[0mwindow\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtk\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mTk\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      6\u001b[0m \u001b[0mwindow\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtitle\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Analysis and Plotting tool\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      7\u001b[0m \u001b[0mwindow\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgeometry\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"500x500\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/lib/python3.6/tkinter/__init__.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, screenName, baseName, className, useTk, sync, use)\u001b[0m\n\u001b[1;32m   2021\u001b[0m                 \u001b[0mbaseName\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mbaseName\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mext\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2022\u001b[0m         \u001b[0minteractive\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2023\u001b[0;31m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtk\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_tkinter\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcreate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mscreenName\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbaseName\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mclassName\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minteractive\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mwantobjects\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0museTk\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msync\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0muse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   2024\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0museTk\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2025\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_loadtk\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mTclError\u001b[0m: no display name and no $DISPLAY environment variable"
          ]
        }
      ],
      "source": [
        "\n",
        "import tkinter as tk\n",
        "\n",
        "#creating a base window of desired size\n",
        "window = tk.Tk()\n",
        "window.title(\"Analysis and Plotting tool\")\n",
        "window.geometry(\"500x500\")\n",
        "window.resizable(0,0) #doesn't allow to resize\n",
        "\n",
        "#Defining the layout of the window\n",
        "label1 = tk.Label(window, text=\"Analysis and Plotting tool\", font=(\"calibre\",20,\"bold\"))\n",
        "label1.pack()\n",
        "\n",
        "window.mainloop()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "eug8CvTK9jx-"
      },
      "source": [
        "###SIde Project for curve-fitiing for lomash sir "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "colab_type": "code",
        "id": "nSpc0Jps9jp_",
        "outputId": "cd67010a-3964-48c8-9246-383625c667a5"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Populating the interactive namespace from numpy and matplotlib\n"
          ]
        }
      ],
      "source": [
        "%pylab inline\n",
        "from scipy.optimize import curve_fit\n",
        "import pandas as pd\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {},
        "colab_type": "code",
        "id": "ti966uKIYETa"
      },
      "outputs": [],
      "source": [
        "#going for buffer scropting\n",
        "\n",
        "# tcp_vs_cl bff\n",
        "\n",
        "d = pd.read_excel()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 416
        },
        "colab_type": "code",
        "id": "mK42ySTfIj6J",
        "outputId": "9d7d86cc-b49c-4b91-dfae-19e31f122264"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "m: 5.58 +/- 0.20\n",
            "p: 845.10 +/- 11.54\n",
            "a: 678.11 +/- 2.76\n",
            "b: -8784.35 +/- 272.92\n",
            "c: 4712.52 +/- 48.42\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/pandas/core/series.py:856: RuntimeWarning: invalid value encountered in sqrt\n",
            "  result = getattr(ufunc, method)(*inputs, **kwargs)\n"
          ]
        },
        {
          "data": {
            "text/plain": [
              "Text(0.5, 0.2, 'chi-square2: 1.17')"
            ]
          },
          "execution_count": 4,
          "metadata": {
            "tags": []
          },
          "output_type": "execute_result"
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "#reading the excel file\n",
        "d = pd.read_excel(\"tcp_vs_cl.xlsx\")\n",
        "\n",
        "#Text processing on the data using pandas dataframe\n",
        "#no of row and column\n",
        "row, col = d.shape\n",
        "#no of total elements in whole dataframe\n",
        "#tot_elements = d.size\n",
        "#No of elements in a row\n",
        "#no_row = d['cl'].size\n",
        "#print(no_row)\n",
        "#anything above is not required as row will give the no of values in the cl\n",
        "\n",
        "#adding a standard deviation column for better fit\n",
        "std = 0.5\n",
        "op_std = std + rand(row)*std/10\n",
        "d['op_std'] = op_std\n",
        "\n",
        "#Define the break up point\n",
        "trb = 50\n",
        "d1 = d.loc[d['cl'] >= trb]\n",
        "d2 = d.loc[d['cl'] <  trb]\n",
        "\n",
        "##After taking the whole range of the data\n",
        "\n",
        "#  Fit by equation\n",
        "\n",
        "# setting up the model equation\n",
        "\n",
        "def model1(x,m,p):\n",
        "    return (m*x)+p\n",
        "\n",
        "def model2(x,a,b,c):\n",
        "    return a+sqrt(b+(c*x))\n",
        "\n",
        "# Going with fit\n",
        "#initially guessing the values diiferent based on different condition\n",
        "init_guess_m1 = [-1,1]\n",
        "\n",
        "init_guess_m2 = [-5000,1e7,1e5]\n",
        "\n",
        "\n",
        "#fit = curve_fit(model, d['cl'],d['tcp'],sigma=d['s_tcp'], p0=init_guess, absolute_sigma=True)\n",
        "#fit for model 1\n",
        "fit1 = curve_fit(model1, d['cl'],d['tcp'], p0=init_guess_m1)\n",
        "\n",
        "#fit for model 2\n",
        "fit2 = curve_fit(model2, d['cl'],d['tcp'], p0=init_guess_m2)\n",
        "\n",
        "# unpacking the fit results for model1:\n",
        "ans,cov = fit1\n",
        "fit_m,fit_p = ans\n",
        "fit_sm,fit_sp = sqrt(diag(cov))\n",
        "\n",
        "# printing the fit results for model1:\n",
        "print(\"m: %.2f +/- %.2f\"%(fit_m,fit_sm))\n",
        "print(\"p: %.2f +/- %.2f\"%(fit_p,fit_sp))\n",
        "\n",
        "# unpacking the fit results for model2:\n",
        "ans,cov = fit2\n",
        "fit_a,fit_b,fit_c = ans\n",
        "fit_sa,fit_sb,fit_sc = sqrt(diag(cov))\n",
        "\n",
        "# printing the fit results model2:\n",
        "print(\"a: %.2f +/- %.2f\"%(fit_a,fit_sa))\n",
        "print(\"b: %.2f +/- %.2f\"%(fit_b,fit_sb))\n",
        "print(\"c: %.2f +/- %.2f\"%(fit_c,fit_sc))\n",
        "\n",
        "\n",
        "\n",
        "# ploting the data and fit results\n",
        "errorbar(d['cl'],d['tcp'],fmt='b.', label=\"data\")\n",
        "xlabel(\"cl (ff)\")\n",
        "ylabel(\"tcp (s)\")\n",
        "\n",
        "#t = linspace(1,100,50, dtype=int)\n",
        "t = array([int(x*2) for x in range(1, 51)])\n",
        "\n",
        "plot(t,model1(t,fit_m,fit_p), label=\"model1\")\n",
        "plot(t,model2(t,fit_a,fit_b, fit_c), label=\"model2\")\n",
        "legend()\n",
        "\n",
        "# computing chi-square\n",
        "# Compute the value of Chi-Square goodness of fit test using the following formula:\n",
        "# Chi-Square = ( (E-O)**2 / E )\n",
        "# Where, Chi-Square = goodness of fit test O= observed value E= expected value\n",
        "\n",
        "#chisq for model1:\n",
        "chisq1 = sum((d['tcp'] - model1(d['cl'],fit_m,fit_p))**2/d['tcp'])\n",
        "figtext(0.5,0.3,\"chi-square1: %.2f\"%chisq1,fontweight=\"bold\")\n",
        "\n",
        "#chisq for model2:\n",
        "chisq2 = sum((d['tcp'] - model2(d['cl'],fit_a,fit_b,fit_c))**2/d['tcp'])\n",
        "figtext(0.5,0.2,\"chi-square2: %.2f\"%chisq2,fontweight=\"bold\")\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 453
        },
        "colab_type": "code",
        "id": "0LX63_2HaYyE",
        "outputId": "4b99afbd-fc47-4a5c-d581-384828d154c1"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "m: 3.26 +/- 0.03\n",
            "p: 1025.53 +/- 3.09\n",
            "a: 675.78 +/- 2.84\n",
            "b: -8767.53 +/- 292.13\n",
            "c: 4769.97 +/- 51.72\n",
            "Model FAILED!!\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/pandas/core/series.py:679: RuntimeWarning: invalid value encountered in sqrt\n",
            "  result = getattr(ufunc, method)(*inputs, **kwargs)\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:117: RuntimeWarning: invalid value encountered in double_scalars\n"
          ]
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "#reading the excel file\n",
        "d = pd.read_excel(\"tcp_vs_cl.xlsx\")\n",
        "\n",
        "#Text processing on the data using pandas dataframe\n",
        "#no of row and column\n",
        "row, col = d.shape\n",
        "#no of total elements in whole dataframe\n",
        "#tot_elements = d.size\n",
        "#No of elements in a row\n",
        "#no_row = d['cl'].size\n",
        "#print(no_row)\n",
        "#anything above is not required as row will give the no of values in the cl\n",
        "\n",
        "#adding a standard deviation column for better fit\n",
        "std = 0.5\n",
        "op_std = std + rand(row)*std/10\n",
        "d['op_std'] = op_std\n",
        "\n",
        "#Define the break up point\n",
        "clb = 94\n",
        "d1 = d.loc[d['cl'] >= clb]\n",
        "d2 = d.loc[d['cl'] <  clb]\n",
        "\n",
        "##After taking the seperate range for data for model1 and model2\n",
        "\n",
        "#  Fit by equation\n",
        "\n",
        "# setting up the model equation\n",
        "\n",
        "def model1(x,m,p):\n",
        "    return (m*x)+p\n",
        "\n",
        "def model2(x,a,b,c):\n",
        "    return a+sqrt(b+(c*x))\n",
        "\n",
        "# Going with fit\n",
        "#initially guessing the values diiferent based on different condition\n",
        "init_guess_m1 = [1,1]\n",
        "\n",
        "init_guess_m2 = [-5000,1e7,1e5]\n",
        "\n",
        "\n",
        "#fit = curve_fit(model, d['cl'],d['tcp'],sigma=d['s_tcp'], p0=init_guess, absolute_sigma=True)\n",
        "#fit for model 1\n",
        "fit1 = curve_fit(model1, d1['cl'],d1['tcp'], p0=init_guess_m1)\n",
        "\n",
        "#fit for model 2\n",
        "fit2 = curve_fit(model2, d2['cl'],d2['tcp'], p0=init_guess_m2)\n",
        "\n",
        "# unpacking the fit results for model1:\n",
        "ans,cov = fit1\n",
        "fit_m,fit_p = ans\n",
        "fit_sm,fit_sp = sqrt(diag(cov))\n",
        "\n",
        "# printing the fit results for model1:\n",
        "print(\"m: %.2f +/- %.2f\"%(fit_m,fit_sm))\n",
        "print(\"p: %.2f +/- %.2f\"%(fit_p,fit_sp))\n",
        "\n",
        "# unpacking the fit results for model2:\n",
        "ans,cov = fit2\n",
        "fit_a,fit_b,fit_c = ans\n",
        "fit_sa,fit_sb,fit_sc = sqrt(diag(cov))\n",
        "\n",
        "# printing the fit results model2:\n",
        "print(\"a: %.2f +/- %.2f\"%(fit_a,fit_sa))\n",
        "print(\"b: %.2f +/- %.2f\"%(fit_b,fit_sb))\n",
        "print(\"c: %.2f +/- %.2f\"%(fit_c,fit_sc))\n",
        "\n",
        "\n",
        "\n",
        "# ploting the data and fit results\n",
        "errorbar(d['cl'],d['tcp'],fmt='b.', label=\"data\")\n",
        "xlabel(\"cl (ff)\")\n",
        "ylabel(\"tcp (s)\")\n",
        "\n",
        "\n",
        "#t = linspace(1,100,50, dtype=int)\n",
        "t = array([int(x*2) for x in range(1, 51)])\n",
        "\n",
        "#output from model 1\n",
        "y_model1 = model1(t,fit_m,fit_p) \n",
        "y_model2 = model2(t,fit_a,fit_b, fit_c)\n",
        "plot(t, y_model1, label=\"model1\")\n",
        "plot(t, y_model2, label=\"model2\")\n",
        "legend()\n",
        "\n",
        "# computing chi-square\n",
        "# Compute the value of Chi-Square goodness of fit test using the following formula:\n",
        "# Chi-Square = ( (E-O)**2 / E )\n",
        "# Where, Chi-Square = goodness of fit test O= observed value E= expected value\n",
        "\n",
        "#chisq for model1:\n",
        "chisq1 = sum((d1['tcp'] - model1(d1['cl'],fit_m,fit_p))**2/d1['tcp'])\n",
        "figtext(0.5,0.3,\"chi-square1: %.2f\"%chisq1,fontweight=\"bold\")\n",
        "\n",
        "#chisq for model2:\n",
        "chisq2 = sum((d2['tcp'] - model2(d2['cl'],fit_a,fit_b,fit_c))**2/d2['tcp'])\n",
        "figtext(0.5,0.2,\"chi-square2: %.2f\"%chisq2,fontweight=\"bold\")\n",
        "\n",
        "#Processing in a new dataframe for 2% error points which are trb's\n",
        "d_op = d\n",
        "d_op['y_model1'] = y_model1.tolist()\n",
        "d_op['y_model2'] = y_model2.tolist()\n",
        "#y_model1.tolist()\n",
        "#y_model1.shape\n",
        "#y_model2.shape\n",
        "\n",
        "#calculating the percentage difference for both model from data tcp\n",
        "d_op['pcdiff1'] =( abs( d_op['tcp'] - d_op['y_model1']) / d['tcp'] *100)\n",
        "d_op['pcdiff2'] =( abs( d_op['tcp'] - d_op['y_model2']) / d['tcp'] *100)\n",
        "\n",
        "#Finding the 2% variation point\n",
        "cl1 = d_op.loc[(d_op['pcdiff1'] > 2) & (d_op['pcdiff1'] < 2.5)]\n",
        "cl2 = d_op.loc[(d_op['pcdiff2'] > 2) & (d_op['pcdiff2'] < 2.5)]\n",
        "\n",
        "#Definig the averaging the values if multiple values come from selection\n",
        "def avg(lst): \n",
        "    return sum(lst) / len(lst)\n",
        "\n",
        "#Getting the average of the cl values to get the idea of their location\n",
        "clb1 = avg(cl1['cl'].tolist())\n",
        "clb2 = avg(cl2['cl'].tolist())\n",
        "\n",
        "#Testing wether the model has passsed or not\n",
        "if ((clb1 <= clb) & (clb2 >= clb)):\n",
        "  print('The model has Passed the test input')\n",
        "  print(\"clb: %.1f, clb1: %.1f, clb12: %.1f\"%(clb, clb1, clb2))\n",
        "else:\n",
        "  print('Model FAILED!!')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "colab_type": "code",
        "id": "0YbShC5diAW0",
        "outputId": "464ab0d2-5f2f-4a29-ff50-f1663794e44b"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Failed on trb value: 210.0\n",
            "Failed on trb value: 207.0\n",
            "Failed on trb value: 204.0\n",
            "Failed on trb value: 201.0\n",
            "Failed on trb value: 198.0\n",
            "Failed on trb value: 195.0\n",
            "Failed on trb value: 192.0\n",
            "Failed on trb value: 189.0\n",
            "Failed on trb value: 186.0\n",
            "Failed on trb value: 183.0\n",
            "Failed on trb value: 180.0\n",
            "Failed on trb value: 177.0\n",
            "Failed on trb value: 174.0\n",
            "Failed on trb value: 171.0\n",
            "Failed on trb value: 168.0\n",
            "Failed on trb value: 165.0\n",
            "Failed on trb value: 162.0\n",
            "Failed on trb value: 159.0\n",
            "Failed on trb value: 156.0\n",
            "Failed on trb value: 153.0\n",
            "Failed on trb value: 150.0\n",
            "Failed on trb value: 147.0\n",
            "Failed on trb value: 144.0\n",
            "Failed on trb value: 141.0\n",
            "Failed on trb value: 138.0\n",
            "Failed on trb value: 135.0\n",
            "Failed on trb value: 132.0\n",
            "Failed on trb value: 129.0\n",
            "Failed on trb value: 126.0\n",
            "Failed on trb value: 123.0\n",
            "Failed on trb value: 120.0\n",
            "Failed on trb value: 117.0\n",
            "Failed on trb value: 114.0\n",
            "Passed on trb value: 111.0\n",
            "m: 0.94 +/- 0.00\n",
            "p: 22.97 +/- 0.17\n",
            "a: 0.49 +/- 0.00\n",
            "b: 7.35 +/- 0.02\n",
            "Model FAILED!!\n",
            "trb: 111.0, trb1: 126.0, trb2: 199.1\n"
          ]
        },
        {
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>tr</th>\n",
              "      <th>tcp</th>\n",
              "      <th>op_std</th>\n",
              "      <th>y_model1</th>\n",
              "      <th>y_model2</th>\n",
              "      <th>pcdiff1</th>\n",
              "      <th>pcdiff2</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>0.006</td>\n",
              "      <td>22.7427</td>\n",
              "      <td>0.518349</td>\n",
              "      <td>22.974786</td>\n",
              "      <td>0.572485</td>\n",
              "      <td>1.020485</td>\n",
              "      <td>97.482776</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>3.006</td>\n",
              "      <td>25.4238</td>\n",
              "      <td>0.505406</td>\n",
              "      <td>25.781386</td>\n",
              "      <td>14.217343</td>\n",
              "      <td>1.406502</td>\n",
              "      <td>44.078608</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>6.006</td>\n",
              "      <td>28.2037</td>\n",
              "      <td>0.540148</td>\n",
              "      <td>28.587987</td>\n",
              "      <td>20.954969</td>\n",
              "      <td>1.362540</td>\n",
              "      <td>25.701349</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>9.006</td>\n",
              "      <td>31.0121</td>\n",
              "      <td>0.519147</td>\n",
              "      <td>31.394587</td>\n",
              "      <td>26.467261</td>\n",
              "      <td>1.233347</td>\n",
              "      <td>14.655051</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>12.006</td>\n",
              "      <td>33.8115</td>\n",
              "      <td>0.524684</td>\n",
              "      <td>34.201187</td>\n",
              "      <td>31.344867</td>\n",
              "      <td>1.152529</td>\n",
              "      <td>7.295250</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>...</th>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>576</th>\n",
              "      <td>1728.010</td>\n",
              "      <td>1146.0200</td>\n",
              "      <td>0.516323</td>\n",
              "      <td>1639.580319</td>\n",
              "      <td>1150.134577</td>\n",
              "      <td>43.067339</td>\n",
              "      <td>0.359032</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>577</th>\n",
              "      <td>1731.010</td>\n",
              "      <td>1147.7200</td>\n",
              "      <td>0.506612</td>\n",
              "      <td>1642.386919</td>\n",
              "      <td>1151.865888</td>\n",
              "      <td>43.099965</td>\n",
              "      <td>0.361228</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>578</th>\n",
              "      <td>1734.010</td>\n",
              "      <td>1149.4000</td>\n",
              "      <td>0.533271</td>\n",
              "      <td>1645.193519</td>\n",
              "      <td>1153.596969</td>\n",
              "      <td>43.134985</td>\n",
              "      <td>0.365144</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>579</th>\n",
              "      <td>1737.010</td>\n",
              "      <td>1151.1000</td>\n",
              "      <td>0.535960</td>\n",
              "      <td>1648.000120</td>\n",
              "      <td>1155.327821</td>\n",
              "      <td>43.167415</td>\n",
              "      <td>0.367285</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>580</th>\n",
              "      <td>1740.000</td>\n",
              "      <td>1152.7800</td>\n",
              "      <td>0.519171</td>\n",
              "      <td>1650.797365</td>\n",
              "      <td>1157.052676</td>\n",
              "      <td>43.201423</td>\n",
              "      <td>0.370641</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "<p>581 rows × 7 columns</p>\n",
              "</div>"
            ],
            "text/plain": [
              "           tr        tcp    op_std  ...     y_model2    pcdiff1    pcdiff2\n",
              "0       0.006    22.7427  0.518349  ...     0.572485   1.020485  97.482776\n",
              "1       3.006    25.4238  0.505406  ...    14.217343   1.406502  44.078608\n",
              "2       6.006    28.2037  0.540148  ...    20.954969   1.362540  25.701349\n",
              "3       9.006    31.0121  0.519147  ...    26.467261   1.233347  14.655051\n",
              "4      12.006    33.8115  0.524684  ...    31.344867   1.152529   7.295250\n",
              "..        ...        ...       ...  ...          ...        ...        ...\n",
              "576  1728.010  1146.0200  0.516323  ...  1150.134577  43.067339   0.359032\n",
              "577  1731.010  1147.7200  0.506612  ...  1151.865888  43.099965   0.361228\n",
              "578  1734.010  1149.4000  0.533271  ...  1153.596969  43.134985   0.365144\n",
              "579  1737.010  1151.1000  0.535960  ...  1155.327821  43.167415   0.367285\n",
              "580  1740.000  1152.7800  0.519171  ...  1157.052676  43.201423   0.370641\n",
              "\n",
              "[581 rows x 7 columns]"
            ]
          },
          "execution_count": 124,
          "metadata": {
            "tags": []
          },
          "output_type": "execute_result"
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "#reading the excel file\n",
        "d = pd.read_excel(\"tcp_vs_tr.xlsx\")\n",
        "\n",
        "#Text processing on the data using pandas dataframe\n",
        "#no of row and column\n",
        "row, col = d.shape\n",
        "#no of total elements in whole dataframe\n",
        "#tot_elements = d.size\n",
        "#No of elements in a row\n",
        "#no_row = d['cl'].size\n",
        "#print(no_row)\n",
        "#anything above is not required as row will give the no of values in the cl\n",
        "\n",
        "#adding a standard deviation column for better fit\n",
        "std = 0.5\n",
        "op_std = std + rand(row)*std/10\n",
        "d['op_std'] = op_std\n",
        "\n",
        "#Define the break up point\n",
        "trb = 210\n",
        "\n",
        "while trb>1:\n",
        "\n",
        "  #changed in equality than cl as model1 will be fitted on the initial data\n",
        "  d1 = d.loc[d['tr'] <= trb]\n",
        "  d2 = d.loc[d['tr'] >  trb]\n",
        "\n",
        "  ##After taking the seperate range for data for model1 and model2\n",
        "\n",
        "  #  Fit by equation\n",
        "\n",
        "  # setting up the model equation\n",
        "\n",
        "  def model1(x,m,p):\n",
        "      return m*x+p\n",
        "\n",
        "  def model2(x,a,b):\n",
        "      return (a*x)+b*sqrt(x)\n",
        "\n",
        "  # Going with fit\n",
        "  #initially guessing the values diiferent based on different condition\n",
        "  init_guess_m1 = [1,1]\n",
        "\n",
        "  init_guess_m2 = [-5000,1e7]\n",
        "\n",
        "  #fit = curve_fit(model, d['cl'],d['tcp'],sigma=d['s_tcp'], p0=init_guess, absolute_sigma=True)\n",
        "  #fit for model 1\n",
        "  fit1 = curve_fit(model1, d1['tr'],d1['tcp'], p0=init_guess_m1)\n",
        "\n",
        "  #fit for model 2\n",
        "  fit2 = curve_fit(model2, d2['tr'],d2['tcp'], p0=init_guess_m2)\n",
        "\n",
        "  # unpacking the fit results for model1:\n",
        "  ans,cov = fit1\n",
        "  fit_m,fit_p = ans\n",
        "  fit_sm,fit_sp = sqrt(diag(cov))\n",
        "\n",
        "  # unpacking the fit results for model2:\n",
        "  ans,cov = fit2\n",
        "  fit_a,fit_b = ans\n",
        "  fit_sa,fit_sb = sqrt(diag(cov))\n",
        "\n",
        "\n",
        "  #t = linspace(1,100,50, dtype=int)\n",
        "  #t = array([int(x*2) for x in range(1, 51)])\n",
        "  #Best method to calculate the t is to copy x axis from xls data\n",
        "  t=array(d['tr'].tolist())\n",
        "\n",
        "  #output from model 1\n",
        "  y_model1 = model1(t,fit_m,fit_p) \n",
        "  y_model2 = model2(t,fit_a,fit_b)\n",
        "\n",
        "  # computing chi-square\n",
        "  # Compute the value of Chi-Square goodness of fit test using the following formula:\n",
        "  # Chi-Square = ( (E-O)**2 / E )\n",
        "  # Where, Chi-Square = goodness of fit test O= observed value E= expected value\n",
        "\n",
        "  #chisq for model1:\n",
        "  chisq1 = sum((d1['tcp'] - model1(d1['tr'],fit_m,fit_p))**2/d1['tcp'])\n",
        "  #chisq for model2:\n",
        "  chisq2 = sum((d2['tcp'] - model2(d2['tr'],fit_a,fit_b))**2/d2['tcp'])\n",
        "\n",
        "  #checking for validity of fit of model1\n",
        "  if chisq1 > 0.13:\n",
        "    print(\"Failed on trb value: %.1f\"%trb)\n",
        "    trb = trb - 3\n",
        "    continue\n",
        "  else:\n",
        "    print(\"Passed on trb value: %.1f\"%trb)\n",
        "    break\n",
        "\n",
        "# printing the fit results for model1:\n",
        "print(\"m: %.2f +/- %.2f\"%(fit_m,fit_sm))\n",
        "print(\"p: %.2f +/- %.2f\"%(fit_p,fit_sp))\n",
        "\n",
        "# printing the fit results model2:\n",
        "print(\"a: %.2f +/- %.2f\"%(fit_a,fit_sa))\n",
        "print(\"b: %.2f +/- %.2f\"%(fit_b,fit_sb))\n",
        "\n",
        "# ploting the data and fit results\n",
        "errorbar(d['tr'],d['tcp'],fmt='-b', label=\"data\")\n",
        "xlabel(\"cl (ff)\")\n",
        "ylabel(\"tcp (s)\")\n",
        "\n",
        "plot(t, y_model1, label=\"model1\")\n",
        "plot(t, y_model2, label=\"model2\")\n",
        "legend()\n",
        "\n",
        "#Adding the chisquare value to figure\n",
        "figtext(0.5,0.3,\"chi-square1: %.2f\"%chisq1,fontweight=\"bold\")\n",
        "figtext(0.5,0.2,\"chi-square2: %.2f\"%chisq2,fontweight=\"bold\")\n",
        "\n",
        "#Processing in a new dataframe for 2% error points which are trb's\n",
        "d_op = d\n",
        "d_op['y_model1'] = y_model1.tolist()\n",
        "d_op['y_model2'] = y_model2.tolist()\n",
        "#y_model1.tolist()\n",
        "#y_model1.shape\n",
        "#y_model2.shape\n",
        "\n",
        "#calculating the percentage difference for both model from data tcp\n",
        "d_op['pcdiff1'] = ( abs( d_op['tcp'] - d_op['y_model1']) / d['tcp'] *100)\n",
        "d_op['pcdiff2'] = ( abs( d_op['tcp'] - d_op['y_model2']) / d['tcp'] *100)\n",
        "\n",
        "#Finding the 2% variation point\n",
        "cl1 = d_op.loc[(d_op['pcdiff1'] > 2) & (d_op['pcdiff1'] < 2.5)]\n",
        "cl2 = d_op.loc[(d_op['pcdiff2'] > 2) & (d_op['pcdiff2'] < 2.5)]\n",
        "\n",
        "#Definig the averaging the values if multiple values come from selection\n",
        "def avg(lst): \n",
        "    return sum(lst) / len(lst)\n",
        "\n",
        "#Getting the average of the cl values to get the idea of their location\n",
        "trb1 = avg(cl1['tr'].tolist())\n",
        "trb2 = avg(cl2['tr'].tolist())\n",
        "\n",
        "#Testing wether the model has passsed or not\n",
        "if (trb1 >= trb2):\n",
        "  print('The model has Passed the test input')\n",
        "  print(\"trb: %.1f, trb1: %.1f, trb2: %.1f\"%(trb, trb1, trb2))\n",
        "else:\n",
        "  print('Model FAILED!!')\n",
        "  print(\"trb: %.1f, trb1: %.1f, trb2: %.1f\"%(trb, trb1, trb2))\n",
        "\n",
        "d_op.to_excel('output.xls')\n",
        "d_op"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {},
        "colab_type": "code",
        "id": "AY7dUycUaqhz"
      },
      "outputs": [],
      "source": [
        "x = d['tr'].tolist()\n",
        "#for trb in x:\n",
        "#  print(x)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "sytFs4VgoRkK"
      },
      "source": [
        "###Chapter 11: WEB Scrapping"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "colab_type": "code",
        "id": "rwb5vJ8XoW84",
        "outputId": "96c6ce9f-985c-42c3-cca6-f86bc38321db"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "execution_count": 97,
          "metadata": {
            "tags": []
          },
          "output_type": "execute_result"
        }
      ],
      "source": [
        "#Web scrapping is downloading the web contnt and then processing it in python\n",
        "#Let's Scrap web pages online\n",
        "\n",
        "'''\n",
        "webbrowser Comes with Python and opens a browser to a specific page.\n",
        "Requests Downloads files and web pages from the Internet.\n",
        "Beautiful Soup Parses HTML, the format that web pages are written in.\n",
        "Selenium Launches and controls a web browser. Selenium is able to\n",
        "fill in forms and simulate mouse clicks in this browser.\n",
        "'''\n",
        "import webbrowser\n",
        "webbrowser.open('http://google.com/')\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "BHudnpuUP4WG"
      },
      "source": [
        "###Chapter 10: Debugging Finding and removing errors"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 238
        },
        "colab_type": "code",
        "id": "jR9lqDvWQSF8",
        "outputId": "08bb21ef-108c-4f01-d73d-1cbba6899c9c"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "****\n",
            "*  *\n",
            "*  *\n",
            "****\n",
            "00000000000000000000\n",
            "0                  0\n",
            "0                  0\n",
            "0                  0\n",
            "00000000000000000000\n",
            "An exception has occured: width must be greater than 2\n",
            "An exception has occured: symbol should be a single charecter\n",
            "The traceback error was written to the log file \"errorlog.txt\"\n",
            "120\n"
          ]
        }
      ],
      "source": [
        "\n",
        "#Raising exception \n",
        "#without the try and except block the raise exception method will crash\n",
        "#raise Exception('A exception is being raised!')\n",
        "\n",
        "#use of raise in a function\n",
        "def boxprint(symbol, width, height):\n",
        "  if len(symbol) != 1:\n",
        "    raise Exception ('symbol should be a single charecter')\n",
        "  if width <= 2 :\n",
        "    raise Exception ('width must be greater than 2')\n",
        "  if height <=2 :\n",
        "    raise Exception ('height must be greater than 2')\n",
        "  print (symbol * width)\n",
        "  for i in range (height - 2):\n",
        "    print(symbol + (' ' * (width - 2)) + symbol)\n",
        "  print (symbol * width)\n",
        "  \n",
        "for sym, w, h in (('*', 4, 4), ('0', 20, 5), ('x', 1, 3), ('ZZ', 3, 3)):\n",
        "  try:\n",
        "    boxprint(sym, w, h)\n",
        "  except Exception as err: #err variable stores the exception messsage\n",
        "    print('An exception has occured: ' + str(err)) #str(err) can be printed\n",
        "\n",
        "#instead of crashing a program you can get the traceback log and debug later\n",
        "'''\n",
        "#instead of crashing below is smart way to handle it\n",
        "def spam():\n",
        "  bacon()Anubhav: renamed document to ak\n",
        "def bacon():\n",
        "  raise Exception('The error Message')\n",
        "\n",
        "spam()\n",
        "\n",
        "\n",
        "Output://\n",
        "Exception                                 Traceback (most recent call last)\n",
        "Exception: The error Message\n",
        "'''\n",
        "import traceback\n",
        "try:\n",
        "  raise Exception('This is an error message!')\n",
        "except:\n",
        "  errorfile = open('errorlog.txt', 'w')\n",
        "  errorfile.write(traceback.format_exc())\n",
        "  errorfile.close()\n",
        "  print('The traceback error was written to the log file \"errorlog.txt\"')\n",
        "#Exception: This is an error message! written to logfile\n",
        "\n",
        "#Assertion for use in sanity check\n",
        "#for checking the code is executing correctly\n",
        "#assert condition, Message for false condition\n",
        "#assert statements are never used with try and catch block and crashed voluntarily\n",
        "#Good for programmers to find bug while debugging easily\n",
        "flag = True\n",
        "assert flag == True, 'If flag is set false exception will occur'\n",
        "#flag is set to true but checked on flase so exception\n",
        "#This is voluntarily crashing the program if flag changes values in btw\n",
        "#This might be useful if flag as true is being used in program throughout\n",
        "#And if value of flag value change program will have logical error\n",
        "\n",
        "#___Example program of traffic light for assert based sanity check__#\n",
        "#two traffic light at market and mission circle intersection\n",
        "#current status of the stoplight is stored in the dict for two directions\n",
        "#ns for traffic in north-south and ew for in east-west\n",
        "\n",
        "market = {'ns': 'green', 'ew': 'red'}\n",
        "\n",
        "def switchlight (stoplight):\n",
        "  for key in stoplight.keys():\n",
        "    if stoplight[key] == 'green':\n",
        "      stoplight[key] = 'yellow'\n",
        "    elif stoplight[key] == 'yellow':\n",
        "      stoplight[key] = 'red'\n",
        "    elif stoplight[key] == 'red':\n",
        "      stoplight[key] = 'green'\n",
        "  #assert 'red' in stoplight.values(), 'Neither light is red!' + str(stoplight)\n",
        "#if you don't remove the above comment cars will crash..\n",
        "#calling the defined function\n",
        "switchlight(market)\n",
        "market \n",
        "#{'ew': 'green', 'ns': 'yellow'}\n",
        "#This will likely crash cars rather program so inserting line \n",
        "#assert 'red' in stoplight.values(), 'Neither light is red!' + str(stoplight)\n",
        "\n",
        "#__Disabling Assertion__\n",
        "''' once the program has been passed from the debugging phase to be handing \n",
        "over to user remove all the asertion if the program is still in dev like in most\n",
        "linux based dev so RUN THE PROGRAMM USING -0 OPTION WHICH WILL mute all the error\n",
        "'''\n",
        "\n",
        "#__Logging__\n",
        "#just like printing a message or variable value to check if code executed properly\n",
        "\n",
        "import logging\n",
        "\n",
        "logging.basicConfig(filename= 'mylog.txt', level=logging.DEBUG, format=' %(asctime)s - %(levelname)s - %(message)s')\n",
        "logging.disable(logging.NOTSET)\n",
        "#will only give log of error and critical message\n",
        "#logging.basicConfig(filename= 'mylog.txt', level=logging.ERROR, format=' %(asctime)s - %(levelname)s - %(message)s')\n",
        "\n",
        "#writing a log message\n",
        "logging.debug('Start of the program')\n",
        "\n",
        "#checking the functionality of the debug programm over the factorial prg\n",
        "def factorial(n):\n",
        "  logging.debug('Start of factorial (%s%%)' %(n))\n",
        "  total = 1\n",
        "#  for i in range(n+1): #will be an error as range will start from 0\n",
        "  for i in range(1, n+1):\n",
        "    total *= i\n",
        "    logging.debug('i is ' + str(i) + ', total is ' + str(total))\n",
        "  logging.debug('End of the factorial(%s%%)' %(n))\n",
        "  return total \n",
        "\n",
        "#calling the function for factorial 5 and checking op\n",
        "print(factorial(5))\n",
        "logging.debug('End of the program')\n",
        "#Debug results are always printed in the start of the program result\n",
        "#since range starts from 0 and factorial of 0 is not defined \n",
        "#with the help of debug method we are able to track down the error occurance\n",
        "#and factorial can be corrected by starting the range from 1\n",
        "#Although the same can be achieved with print but \n",
        "#Logging can be disabled by the logging.disable(logging.CRITICAL)\n",
        "#While you have to remove all print message and aciidently can remove needed ones\n",
        "\n",
        "#Disabling the logging debug message\n",
        "#logging.disable(logging.CRITICAL)\n",
        "#logging message will be disabled in second run as in first it will be last to executed\n",
        "#__IMP: To re-enable logging messages you just have to set disable flag to not set\n",
        "#logging.disable(logging.NOTSET)\n",
        "#after disabling debug message insert some print message for user friendy op\n",
        "\n",
        "#___Logging Levels__\n",
        "#debug, info, warning, error, critical\n",
        "#logging.debug(), logging.info(), logging.warning(), logging.error, logging.critical()\n",
        "#These logging messages are for suggestion and you to identify the critcality\n",
        "logging.debug('Some debugging message')\n",
        "logging.info('Information: The debug module is working')\n",
        "logging.warning('An error message is about to be logged')\n",
        "logging.error('An error has occured')\n",
        "logging.critical('The program is unable to recover')\n",
        "\n",
        "#__Disabling Logging once the debugging part is over\n",
        "\n",
        "#benifit if logging levels is that we can choose which level log we want to see\n",
        "#by setting the level to logging.DEBUG/EROOR and so on we wil get that message\n",
        "#Debug is the lowest level and critical is the heighest level \n",
        "#this will disable all the debug messages\n",
        "#logging.disable(logging.DEBUG)\n",
        "#Below line will disable all the message till warning like debug, info, warning\n",
        "#logging.disable(logging.WARNING)\n",
        "#Below will again make the all message display\n",
        "#logging.disable(logging.NOTSET)\n",
        "#it is always better to put the disabling point near the import function as \n",
        "#it will decide then and there what to do with the rest of the programm\n",
        "\n",
        "#__Logging To a file\n",
        "#Instead to display the log message to screen we can write these message to file\n",
        "\n",
        "#logging.basicConfig(filename='mylog.txt', level=logging.DEBUG, format=' %(asctime)s - %(levelname)s - %(message)s')\n",
        "#This line should only occur once in program so change it up there for filenaem\n",
        "#it is better to not cluttering your screen and print to file \n",
        "\n",
        "#__Debugging the program by eecuting it line by lin___#\n",
        "\n",
        "#the debugger can be used to debug the the written code line by line \n",
        "#This has been tried in the spyder with the debug option \n",
        "#where breakpoints has to be defined starting and ending point\n",
        "#then run deubgger\n",
        "#STEP will execute the next line of the code \n",
        "#if you want to go inside any function pre-defined and user defined \n",
        "#You have to choose the step into button for this action\n",
        "#variable will be updated after execution of that line\n",
        "#heighlighted line will the line to be executed next\n",
        "\n",
        "#_________________________END_______________________________#\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "U9bKnb9ygIoe"
      },
      "source": [
        "###Project on Backing up a folder in a zip file the name of which auto increments"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        },
        "colab_type": "code",
        "id": "rHmqmQKEgR6T",
        "outputId": "eef8449d-1ec1-48e9-f6e1-676234f0b055"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "creating the sample_data_2.zip\n",
            "Adding files in /content/sample_data...\n",
            "Backup Done!!\n"
          ]
        }
      ],
      "source": [
        "#Generating the backup of the folder in a zip file with functionality of auto increment name\n",
        "\n",
        "import zipfile, os\n",
        "#function which can be reuse based upon the requirements\n",
        "def backuptozip(folder):\n",
        "  #backing up the entire content of the folder\n",
        "  \n",
        "  #making sure that provided folder has an absolute path\n",
        "  folder = os.path.abspath(folder)\n",
        "\n",
        "  #figuring out what fileno should be used based on the backup files already exist\n",
        "  no = 1\n",
        "  while True:\n",
        "    zipfilename = os.path.basename(folder) +  '_' + str(no) + '.zip'\n",
        "    if not os.path.exists(zipfilename):\n",
        "      break\n",
        "    no = no +1\n",
        "  \n",
        "  #now creating a zip file\n",
        "  print('creating the %s' %(zipfilename))\n",
        "  backupzip = zipfile.ZipFile(zipfilename, 'w')\n",
        "\n",
        "  #no walking the entire tree in that folder and backing up every file\n",
        "  for foldername, subfolders, filenames in os.walk(folder):\n",
        "    print('Adding files in %s...' %(foldername))\n",
        "    #adding the current folder to zipfile\n",
        "    backupzip.write(foldername)\n",
        "    #adding all files of current folder to zip\n",
        "    for filename in filenames:\n",
        "      #checking and excluding the zip files or previous archived\n",
        "      newbase = os.path.basename(folder)\n",
        "      if filename.startswith(newbase) and filename.endswith('.zip'):\n",
        "        continue\n",
        "      #backing non zip files\n",
        "      backupzip.write(os.path.join(foldername,filename))\n",
        "  backupzip.close()\n",
        "  print('Backup Done!!')\n",
        "\n",
        "#Calling the function for backing up sample data\n",
        "\n",
        "backuptozip('/content/sample_data')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "Q7PAIo6FYQ7I"
      },
      "source": [
        "###Project on renaming the files in american date mm-dd-yyyy to europian date format dd-mm-yyyy"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 71
        },
        "colab_type": "code",
        "id": "5ASNpLiPYb32",
        "outputId": "20986ecf-ba9b-4f66-9e9e-347370ae5282"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Reanming the \"/content/hello_world 01-12-2019 created.txt\" to \"/content/hello_world 12-01-2019 created.txt\" ....\n",
            "Reanming the \"/content/hello_world 12-01-2019 created.txt\" to \"/content/hello_world 01-12-2019 created.txt\" ....\n"
          ]
        }
      ],
      "source": [
        "#Code for changing dates in files name to eu format from us format\n",
        "\n",
        "import shutil, os, re\n",
        "\n",
        "#creating a file for testing\n",
        "fileptr = open('hello_world 12-01-2019 created.txt','w')\n",
        "fileptr.write('Hello World!')\n",
        "fileptr.close()\n",
        "\n",
        "#creating a regex for matching files with american date format\n",
        "\n",
        "datepattern = re.compile(r\"\"\"\n",
        "^(.*?)            #All the text before the date\n",
        "((0|1)?\\d)-       #one or two digits for the month\n",
        "((0|1|2|3)?\\d)-   #one or two digits for the day\n",
        "((19|20)\\d\\d)     #four digits for the year\n",
        "(.*?)$            #All the text after the date\n",
        "\"\"\", re.VERBOSE)\n",
        "\n",
        "#loop over the files in the working directory\n",
        "for amerfilename in os.listdir('.'):\n",
        "  mo = datepattern.search(amerfilename)\n",
        "  #skipping a file without the date\n",
        "  if mo == None:\n",
        "    continue\n",
        "  #get the different parts of the file name\n",
        "  beforepart  = mo.group(1)\n",
        "  monthpart   = mo.group(2)\n",
        "  daypart     = mo.group(4)\n",
        "  yearpart    = mo.group(6)\n",
        "  afterpart   = mo.group(8)\n",
        "  \n",
        "  #From the New filename and rename files \n",
        "  eurofilename = beforepart + daypart + '-' + monthpart + '-' + yearpart + afterpart\n",
        "\n",
        "  #get the full, absolute file paths.\n",
        "  absdir = os.path.abspath('.')\n",
        "  amerfilename = os.path.join(absdir, amerfilename)\n",
        "  eurofilename = os.path.join(absdir, eurofilename)\n",
        "\n",
        "  #Rename the files\n",
        "  print('Reanming the \"%s\" to \"%s\" ....' %(amerfilename,eurofilename))\n",
        "  shutil.move(amerfilename, eurofilename)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "JejDOkPs9vjl"
      },
      "source": [
        "###File organizing and browsing using shutil module "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "colab_type": "code",
        "id": "DDZjSLZGirLe",
        "outputId": "35b58013-6d6a-466f-e430-9b280fed216b"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Compressed file is 8x smaller\n"
          ]
        }
      ],
      "source": [
        "import shutil,os\n",
        "#changing to a new directory\n",
        "os.chdir('/content/sample_data')\n",
        "os.getcwd()\n",
        "#op: '/content/sample_data'\n",
        "os.chdir('/content/')\n",
        "#*IF Running first time uncomment this line so that folder can be created easily\n",
        "#os.makedirs('ak')     #for making a directory\n",
        "os.chdir('/content/ak/')\n",
        "os.getcwd()\n",
        "#op: '/content/ak'\n",
        "#Creating the hello file\n",
        "fileptr = open('hello_world.txt','w')\n",
        "fileptr.write('Hello World!')\n",
        "fileptr.close()\n",
        "\n",
        "#______Using copy function of shutil\n",
        "#_copy with the same name\n",
        "#LIMIT: it overwrite the file if already exists\n",
        "shutil.copy('/content/sample_data/README.md','/content/ak/')\n",
        "#op: '/content/ak/README.md'\n",
        "#_copy with the different name\n",
        "shutil.copy('hello_world.txt','/content/hello.txt')\n",
        "#op: '/content/hello.txt'\n",
        "\n",
        "#___Copying all the files including folders using shutil.copytree\n",
        "#os.mkdir('personal')\n",
        "#LIMIT: only works if the folder doesn't exist before otherwise use no's\n",
        "#shutil.copytree('/content/ak','/content/ak_backup',False)\n",
        "#op: '/content/ak_backup'\n",
        "\n",
        "#______Using the move function of shutil\n",
        "#shutil.move('/content/hello.txt', '/content/ak/')\n",
        "#OP:'/content/ak/hello.txt'\n",
        "#shutil.copy('/content/ak/hello.txt', '/content/')\n",
        "#LIMIT: can overwrite the file if it exists and same name is specified in dest\n",
        "#shutil.move('/content/hello.txt', '/content/ak/hello.txt')\n",
        "\n",
        "#also if folder do not exist it will rename to dir name\n",
        "#_Renaming files....\n",
        "#shutil.move('/content/ak.txt', '/content/jk')\n",
        "#shutil.move('/content/jk', '/content/ak.txt')\n",
        "\n",
        "#If some folder or sub-folder doesn't exist pyhton will throw an error msg\n",
        "#shutil.move('/content/ak.txt', '/content/jk/rk')\n",
        "#op: No such file or directory: '/content/jk/rk\n",
        "\n",
        "##__________Permanently deleting files and folders________\n",
        "#os.unlink('/content/ak_backup')\n",
        "#Is a directory: '/content/ak_backup #_can't delete a directory\n",
        "#shutil.copy('/content/ak/hello.txt', '/content/')\n",
        "#os.unlink('/content/hello.txt')\n",
        "#op: delete file hello.txt created by copying the file from the ak directory\n",
        "\n",
        "#removing a directory from the folder\n",
        "\n",
        "#os.rmdir - only removes the empty directories\n",
        "#os.rmdir('/content/ak_backup')\n",
        "#Directory not empty\n",
        "\n",
        "#___Small folder Backup program____\n",
        "#shutil.rmtree: removes the complete directory recursively\n",
        "#shutil.rmtree('/content/ak_backup')                   #deletes old content\n",
        "#shutil.copytree('/content/ak','/content/ak_backup')   #creates new backup\n",
        "\n",
        "##_____________Safely deleting the files and folders________\n",
        "#doesn't permanently delete a file instead moves to trash\n",
        "#LIMIT: Doesn't have the authority to pull back the data from trash\n",
        "#import send2trash\n",
        "#shutil.copy('/content/ak/hello.txt', '/content/')\n",
        "#send2trash.send2trash('/content/hello.txt')\n",
        "\n",
        "#________Walking a directry Tree__________________\n",
        "'''\n",
        "for folderName, subfolders, filenames in os.walk('/content/'):\n",
        "  print('The current folder name is' + folderName)\n",
        "\n",
        "  for subfolder in subfolders:\n",
        "    print('SUBFOLDER OF' + folderName + 'is' + subfolder)\n",
        "  for filename in filenames:\n",
        "    print('Files inside ' + folderName + 'is' + filename)\n",
        "  print('')\n",
        "'''\n",
        "import zipfile,os\n",
        "os.chdir('/content/')\n",
        "#__zip also can be considered as a file type \n",
        "#__where you can read write and append other files\n",
        "\n",
        "#creating the zip file for sample_data backup__Write mode\n",
        "newzip = zipfile.Zifiles organizing and browsingpFile('sample_data_backup', 'w')\n",
        "newzip.write('/content/sample_data/mnist_test.csv', compress_type = zipfile.ZIP_DEFLATED)\n",
        "newzip.close()\n",
        "#Appending the zip file with other files in a mode\n",
        "newzip = zipfile.ZipFile('sample_data_backup', 'a')\n",
        "newzip.write('/content/sample_data/mnist_train_small.csv', compress_type = zipfile.ZIP_DEFLATED)\n",
        "newzip.close()\n",
        "#reading the content of zip file in r mode\n",
        "\n",
        "readzip = zipfile.ZipFile('sample_data_backup')\n",
        "readzip.namelist()\n",
        "#['content/sample_data/mnist_test.csv', 'content/sample_data/mnist_train_small.csv']\n",
        "\n",
        "#getting info of the zip files\n",
        "fileinfo = readzip.getinfo('content/sample_data/mnist_test.csv')\n",
        "fileinfo.file_size\n",
        "#18289443\n",
        "fileinfo.compress_size\n",
        "#2206214\n",
        "print('Compressed file is %sx smaller' %(round(fileinfo.file_size / fileinfo.compress_size)))\n",
        "#Compressed file is 8x smaller\n",
        "\n",
        "readzip.close()\n",
        "\n",
        "#Extracting all the files from zip archive using extractall method\n",
        "unzipfile = zipfile.ZipFile('sample_data_backup')\n",
        "#pass a folder created location or it will uzip in current working directory\n",
        "unzipfile.extractall('/content/backup/')\n",
        "unzipfile.close()\n",
        "\n",
        "#Extracting a specific file using extract method \n",
        "unzipfile = zipfile.ZipFile('sample_data_backup')\n",
        "#pass a folder created location or it will uzip in current working directory\n",
        "unzipfile.extract('content/sample_data/mnist_test.csv','/content/backup2/')\n",
        "unzipfile.close()\n",
        "#It will be extracted in the same directory pattern as in the archive even for single file\n",
        "\n",
        "#________The End________#"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "JKDbuxo49bOK"
      },
      "source": [
        "###**Project3:** *|File Handling|* Opening a file and then searching with reg ex pattern"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {},
        "colab_type": "code",
        "id": "O6OD3d5V9q9g"
      },
      "outputs": [],
      "source": [
        "#Coming soon..."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "7oMPBYPXIawV"
      },
      "source": [
        "###**Project2:** *|File Handling|* MultiClipboard"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        },
        "colab_type": "code",
        "id": "lEfGhaatMYMo",
        "outputId": "849cc5fc-6f18-4f35-ac23-7600a4205b82"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "please enter the key for valueak\n",
            "please enter the value for given keyjk\n"
          ]
        },
        {
          "data": {
            "text/plain": [
              "{'ak': 'jk'}"
            ]
          },
          "execution_count": 3,
          "metadata": {
            "tags": []
          },
          "output_type": "execute_result"
        }
      ],
      "source": [
        "#---------Pyperclip testing---------\n",
        "\n",
        "#!pip install -q pyperclip\n",
        "#import pyperclip\n",
        "#pyperclip.copy(\"hello\")\n",
        "#pyperclip.paste()\n",
        "\n",
        "#__since pyperclip does not work properly we will use input function\n",
        "#__Morever i will write a python script form here and will call it here\n",
        "key = input('please enter the key for value')\n",
        "value = input('please enter the value for given key')\n",
        "\n",
        "\n",
        "#__________FAILURE   creating a new file no meaninig doesn't execute________\n",
        "#mcbfile = open('mcb.py','w')\n",
        "#mcbfile.write('''\n",
        "#import shelve\n",
        "#mcb - multiclipboard short form use variable to use later\n",
        "#mcbvar = shelve.open('mcb')\n",
        "#''')\n",
        "#mcbfile.write('mcbvar[\\'' + key +'\\'] = \\'' + value + '\\'')\n",
        "#mcbfile.write('\\nmcbvar.clopyperclip.copy('Hello world!')\n",
        "#mcbfile.close()\n",
        "#import mcb\n",
        "\n",
        "import shelve,sys\n",
        "#sys function will be used for getting the system variable passed while calling\n",
        "\n",
        "mcbvar = shelve.open('mcb')\n",
        "mcbvar[key] = value\n",
        "mcbvar.close()\n",
        "\n",
        "mcvar = shelve.open('mcb')\n",
        "mcb = {}\n",
        "for index in range(len(list(mcvar.keys()))):\n",
        "  mcb [list(mcvar.keys())[index]] = list(mcvar.values())[index]\n",
        "mcb\n",
        "#list(mcvar.keys())\n",
        "#list(mcvar.values())\n",
        "\n",
        "#Just bad idea beacuse the concept is to data will be stored in shelve variable\n",
        "#should be able to run this program from terminal\n",
        "#it doesn't work as not able to initialize variable clip in the mcb.py"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "colab_type": "code",
        "id": "qV2_UlQxd_xC",
        "outputId": "f0e3eeca-6145-48c7-c5e2-90a923d18d97"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "{'anu': 'ak'}"
            ]
          },
          "execution_count": 53,
          "metadata": {
            "tags": []
          },
          "output_type": "execute_result"
        }
      ],
      "source": [
        "clip = {}\n",
        "clip['anu'] = 'ak'\n",
        "clip"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "0JQSGbSTpCa-"
      },
      "source": [
        "###**Project1:** *|File Handling|* generate random quiz files each different for each students"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {},
        "colab_type": "code",
        "id": "LwFdT161pdTv"
      },
      "outputs": [],
      "source": [
        "import random,os\n",
        "#All states and their capital in USA\n",
        "capitals = {'Alabama': 'Montgomery', 'Alaska': 'Juneau', 'Arizona': 'Phoenix',\n",
        "'Arkansas': 'Little Rock', 'California': 'Sacramento', 'Colorado': 'Denver',\n",
        "'Connecticut': 'Hartford', 'Delaware': 'Dover', 'Florida': 'Tallahassee',\n",
        "'Georgia': 'Atlanta', 'Hawaii': 'Honolulu', 'Idaho': 'Boise', 'Illinois':\n",
        "'Springfield', 'Indiana': 'Indianapolis', 'Iowa': 'Des Moines', 'Kansas':\n",
        "'Topeka', 'Kentucky': 'Frankfort', 'Louisiana': 'Baton Rouge', 'Maine':\n",
        "'Augusta', 'Maryland': 'Annapolis', 'Massachusetts': 'Boston', 'Michigan':\n",
        "'Lansing', 'Minnesota': 'Saint Paul', 'Mississippi': 'Jackson', 'Missouri':\n",
        "'Jefferson City', 'Montana': 'Helena', 'Nebraska': 'Lincoln', 'Nevada':\n",
        "'Carson City', 'New Hampshire': 'Concord', 'New Jersey': 'Trenton', 'New Mexico': 'Santa Fe', 'New York': 'Albany', 'North Carolina': 'Raleigh',\n",
        "'North Dakota': 'Bismarck', 'Ohio': 'Columbus', 'Oklahoma': 'Oklahoma City',\n",
        "'Oregon': 'Salem', 'Pennsylvania': 'Harrisburg', 'Rhode Island': 'Providence',\n",
        "'South Carolina': 'Columbia', 'South Dakota': 'Pierre', 'Tennessee':\n",
        "'Nashville', 'Texas': 'Austin', 'Utah': 'Salt Lake City', 'Vermont':\n",
        "'Montpelier', 'Virginia': 'Richmond', 'Washington': 'Olympia', 'West Virginia': 'Charleston', 'Wisconsin': 'Madison', 'Wyoming': 'Cheyenne'}\n",
        "\n",
        "for quizno in range(5):\n",
        "  #opening the two files for full range with capitals and ans\n",
        "  quizfile = open('capitalsquiz%s.txt'%(quizno+1),'w')\n",
        "  anskeyfile = open('capitalsquiz_answer%s.txt'%(quizno+1),'w')\n",
        "\n",
        "  #header for Quiz papers \n",
        "  quizfile.write('Name:\\n\\nDate:\\n\\nClass\\n\\n')\n",
        "  quizfile.write(' '*20 + 'USA states capital Quiz (form%s)'%(quizno+1) )\n",
        "  quizfile.write('\\n\\n')\n",
        "\n",
        "  #shuffling the order of the states\n",
        "  states = list(capitals.keys())\n",
        "  random.shuffle(states)\n",
        "  #generating 50 mcq for capital que\n",
        "  for queno in range(50):\n",
        "    #getting option for each questions\n",
        "    correctans = capitals[states[queno]]\n",
        "    wrongans = list(capitals.values())\n",
        "    #removing the right ans form the list of worngans\n",
        "    del wrongans[wrongans.index(correctans)]\n",
        "    #selecting three wrong answer randomly\n",
        "    wrongans = random.sample(wrongans, 3)\n",
        "    #total answer option\n",
        "    ansoption = wrongans + [correctans]\n",
        "    random.shuffle(ansoption)\n",
        "\n",
        "    #printing the text in the file for the test\n",
        "    quizfile.write('%s. What is the capital of %s?\\n'%(queno + 1,states[queno]))\n",
        "    for i in range(4):\n",
        "      quizfile.write('     %s. %s\\n' %('ABCD'[i], ansoption[i]))\n",
        "    quizfile.write('\\n')\n",
        "\n",
        "    #Writing the correct ans to a file for checking later\n",
        "    anskeyfile.write('%s. %s \\n' %(queno+1, 'ABCD'[ansoption.index(correctans)]))\n",
        "  quizfile.close()\n",
        "  anskeyfile.close()\n",
        "\n",
        "#op: successfully created the 35 quiz files and are very happy about it \n",
        "#This is surely going to be useful in the text processing in vlsi domain\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "mP7KGN5bkuqS"
      },
      "source": [
        "###File Handling"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "colab_type": "code",
        "id": "V1TY57TulIZK",
        "outputId": "4136b272-3d9f-46bd-b8f6-74e1327f9f09"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "'Zophie'"
            ]
          },
          "execution_count": 47,
          "metadata": {
            "tags": []
          },
          "output_type": "execute_result"
        }
      ],
      "source": [
        "import os\n",
        "\n",
        "#joining string independt to OS\n",
        "os.path.join('usr','bin','spam')\n",
        "#/usr/bin/spam/\n",
        "\n",
        "#getting the current working directory\n",
        "os.getcwd()\n",
        "#/content\n",
        "\n",
        "#change directory as well\n",
        "os.chdir('/')\n",
        "os.getcwd()\n",
        "# /\n",
        "#changing back to old cause i don't wanna mess things up.\n",
        "os.chdir('/content')\n",
        "os.getcwd()\n",
        "#/content\n",
        "\n",
        "#to see all directory in the current folder\n",
        "os.listdir()\n",
        "#['.config', 'sample_data']\n",
        "\n",
        "#let's make directories \n",
        "#os.makedirs('/content/anubhav/temp')\n",
        "\n",
        "#Path functions which can be of greater help\n",
        "#-----------Absolute Path-----------------------\n",
        "os.path.abspath('anubhav/temp')\n",
        "#/content/anubhav/temp:  Just updates with the pwd location\n",
        "os.path.isabs('anubhav')\n",
        "#False\n",
        "os.path.isabs(os.path.abspath('anubhav'))\n",
        "#True\n",
        "#------------Realtive Path----------------------\n",
        "os.path.relpath('/content/anubhav/temp', '/content')\n",
        "#anubhav/temp\n",
        "os.path.relpath('/content/anubhav/temp', '/anubhav/whitewalker/')\n",
        "#'../../content/anubhav/temp'\n",
        "#-------------dirname and basename-------------------\n",
        "#dirname : Abs Directory path of file\n",
        "#basename: File name with the type extension\n",
        "path = '/content/anubhav/temp/dict.csv'\n",
        "os.path.basename(path)\n",
        "#'dict.csv'\n",
        "os.path.dirname(path)\n",
        "#'/content/anubhav/temp'\n",
        "#-------------Splitting the dirname and basename---------\n",
        "os.path.split(path)\n",
        "#tuple o/p: ('/content/anubhav/temp', 'dict.csv')\n",
        "(os.path.dirname(path), os.path.basename(path))\n",
        "#tuple o/p: ('/content/anubhav/temp', 'dict.csv')\n",
        "#--------------A Useful variable os.seperator------------\n",
        "os.sep\n",
        "# o/p; '/' gives the result as the seperator type for the current OS being used\n",
        "path.split(os.sep)\n",
        "#['', 'content', 'anubhav', 'temp', 'dict.csv']\n",
        "\n",
        "#--------------getting size info of file-----------------\n",
        "path = '/content/sample_data/mnist_test.csv'\n",
        "os.path.getsize(path)\n",
        "#18289443\n",
        "total_size = 0\n",
        "for filename in os.listdir('/content/sample_data/'):\n",
        "  total_size =+ os.path.getsize(os.path.join('/content/sample_data/',filename))\n",
        "total_size\n",
        "#o/p: 18289443\n",
        "\n",
        "#----------------Checking Provided path validation------------\n",
        "path = '/content/sample_data/mnist_test.csv'\n",
        "os.path.exists(path)  #True\n",
        "os.path.isdir(path)   #False\n",
        "os.path.isfile(path)  #True\n",
        "\n",
        "#__________________Finally starting with the files______________\n",
        "\n",
        "#READ\n",
        "path = '/content/sample_data/README.md'\n",
        "#opening a file in read mode only\n",
        "filePtr = open(path) #default opens for read only\n",
        "fileptr = open('sample_data/mnist_test.csv','r') #or you specify explicitly\n",
        "#both works the same way as the current folder for the work is /content\n",
        "fileData = filePtr.read()\n",
        "#fileData       #gives complete data while reading as text contents\n",
        "filePtr.readlines()\n",
        "#fileData       #no o/p as there are no new lines in the csv or md file\n",
        "filePtr.close()\n",
        "#WRITE\n",
        "fileak = open('ak.txt','w')\n",
        "fileak.write('Hey! there\\n')\n",
        "fileak.close()\n",
        "fileak = open('ak.txt','a')\n",
        "fileak.write('Anubhav here!!')\n",
        "fileak.close()\n",
        "fileak = open('ak.txt','r')\n",
        "fileak.readlines()\n",
        "#o/p; ['Hey! there\\n', 'Anubhav here!!']\n",
        "\n",
        "#--storing vaiable to a binary file for later use--------\n",
        "import shelve\n",
        "varfile = shelve.open('mydata')\n",
        "family = ['ak','jk','pk']\n",
        "others = ['dk','pp']\n",
        "varfile['family'] = family\n",
        "varfile['others'] = others\n",
        "#varfile.close()\n",
        "type(varfile)\n",
        "#op: shelve.DbfilenameShelf\n",
        "varfile['family']\n",
        "#op: ['ak', 'jk', 'pk']\n",
        "list(varfile.keys())\n",
        "#op; ['family', 'others']\n",
        "list(varfile.values())\n",
        "#op: [['ak', 'jk', 'pk'], ['dk', 'pp']]\n",
        "varfile.close()\n",
        "\n",
        "#--saving variable with pprint.pformat---------\n",
        "import pprint\n",
        "cats = [{'name': 'Zophie', 'desc': 'chubby'}, {'name': 'Pooka', 'desc': 'fluffy'}]\n",
        "pprint.pformat(cats)\n",
        "fileobj = open('mycats.py','w')\n",
        "fileobj.write('cats = '+ pprint.pformat(cats) + '\\n')\n",
        "#op; 83\n",
        "fileobj.close()\n",
        "#the file itself can be used as module\n",
        "import mycats\n",
        "mycats.cats \n",
        "#op: [{'desc': 'chubby', 'name': 'Zophie'}, {'desc': 'fluffy', 'name': 'Pooka'}]\n",
        "mycats.cats[0]['name'] \n",
        "#op; 'Zophie'\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "QhTki9ByUkHl"
      },
      "source": [
        "###Project: finding the all email and phone no from copied Text"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 190
        },
        "colab_type": "code",
        "id": "eIE98lD0cOwM",
        "outputId": "1857252c-2285-4a5c-ac7c-146813a6d2c9"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Kindly copy and paste the text you want to extract email and phone no ofSkip to main content Home Search form Search Catalog Blog Media Write for Us About Us Contact Us Topics Art & Design General Computing Hacking & Computer Security Hardware / DIY Kids LEGO® Linux & BSD Manga Programming Python Science & Math Scratch System Administration Early Access Free ebook edition with every print book purchased from nostarch.com! Shopping cart 0 Items\tTotal: $0.00 User login Log in Create account Contact Us  No Starch Press, Inc. 245 8th Street San Francisco, CA 94103 USA Phone: 800.420.7240 or +1 415.863.9900 (9 a.m. to 5 p.m., M-F, PST) Fax: +1 415.863.9950  Reach Us by Email  General inquiries: info@nostarch.com Media requests: media@nostarch.com Academic requests: academic@nostarch.com (Further information) Help with your order: info@nostarch.com Reach Us on Social Media Twitter Facebook Instagram Pinterest  Navigation My account Want sweet deals? Sign up for our newsletter.   About Us  |  Jobs!  |  Sales and Distribution  |  Rights  |  Media  |  Academic Requests  |  Conferences  |  Order FAQ  |  Contact Us  |  Write for Us  |  Privacy Copyright 2020. No Starch Press, Inc\n",
            "Matches are found and are being printed like no-newline-emailid:\n",
            "800-420-7240\n",
            "415-863-9900\n",
            "415-863-9950\n",
            "info@nostarch.com\n",
            "media@nostarch.com\n",
            "academic@nostarch.com\n",
            "info@nostarch.com\n"
          ]
        }
      ],
      "source": [
        "'''\n",
        "#Project Objectives\n",
        "• Get the text off the clipboard and take input\n",
        "• Find all phone numbers and email addresses in the text.\n",
        "• Paste them onto the clipboard.\n",
        "Now you can start thinking about how this might work in code. The\n",
        "code will need to do the following:\n",
        "• Use the input and print module to copy and paste strings.\n",
        "• Create two regexes, one for matching phone numbers and the other for\n",
        "matching email addresses.\n",
        "• Find all matches, not just the first match, of both regexes.\n",
        "• Neatly format the matched strings into a single string to paste.\n",
        "• Display some kind of message if no matches were found in the text.\n",
        "'''\n",
        "\n",
        "import re\n",
        "\n",
        "\n",
        "text = input('Kindly copy and paste the text you want to extract email and phone no of')\n",
        "\n",
        "#Creating regex for finding all phone no in the inputed text.\n",
        "\n",
        "phonereg =  re.compile(r'''(\n",
        "  (\\d{3}|\\(\\d{3}\\))?              #finding Area code\n",
        "  (\\s|-|\\.)?                      #finding seperator\n",
        "  (\\d{3})                         #finding first three digit of no\n",
        "  (\\s|-|\\.)                       #finding seperator\n",
        "  (\\d{4})                         #finding the last four digits of no\n",
        "  (\\s*(ext|x|ext.)\\s*(\\d{2.5}))?  #finding the extension no for the user\n",
        ")''', re.I|re.VERBOSE)\n",
        "\n",
        "#Crating regex for the finding all email address \n",
        "\n",
        "emailreg = re.compile(r'''(\n",
        "  [a-zA-Z0-9._%+-]+               #username\n",
        "  @                               # @ symbol for the email\n",
        "  [a-zA-Z0-9.-]+                  #domain name\n",
        "  (\\.[a-zA-z]{2,4})               #dot something\n",
        ")''',re.I|re.VERBOSE)\n",
        "\n",
        "#Finding matches in the inputted text\n",
        "\n",
        "matches = []\n",
        "for groups in phonereg.findall(text):\n",
        "  phoneno = '-'.join([groups[1],groups[3],groups[5]])\n",
        "  if groups[8] != '':\n",
        "    phoneno =+ ' x' + groups[8]\n",
        "  matches.append(phoneno)\n",
        "for groups in emailreg.findall(text):\n",
        "  matches.append(groups[0])\n",
        "\n",
        "#Checking if matches has been found or not\n",
        "\n",
        "if len(matches) > 0:\n",
        "  print('Matches are found and are being printed like no-newline-emailid:')\n",
        "  print('\\n'.join(matches))\n",
        "else:\n",
        "  print('No email or phone no has been found in the inserted text')\n",
        "\n",
        "#phonereg.search('My phone no is 945 253 1884 ext 884')\n",
        "#emailreg.search('My email is anubhavkumar.995@gmail.com')\n",
        "#emailreg.search('My email is akumar14@ec.iitr.ac.in')\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "2fwvIbCrbyqK"
      },
      "source": [
        "\n",
        "###3. Regexes expression for pattern detection"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 90
        },
        "colab_type": "code",
        "id": "7-bFXQbYUEvf",
        "outputId": "2d8110ab-0244-41e8-fe40-1c156dcc739b"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Found No is: Area code: 945 No: 253-1884\n",
            "Area code: 945 Phone No: 253-1884\n",
            "Area code: (945) Phone No: 234-1884\n"
          ]
        },
        {
          "data": {
            "text/plain": [
              "<_sre.SRE_Match object; span=(46, 59), match='Anubhav Kumar'>"
            ]
          },
          "execution_count": 28,
          "metadata": {
            "tags": []
          },
          "output_type": "execute_result"
        }
      ],
      "source": [
        "import re\n",
        "#phonenoreg = re.compile(r'\\d\\d\\d-\\d\\d\\d-\\d\\d\\d\\d') #r'' passes raw string\n",
        "#phonenoreg = re.compile('\\\\d\\\\d\\\\d-\\\\d\\\\d\\\\d-\\\\d\\\\d\\\\d\\\\d') #other method with escape charecter\n",
        "#phonenoreg = re.compile(r'\\d{3}-\\d{3}-\\d{4}') # most shortest method\n",
        "phonenoreg = re.compile(r'(\\d{3})-(\\d{3}-\\d{4})') # most shortest method\n",
        "\n",
        "mo = phonenoreg.search ('My Phone no is 945-253-1884 call me')\n",
        "#print('Phone No found is: ' + mo.group())\n",
        "print ('Found No is: ' + 'Area code: ' + mo.group(1) + ' No: ' + mo.group(2) )\n",
        "# groups results in the tuple information of the all groups\n",
        "areaCode, phNo = mo.groups()\n",
        "print ('Area code: ' + areaCode + ' Phone No: ' + phNo )\n",
        "\n",
        "#Searching for )( in the regex just escape it by \\\n",
        "\n",
        "reg2 = re.compile(r'(\\(\\d{3}\\))-(\\d{3}-\\d{4})')\n",
        "mo1 = reg2.search('My mobile no is (945)-234-1884 call me')\n",
        "areaCode, phNo = mo1.groups()\n",
        "#mo1.group(1)\n",
        "print ('Area code: ' + areaCode + ' Phone No: ' + phNo )\n",
        "\n",
        "#----------Using Pipe for maultiple matching or OR-ing the match---------------#\n",
        "reg3 = re.compile(r'Sonu|Anubhav Kumar')\n",
        "mo2 = reg3.search('My name is Anubhav Kumar. At home people call me Sonu')\n",
        "mo2.group() #'Anubhav Kumar'\n",
        "\n",
        "#------in pipe also you can group multiple words--------------#\n",
        "reg4 = re.compile(r'red(wine|beer|whiskey|malt)')\n",
        "mo3 = reg4.search('I love to have redwine but redwhiskey will also do')\n",
        "mo3.group() #'redwine'\n",
        "mo3.group(1) #'wine'\n",
        "\n",
        "#------------Optional matching with question mark-------------#\n",
        "reg4 = re.compile(r'red(-| |_)?(wine|beer|whiskey|malt)')\n",
        "mo3 = reg4.search('I love to have red wine but redwhiskey will also do')\n",
        "mo3.group() #'red wine'\n",
        "mo3.group(2) #'wine'\n",
        "mo3 = reg4.search('I love to have redwhiskey but red-wine will also do')\n",
        "mo3.group() #'redwhiskey'\n",
        "mo3.group(2) #'whiskey'\n",
        "\n",
        "#-------------Matching any or no occurance of a group with *----------#\n",
        "reg4 = re.compile(r'(red)*(wine|beer|whiskey|malt)')\n",
        "reg5 = re.compile(r' (red)*(beer|whiskey|malt)')\n",
        "mo3 = reg4.search('I love to have redredredwine but whiskey will also do')\n",
        "mo3.group() #'redredredwine'\n",
        "mo3.group(1) #'red'\n",
        "mo3 = reg5.search('I love to have redredredwine but whiskey will also do')\n",
        "mo3.group() #'whiskey'\n",
        "mo3.group(1) #''\n",
        "\n",
        "#-----------Mathing one or more occurance of a group with +---------#\n",
        "reg4 = re.compile(r'(red)+(wine|beer|whiskey|malt)')\n",
        "reg5 = re.compile(r' (red)+(beer|whiskey|malt)')\n",
        "mo3 = reg4.search('I love to have redredredwine but whiskey will also do')\n",
        "mo3.group() #'redredredwine'\n",
        "mo3.group(1) #'red'\n",
        "mo3 = reg5.search('I love to have redredredwine but whiskey will also do')\n",
        "#mo3.group() #'None' Error\n",
        "#mo3.group(1) #'None' Error\n",
        "mo3 == None #'True'\n",
        "\n",
        "#----------Using {} for no range occurance ---------------------#\n",
        "#pattern will search for ha occurance in 2 or 4 time range but.\n",
        "#But it is GREEDY in nature and will look for the largest match\n",
        "reg = re.compile(r'(ha){2,4}')\n",
        "#search1\n",
        "mo = reg.search('hahaha')\n",
        "mo.group() #'hahaha'\n",
        "#search2\n",
        "mo = reg.search('ha')\n",
        "mo == None #'True'\n",
        "\n",
        "# NON-GREEDY version for the Shortest match\n",
        "reg = re.compile(r'(ha){2,4}?')\n",
        "#search1\n",
        "mo = reg.search('hahaha')\n",
        "mo.group() #'haha'\n",
        "\n",
        "#----------findall() function for all results/tuples for groups-----#\n",
        "\n",
        "reg4 = re.compile(r'redwine|redwhiskey')\n",
        "mo3 = reg4.findall('I love to have redwine but redwhiskey will also do')\n",
        "mo3 \n",
        "#o/p_noGroups: all matches: ['redwine', 'redwhiskey']\n",
        "\n",
        "reg4 = re.compile(r'(red)(wine|beer|whiskey|malt)')\n",
        "reg4.findall('I love to have redwine but redwhiskey will also do')\n",
        "#o/p tuples:  [('red', 'wine'), ('red', 'whiskey')]\n",
        "\n",
        "#-----------regex charecter classes similar to \\d-------------#\n",
        "#\\d: 0-9 not\\d: \\D\n",
        "#\\w: [0-9,ch,_] not\\w: \\W\n",
        "#\\s: [spcae , tab\\t, new-line\\n] not\\s: \\S\n",
        "\n",
        "reg = re.compile(r'\\d+\\s\\w+')\n",
        "reg.findall('12 drummers, 11 pipers, 10 lords, 9 ladies, 8 maids, 7 swans, 6 geese, 5 rings, 4 birds, 3 hens, 2 doves, 1 partridge')\n",
        "# ['12 drummers', '11 pipers',......]\n",
        "\n",
        "#----------Making your own charecter classes-------------------#\n",
        "#Define your class in [a-zA-Z0-9] will match char(upper+lower)+numeric\n",
        "reg = re.compile(r'[anubhavAnubhav0-9.@gmailcom.*?]')\n",
        "reg.findall('Is My email id anubhavkumar.995@gmail.com.? *')\n",
        "#o/p 1: all the charecters mentioned in the regex expression\n",
        "\n",
        "#Defining a negative class of the above example\n",
        "reg = re.compile(r'[^anubhavAnubhav0-9.@gmailcom.*?]')\n",
        "reg.findall('Is My email id anubhavkumar.995@gmail.com.? *')\n",
        "#o/p 2: remaining charecters of the output from 1\n",
        "\n",
        "#--------searching the begin or end of string with ^,$ respectivly------#\n",
        "#if both the wild charecters ^$(carrot cost dollars) are used then full string match is required. \n",
        "reg = re.compile(r'^\\w+[a-zA-Z _\\-]?\\d+$')\n",
        "reg.findall('My-9452531884') #match\n",
        "#full string has to be matched then only search result will be there.\n",
        "reg = re.compile(r'^\\w+\\d+$')\n",
        "reg.findall('My_9452531884') #match\n",
        "reg.findall('My -9452531884') #no match as \\w doesn't include the space and -.\n",
        "#Also keep in mind that space is not included into the \\w so only word in matched\n",
        "#------------------------Wild card charecter .(DOT)---------------------------#\n",
        "#search multiple values of the -at word\n",
        "reg = re.compile(r'.at')\n",
        "reg1 = re.compile(r'\\.at')\n",
        "reg.findall('cat bat hat mat rat sat lal peep we .at')\n",
        "#o/p: ['cat', 'bat', 'hat', 'mat', 'rat', 'sat']\n",
        "reg1.findall('cat bat hat mat rat sat lal peep we .at')\n",
        "#o/p: ['.at']\n",
        "\n",
        "#with force first and last charecter limit\n",
        "reg = re.compile(r'^\\w.+\\d+$')\n",
        "reg.findall('My-9452531884') # match\n",
        "reg.findall('- My-9452531884') # no match as - is not in \\w match\n",
        "reg.findall('My-9452531884 anubhav') # no match should end with number\n",
        "\n",
        "##Matching anything except \\n(newline) within a pattern using (.*)\n",
        "\n",
        "#Greedy method of matching by (.*)\n",
        "reg = re.compile(r'<Name: (.*)>')\n",
        "#Non-Greedy method of matching by (.*?)\n",
        "reg1 = re.compile(r'<Name: (.*?)>')\n",
        "reg.search('<Name: Anubhav> Kumar>')# Greedy longest match <Name: Anubhav> Kumar>\n",
        "reg1.findall('<Name: Anubhav> Kumar>')# Non-Greddy shortest match <Name: Anubhav>\n",
        "\n",
        "##Matching newline with the wild card charecter .\n",
        "reg = re.compile(r'.*')\n",
        "reg1 = re.compile(r'.*', re.DOTALL)\n",
        "reg.search('Name: Anubhav\\nID: 18534002')# Name: Anubhav match till newline\n",
        "reg1.search('Name: Anubhav\\nID: 18534002').group()#  matches all and group gives only relevent information\n",
        "reg.findall('Name: Anubhav\\nID: 18534002')# findall matchs all and result in tuple\n",
        "\n",
        "#----------Case in-sensitive regex searching with extra argument re.I---------#\n",
        "reg = re.compile(r'anubhav')\n",
        "reg1 = re.compile(r'anubhav',re.I)\n",
        "\n",
        "reg.findall('I am Anubhav')# no match as match is case sensitive\n",
        "reg1.findall('I am Anubhav')# \"Anubhav\" match as match is case in-sensitive\n",
        "\n",
        "#-----------find and Substitue a string in place of other string---------------#\n",
        "reg = re.compile(r'anubhav\\s\\w+',re.I)#A (.*) will include everything all words\n",
        "reg.sub('Chu', 'My name is Anubhav Kumar')# 'My name is chu'\n",
        "\n",
        "#replacing/substituting only some part of a searched string\n",
        "reg = re.compile(r'(a)nubhav\\s(\\w)\\w+',re.I)#A (.*) will include everything all words\n",
        "reg.sub(r'\\1** \\2**', 'My name is Anubhav Kumar')# 'My name is A** K**'\n",
        "reg = re.compile(r'Mr. (\\w)\\w+')\n",
        "reg.sub(r'\\1**','I love to meet Mr. Dinesh, Mr. Lomash and Mr. Mahipal')\n",
        "#o/p: 'I love to meet D**, L** and M**'\n",
        "\n",
        "\n",
        "#------------Organize a long regex expression using re.VERBOSE and '''--------#\n",
        "#better visualization\n",
        "reg = re.compile(r'''(\n",
        "  (\\d{3}|\\(\\d{3}\\))? #areaCode either like 123 (123) or not at all\n",
        "  (\\s|-|\\.)? #finding space or - or dot\n",
        "  \\d{3} #first three digits of Phno\n",
        "  (\\s|-|\\.)? #finding space or - or dot\n",
        "  \\d{4} #finding last 4 digit of phone no;\n",
        "  (\\s*(ext|x|ext.)\\s*\\d{2,5})? #finding wether an extension no id there\n",
        ")''',re.VERBOSE)\n",
        "reg.search('My phone no is 945 253 1884 ext 884')\n",
        "#O/P:  match='945 253 1884 ext 884'\n",
        "\n",
        "#----------Passing one or more than one parameters in re.compile function------#\n",
        "reg = re.compile(r'''(\n",
        "  (a)            #Matching first a/A\n",
        "  nubhav\\s       #mathing the remaining part of the name\n",
        "  (\\w)?          #Searching for K in Kumar \n",
        "  (\\w*)           #Searching the remaining part of Kumar\n",
        "  )''',re.I|re.DOTALL|re.VERBOSE)#case in-sensitive|search after \\n|commenting inside regex)\n",
        "reg.search('My name is Anubhav/n But you can just call me Anubhav Kumar')\n",
        "#O/P: 'Anubhav Kumar'\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "zSasL1hlUFMB"
      },
      "source": [
        "###2. Password Manager from Automating python book"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 53
        },
        "colab_type": "code",
        "id": "WCA0FqzqcH0G",
        "outputId": "d7cfebe3-48cb-4d0e-b779-efac841eab2e"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter the account you want to kmow the password ofafa\n",
            "afaThis account does not exist\n"
          ]
        }
      ],
      "source": [
        "#! python3\n",
        "#pw.py-An insecure password manager designer with refrence from automating book\n",
        "import sys\n",
        "#stored password dictonary\n",
        "password = {'email':123, 'mobile':345, 'tablet':678, 'laptop':789}\n",
        "\n",
        "#core program starts here\n",
        "account = input('Enter the account you want to kmow the password of')\n",
        "if account in password:\n",
        "  print ('The password for ' + account + 'is :' + str(password[account]))\n",
        "else:\n",
        "  print (account + 'This account does not exist')\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "HPF7K0eJsopj"
      },
      "source": [
        "### 1. Tic Tak Toe\n",
        "A learning milestone"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {},
        "colab_type": "code",
        "id": "-bQw4XknffL9"
      },
      "outputs": [],
      "source": []
    }
  ],
  "metadata": {
    "colab": {
      "collapsed_sections": [],
      "include_colab_link": true,
      "name": "Auto_python_book.ipynb",
      "provenance": [],
      "toc_visible": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python",
      "version": "3.10.12"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}