Telegram-Leecher.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bgOUmN8ixyQM"
      },
      "source": [
        "# Telegram-Leecher\n",
        "\n",
        "1. UPLOAD YOUR THUMBNAIL (OPTIONAL) ( thmb.jpg < 200KB )\n",
        "\n",
        "2. UPLOAD YOUR token.pickle file ( REQUIRED !! )\n",
        "\n",
        "### NOTE: File names should be exactly same as mentioned\n",
        "\n",
        "![2023-03-20 11_46_08-Try.ipynb - Colaboratory - Brave.png](data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAASQAAAEhCAIAAABZVkoIAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAASdEVYdFNvZnR3YXJlAEdyZWVuc2hvdF5VCAUAABocSURBVHhe7Z1PbBvHvcd7fqd3ead3eqd36emdaDSJu0laRnbjiE+2rFZwEdWx1BAvNRyYbc3ApZvIgFVDsiq6jlyndK2klmvQQiDApRHQMAMkRAoQARGBhxbw+b3rO/T83nfmN1wul/+WFHe4JL8fLOyZ2Znd4XI+O7NDcfitGCHECpSNEEtQNkIsQdkIsQRlI8QSlI0QS1A2QixB2QixBGUjxBKUjRBLUDZCLEHZCLEEZSPEEpSNEEtQNkIsQdnI2DM7O3urHzKZDIqYwhahbGTsef78+T/6BEVM4c5ASGTroiV27e3tBfeWspHxBm0d8kijb4vY1Qp2mUN0QBzu5BsSv/zyS2TAvyapF5SNjDeiEwaHJt7MYWRDhk6+ISqmYZdJCgBlI+ON6BSGbAB5Wn1DYADTAGUj443o1EU2NSXSjKjiytMdZPP6BgYzDURCtuXL2eyWb1tLzcViTmr708L+7ZSDTHOpNaRfXpYihAho/V1kawsyB5cNIKfr28CmgR6yyW0AJ1tZWVH3hM5kMhlTpn82ntRaqOy+G4ttFnS4sIFM7+5WEHyigoS4WJANuL6BwUwDPWSTE4hpcqZO7O3tmTL9o2Urbp9dWmpsiwl0Z04y+7CQ30qqno2ykXZYk036NAAp+irr0kM2aAZMJDS0bLr78hOfh3gLcRVskS2+kFpVA86NzDmdoUF8/ueraiy6nknOKk/JBGNBNtc0aCbdz2C+ReKZrbNsG2ocKYI1ybaYeVhGzKWyv7aod+Axb+cLk6ipFjbNHjKRhC2b1zSJDuxbb9n6PeIAaNnKeTM1ojczEdJetuW7JQQrj7OpWceZTa4+UuKV7qoijn7MqzxMYxQaP7ea/6JSerSxpMqTyQTtMzzZkKd1RgSJg/nWQzY5E46YyWQQ7kJfr9ZHmwkS04O1lS2dR6iST+scmkz+61rt85ySal3L9mh1eUZ2kQkHjTMk2ZABDdtnmoBdA/gWaIIEh+sp26FnI5snSOQ5ra1sTraIQBv0QNRJ5Z5VJV79qlS4t7rEp7aJBo0TTbTLn2u1ElA2HLOtaQKKix1o/CapF9EZRgZ+ZhPZnm43zDTbfH2exElcXN2+v1+Ux7ryznmTTiYQtE80dzT6fjHlOyNHNpF2SIbgM4jjOEFyfvcrNfGxMaezKBYzNzfOy7hxZnn1dlZ/Cg6ctccooz+yI5MLGj0GVuivgmNK2qWHbHgZI536bz9BsrhZUCPFSiG3nkldzub1uLF8XymWfqhyVT/PZy8nU1d3impPMdvQkpCR0UM26XChHG4GEu7EoT/U7mvq30luFSoHiBvKDzP1qf9k9rHKaDio7F/j1D+JBD1kg2NiEfo31ft2xkIH6MdJLOqntfmWiUdndrH5KY6Q0ROJZzZCpgHKRoglKBshlqBshFiCshFiCcpGiCUoGyGWoGyEWIKyEWIJykaIJSgbIZagbIRYgrIRYgnKRoglKBshlqBshFiCshFiCcpGiCUoGyGWoGyEWIKyEWKJ8ZNtZWWlywq4t0a0/iYhPRk/2WSB9S7QNxJNxk82McpEmpFdIDzf0K+2td2+4dGpSVtkLW1UJpPJIICo2THFTKZsIKQ2F50RbDTH0l0Wz8atYYQViwITKxsI4601h+4TtDPc3c0hhoQ5dJ+EUROXTpp5mWblJlk2MPT31Ry3f9DIzCGGhDluZ3BG9H4AAZOkGXpNBF9Pi6hYjb5OftzP7NAc5pchxpcJlw2YfUNisGMOVqo7cswuuI9JCJikOpI+RIK45Ov3UMTsmBomSjYfwXMGZ7BjDlaqO3LMTqBle1s8wmaHxqQOCd/BXYvELu+4ccr7N8rWH4Mdc7BS3ZFjtkUGijINKJl9nZskDoXWblN+8NnXj4lXqI+Ja1DP8B4gI8iEyCY/PGkiddrmPCRhHHMwpCZtcR+WvF0HLpHZPdT6+zorIMPXtg+KrWZO1WByEmRzm5HPN0k0kSER/JioDNo6kDs9WtVwG5bUpBXvWXBqOTtAQ8cuySMpQ8E9pktb2YDkN5E6w70mEac/2eQ6jhZ5k0yk+YYNvL5JiokMiSDHdAdLaHDS5iRgRzbveyTnNRFPxUx8GLR2VtKv+oaR8r743izAYaQfXFDcoeXqSKMZoXVSDQn73jzUDf+6vkmihIdFkGPqFm6eRnCh3EpakM17r3HPi8rg1IKkmBxDwucVzoJEvHCky6Vwa+VWQECjkvQpobds7u0QlwZXTazDFRzVPUkqI2F5m90ayrvrvoWSKOFh0fOY0sTdm5HUUJBWOCzMQZvx3gTbNmW5ViYyJMQrqYCAqNnnQVqOy3CvxljQWza5G3nVwsXVN6xQPhvtibxVJqIrg3/dRG893cQh0vOYaFLeZoTqoUqC14TDIzXx4QqGQNvTybtpIsMD5/L5huaB+w7SAV67nNdlCk0DPWST+zT+NfE6uHxIx78mbhH9ZvmbS/DEQ9LzmD7ZwkNq4gNNXBp3275F3jVg4kMF5/X51hbUsG3dpoEessnlw3U08TpIQfpIrpp+y0Ymm+8O7QOtWW5PvtuQtPLWe9Zh6FQTNeTwPKR5kQwImEOEQBflplkzIZBsJtIM0t1Bi030GxdIoeA5gwNt3FbbCnahtUlzd+9QbopEh0X3mnQC1fDdCEICrxonwv0FTcjOGaNPD9lwmfAOtV6sTsNLC6C56GYTiKE38SCIXXJ2N8AGR3rI1nqfBiHdqgMCw3FqrVIPcOMfVRPHJUI9UQF0/lM+diIuPWQDaDdouGjf0m6ANOVO812EkLb0lg1AKu/jgffJhKMjQgISSDYXb1fm9nj0jZAg9CebD/pGSHAOJRtwffN2eoSQVg4rG4Bm7NkI6ckQZCOEBIGyEWIJykaIJSgbIZYYvWxLhIwzph0HgD0bIZagbIRYgrIRYgnKRoglKBshlqBshFiCshFiCcpGiCUoGyGWoGyEWIKyEWIJykaIJSgbIZYYe9lW9I9I7HlA1OwjJEqMvWxqIcsW6BuJIOMtm/zkQECee34nkRD7TJpsMMqEOsCFwMiomCjZZF1099cI2oIipjAhdpkc2WCaJHb3jbKRUTEhsrmmCV18o2xkVEyCbLL4OTCp9UWa9/b2RDAvlI2MiskZRkI5k9r110k7yLaYvrm9lnRU0Emu3c6mF3UyIcODsgmr+9Va+V5SBc/mSrVa4bpOJmR4UDZCLDFRsrmYpHZQNjIqxlu2Wf3rcH3hnUchxCZDkG20zRc9lf7z40Dwz0fICOkhG1rnlxoTb4dk4PCMkO70kA3jLjwCmUhnIBtymgghpB3dZJMnIoy+TFwjnxdLGAEZQyIPH4cI6U4fsiEqc30AUenNZK/8bRRlI6QLffds4hVMQ7prF2UjpCe9ZYNIJq7B0FFkM3GNfN5F2QjpQkfZYA6MwojRp5AY6JMNicjp7esIIT46yoYeDPK0yiaPavLY5uIaSNkI6US3YaSMGL0foCEFRskTmtgodrkpko0Q0krQZzbp5aRDEwm9dnGCpJX5+flsNvunP/3pk08+2djY+N73vmd2kGklqGwII+DqhO7O2+ONULYf/vCH6XT6Nx4QNftGx5EjR9bX12/fvv2Tn/xkYWHh7NmzZgeZYoLK1p0Ryva0HSP37dixYzDt6tWrJk5Id9kAxo2+ice2IBtkM5GB+MEPfmBC/ZBMJo1eAcjn8+j3TMmuLC0t/f73v79///7HH3/8wQcfvPzyy0jEreTGjRsYE8qw8PXXX0cixoofffTRlStXcrkc8kMw9GNIvHv3LqIAgTfffNMVDz3er3/9axwWB9nc3Lxz5w6FnB56yIYuq6dv2IsnOu+ocgB++9vfHj9+3EQC05dsAoadpnAHYMsf/vAHOADHzp07B1suXbqEMB7Abt68eVKzvb2NKBLFK7h05syZ06dPI4DRIw7i7dm84QsXLuzs7PziF7/AzQVXDMpRtumhh2yChfEhZPvzn//cr28DyIYipnAH3nvvPXQ47ktOpVKXL1/+6U9/CqncRy8EEEUiZEOf9s4770g6zIGHr732WlvZ0K2hNwMIeNN1UTL5BJLNApANJvTrWxiyofVvbW2JDy4XL170Gjg3N4feD4kyjIR1ko6y8AcWeUVyw95Eb7pEycQTLdlAX76NSrZTp06hZ6NspC8omx/fMPKtt956++23uwwjg8uGMMaQeKjjMHI64TBS8fLLL6Ob+vGPf4xwlwkS9HiJROLkyZO/+93v3AmSvmS7cOHCvXv3cC5OkEwhEZJthBMkUAi92fvvvy9Rd+r/j3/8469+9asXX3wRiejrIJua+P/kkxs3bkjX169s6NM49T+1REi2fk0Dw5LNGpBN1AXQFbKhl5MomXiiIpuFD7WF0coGtba3t8+cOYMhKPq0XC73ox/9yOwjk05UZBuMmZkZ41BgUMQUHgVw7IMPPtjZ2cEYFU+Gb7/9ttlBpoDxlg2gp5K/Pw5Czz8fISQ8xl42QsYFykaIJSgbIZagbIRYgrIRYgnKRoglKBshlqBshFiCshFiiYZs/3Phn2QzcRIKG4VarbBpIoOwWah9tXveRMg4Mfayrays3Lp1a89DkLX3Rkf4sr27W6lVdt81MRIdxl62f7Qjwr5RtuklKrLNzc2ZUD9k9E9VBeS5/p0dU7IF52KuWKkpDirFe+m4SU1mH5erByq5Wt5fW9SJqjUXd+8WKzq98jSXenNtv6zCtYPy/jXJBKkq+Xv7ZZ2n9kU+I8lNsjmp20WTAQd/05HUNizWj18p7j4qubKhdoVyVaUfVMufqtqdvy+vQVG5r3O1fQlkFERFtkKhcPLkSRMJTF+yCR1+/WN1v1orP0gnHCfx3m65Vt2/ppr+6qdI3U3POjFnKfukWnuaTSBVyVYrP1pNzsYTF3dKaMUH5fzV5fjMfOaBKrqqDqikqj7dTi3E4+dW81BFynpkW9wqVquF7Ll4bGZ59VGlc3+1nPtcHwqnS+pDmZxunWPOm9lCtVa8qc/Q3LO1fwlkFERItr/97W/9+jaAbChiCjcBB6r5K9K3JFLXs2sX0SadxJmlRTRTAeO3WmEDAd2zZU2yk/2sVvusHms0dNWz7da/hO1cgxelbdV5u7Kd3/2qVvqw3vLntku18s5/mVgT6pjlnfotwtkqGtmcxOLZRZgmbDyp1R6r2jXL1uElkFEQIdlgQr++DU+2hOpb0F893d+9mVl2v186c94dg2lc2RpNVrXyJ/WYTzb3wcnJFhvpIpsKNOPJ7wWGmN5S43lmi/+sPowUpBpNsnV4CWQUREs20Jdvw5NNET+X2bibL2KcVi3lVGNNbGDcVd7NLOgnuKaerU/ZVMfVKlt1P8hiP51km9vA0LH8IDOvbw2NajTJ1uElkFFA2TTnMtmtzLKJLO98IbMLaqRXn8zQ47eBZbucbxlGpvPI+tD9tR3HqY/1/KhjthtGNlVDj2bbyNbhJZBRwGGkZiVXqlWLt8/j/h8/t12EGXeWYrElNTPxLJdamJ//+Xbx6/oYLKhsMqvhOLNpNeXyZMM3QbJ8t4Rxa/79JScWX76aL1f2V0+o9Ba8EyQb+xjtimxnVZ1Ld1LzC/Op26hyvRpqyFotXE8kZvFqOrwEMgo4QWJYvLLrTv2XHtZnyL1z7vcwatO9U1DZKoUHBZnZrz7bbTf1H0/fM58fqONf6Twr32Hqf/Ga+Wih8nR353G19mxb+2yeP818SduXQEZBhGTr1zQwRNmGjZKtMYwMiHLVR/8HIVElKrJZ+FBbiLRsZKLpIduJo/+RPvHv3s3siAaz+oeI+8L9xYyQoWzETw/Z3ER3u7/4r2ZfNEBPJX9/HIQOfz5CiA26yYZ+zE30bt8k/7l49l98242T/2aKEULa0Vs2qBVkQ863vv9tU5IQ0kJv2fDYZuKdQR7kjNoTHSGRYvSy/d+3vsWNm7uZZjGJUDZu0dpeffXVl156yTSOySIqsp04cSJBphtpCQgcP37c/cnISSIqsuES/yeZbqQlzM/PIxyPx1944QXTRCaFaMn2xhtvoIsj04m0hIWFBfiG6CuvvPKd73zHtJKJIFqy4RJjCPHaQPyyhZWVFbOPjAOubKdPn0ZjQMrRo0ePHDliGsr401s2/PvW97/dfXNzmpL94JMNlxi3NKcfINV/d2Bzc9Nk6od3cp//dW/NRPokQNkzv7y29sszJkJcpCWcOnVKRpLHjh1D4iR1bt1kk/4q+BakD2ylVTZcYozXcZUDcvPmzf9t4e9//7uk41+Tryvrf/nmm7+sS/j8J391w/3Su+zZj55+883j35gYcZGWgGYwNzeHB4qZmZkpkg3AH/RXQTZToH/aytbXJd7b2zN/Zezh+fPn2HXr1i2Egywj6f1amloQzv2KWp8cpuyUc/iWEHF6yGaBUGUDQXwrmC+PAfWtUCXMZ7m1T/WXLg8qxbspWbIAQlYe7XiWiFxKeVeP1Jl02d3cU/3FNE9ZD43vj/oyFz5M1jMvNs5+P19qfN90kqFsoRO2bCCIb/6eTa2SkErMJJIfqkUScmdVuspTLW7/fD4+s6zWJziAY7JagVq2sXR3yV/2JpIr+UuqrIdm2Wrl/NUkMuulDUxmtWJCtbRzeT4xm1x9pKyjbBPAxMoGYJdL9+WQgV82s8QA0G6s6xB6tgcpnRiLXdQrINRXhnSL686qvoxkLLH9rGlpLI2vZ3Mzq4WGqo8ySN79qr6esaKRf7KhbKETnmw++pOt8dzVaOtKNteBxnIjiibZGmVjqQetj3DNsrXJ7LOLsk0IlM0QBdkyj6o6StkoWzhMoGx9DSMbJ9KZ1TAyuVOule/Vl7GkbJMCZTOoLuiLneRsIuEcWrZ2EyROcm37ZlqvVtcsm5ogWY7H4ss6sxxQT5ComRhOkFC2YRIR2WLv5kpqDVP16xaHla3dbP7SnVLtoLCmgs2yPcvvupm3OPVP2cIkKrLZo1m2htVecA1MyPM7ARMOZQudqZINLy3+MzyRmc8MOsmWvFeWpctjM8vqR9XqSyBPNpQtdKZKtuTHanBYebwhS4137Nl8Pxfa5UdJJwjKFjpTJRvpAmULncNf4oCLkHOF1ogzRbKNiqFcYogE5bpga9VxMjiULXQm/hKTgFC20KFsRKBsoUPZiEDZQoeyEYGyhQ5lIwJlCx3KRgTKFjrDusRmjt8DP1gbLyhb6Bz+EkMq87l1C7cCrKsVnM5/NzxEFtPrG/JVnPaobxuoVYmaafxx8/hC2ULn8JcYRhm3PDx//lzSA/rmfkemC1ZkWysc1Ep31NpB7aFsY8skyNb2byMPs25kJ6zI1gvKNrZMuGwgiG9oqXWkHTtL1/Ml/ZXOWqWUv2ZGdR7ZFjeeVGvl3fSMjlxzMxd3LsVVklKimLu+X25eVdKL+iqqZxXK/BU5i1cbJ7lVkCPgyLuSwSPb4mZBVUKdsalU6nbRlBqrbwxQttAJWzYQxDdvz+Zczldqlf31xmoF+cuqydZlc1L3y7VqQb4n46g17cq77yUcJ5G6U6oifU6UqOnvpMUTyW219KReVdKLOmN9FUq99kExi4IebRLr2iUcORY/r1aV1BnqsuG8qhKbfkUXt4qoQ/ZcPKYOWxmj78JRttAJSTYAu1z6WTfSQbi6v1bvEZy1fbXoFaIim+lPLsp+nVmt0iNk8l/rRSaVEqVtJY9CHfyxMdkFiY1VKPVJSh8mPNq46/8IyxsPC7lLddkWN1Ql7rv9pVtKrTmpj6NR3/JWCz2MBZQtdMKTzUdg2Zrbayy2dLck/YOS7VmphDHdw3S9lavMPlSj9wz2gOfgDZRs7oomMSf7mUSbtClu1c/jojUuPUMl8m4lPKVUoJmxWVKBsoVO9GVTX692ZcMo8VKudOD2bDpzyxCxf9lUPxZYNowe07nP2/ZsCFT3r0rimEHZQid6svUYRiLpPPQr7+qWnsg+rdWeZl01UXn1X9+yqfFn12HkYno9mznnOfK7O+WG826ptHrcfJjWicBUZyygbKETEdm860bqCZL6co7r+2i9zRMkaMMpdDt44kKqcxUuVou3z8djTuLidvHrci7ZUTbP6pE6sVrcvqhmVtIP9IxLPxMkqhKo81fifKOUWnMSlX9/CaWWr+bLlf3VEyo9+lC20ImIbN51I9GOl67vl6vyyFPKX0fDVTRkQw49Y6kl9GQ+KJu1HzvI5lk9Uvdsj3cLMvX/dcnM7Hu0UW66U//l4nbjQ4X6kZ2MqsSjjNNUKp6+Z37IqvGBwThA2UInKrJZp3kYSShb+FA2IlC20KFsRKBsoTO1shEflC10Dn+JM1w3ciKgbKEzlEvMdSMnAMoWOhN/iUlAKFvoUDYiULbQoWxEoGyhI5eYGzfZKFuI+K41tynfKFu4vPrqq7jE8/PzC5pTp07hciOFTCF46ylbiLz00kvHjx/HJYZvp0+fxr9zc3Ny0ckUAuUoW4i8+OKL8Xgcl1gu9xtvvIEwmVpef/11yhYiL7zwwiuvvIJLfOzYsZmZGQTINIObL2ULEVzZo0eP4hITAr773e9SthA5cuQIri8hAtqDaRnjT+RkI2RSoWyEWIKyEWIJykaIJSgbIZagbIRYgrIRYgnKRoglKBshlqBshFiCshFiCcpGiCUoGyGWoGyEWIKyEWIJykaIJSgbIZagbIRYgrIRYgnKRoglKBshlqBshFiCshFiCcpGiCUoGyGWoGyEWIKyEWIJykaIJSgbIZagbIRYgrIRYgnKRoglKBshlqBshFiCshFiCcpGiCUoGyGWoGyEWIKyEWIJykaIJSgbIZagbIRYgrIRYgnKRoglKBshlqBshFiCshFiCcpGiCUoGyGWoGyEWIKyEWIJykaIJSgbIZagbIRYgrIRYgnKRoglKBshlqBshFiCshFiCcpGiCUoGyGWoGyEWIKyEWIJykaIJSgbIZagbIRYgrIRYoVY7P8BlC4WUdxmN9sAAAAASUVORK5CYII=)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "egF9j-Wnwo2z"
      },
      "source": [
        "## Download and set up required files by running the cell"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "q7HC3z2JwqCz"
      },
      "outputs": [],
      "source": [
        "!git clone https://github.com/XronTrix10/Telegram-Leecher &>/dev/null && bash /content/Telegram-Leecher/setup.sh &>/dev/null\n",
        "\n",
        "print('Files and modules setup Successfull')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3lGTb1yExfob"
      },
      "source": [
        "## Edit the Variables with your data and run the cell"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "NCvkOIsIxggT"
      },
      "outputs": [],
      "source": [
        "api_id    =             # <== YOUR TELEGRAM API ID HERE\n",
        "api_hash  = \"\"          # <== YOUR TELEGRAM API HASH HERE ( Place Inside Quotes )\n",
        "bot_token = \"\"          # <== YOUR TELEGRAM BOT TOKEN HERE ( Place Inside Quotes )\n",
        "chat_id   =             # <== YOUR CHAT ID WHERE ALL STATUS AND LOGS WILL BE SHOWN\n",
        "dump_id   =             # <== CHAT ID WHERE ALL FILES WILL BE UPLOADED ( MUST BE A CHANNEL OR SUPERGROUP )\n",
        "\n",
        "# NOTE: Make sure to add the Bot to the Dump Channel/Super-Group as Admin\n",
        "\n",
        "print('BOT Variables Initialized !')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5cQBmcILyrid"
      },
      "source": [
        "# RUN THIS MAIN CODE TO START LEECHING\n",
        "\n",
        "### Don't Worry about the red line errors, it will run fine !"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "dzX50Q4wzsgt"
      },
      "outputs": [],
      "source": [
        "import os\n",
        "import io\n",
        "import re\n",
        "# import sys\n",
        "import cv2\n",
        "import time\n",
        "import shutil\n",
        "import pickle\n",
        "import uvloop\n",
        "import zipfile\n",
        "import datetime\n",
        "import subprocess\n",
        "from PIL import Image\n",
        "from pyrogram import Client\n",
        "from natsort import natsorted\n",
        "from urllib.parse import urlparse\n",
        "from re import search as re_search\n",
        "from os import makedirs, path as ospath\n",
        "from IPython.display import clear_output\n",
        "from urllib.parse import parse_qs, urlparse\n",
        "from googleapiclient.discovery import build\n",
        "from googleapiclient.errors import HttpError\n",
        "from googleapiclient.http import MediaIoBaseDownload\n",
        "from pyrogram.types import (\n",
        "    ReplyKeyboardMarkup,\n",
        "    InlineKeyboardMarkup,\n",
        "    InlineKeyboardButton,\n",
        ")\n",
        "\n",
        "uvloop.install()\n",
        "\n",
        "\n",
        "# =================================================================\n",
        "#    Local OS Functions\n",
        "# =================================================================\n",
        "\n",
        "\n",
        "def convert_seconds(seconds):\n",
        "    seconds = int(seconds)\n",
        "    days = seconds // (24 * 3600)\n",
        "    seconds = seconds % (24 * 3600)\n",
        "    hours = seconds // 3600\n",
        "    seconds %= 3600\n",
        "    minutes = seconds // 60\n",
        "    seconds %= 60\n",
        "\n",
        "    if days > 0:\n",
        "        return f\"{days}d {hours}h {minutes}m {seconds}s\"\n",
        "    elif hours > 0:\n",
        "        return f\"{hours}h {minutes}m {seconds}s\"\n",
        "    elif minutes > 0:\n",
        "        return f\"{minutes}m {seconds}s\"\n",
        "    else:\n",
        "        return f\"{seconds}s\"\n",
        "\n",
        "\n",
        "def size_measure(size):\n",
        "    if size > 1024 * 1024 * 1024 * 1024:\n",
        "        siz = f\"{size/(1024**4):.2f} TiB\"\n",
        "    elif size > 1024 * 1024 * 1024:\n",
        "        siz = f\"{size/(1024**3):.2f} GiB\"\n",
        "    elif size > 1024 * 1024:\n",
        "        siz = f\"{size/(1024**2):.2f} MiB\"\n",
        "    elif size > 1024:\n",
        "        siz = f\"{size/1024:.2f} KiB\"\n",
        "    else:\n",
        "        siz = f\"{size} B\"\n",
        "    return siz\n",
        "\n",
        "\n",
        "def get_file_type(file_path):\n",
        "    name, extension = os.path.splitext(file_path)\n",
        "\n",
        "    extensions_dict = {\n",
        "        \".mp4\": \"video\",\n",
        "        \".avi\": \"video\",\n",
        "        \".mkv\": \"video\",\n",
        "        \".mov\": \"video\",\n",
        "        \".webm\": \"video\",\n",
        "        \".m4v\": \"video\",\n",
        "        \".mp3\": \"audio\",\n",
        "        \".wav\": \"audio\",\n",
        "        \".flac\": \"audio\",\n",
        "        \".aac\": \"audio\",\n",
        "        \".ogg\": \"audio\",\n",
        "        \".jpg\": \"photo\",\n",
        "        \".jpeg\": \"photo\",\n",
        "        \".png\": \"photo\",\n",
        "        \".gif\": \"photo\",\n",
        "    }\n",
        "\n",
        "    if extension in extensions_dict:\n",
        "        if extensions_dict[extension] == \"video\":\n",
        "            video_extension_fixer(file_path)\n",
        "        return extensions_dict[extension]\n",
        "    else:\n",
        "        return \"document\"\n",
        "\n",
        "\n",
        "def get_folder_size(folder_path):\n",
        "    total_size = 0\n",
        "    for dirpath, dirnames, filenames in os.walk(folder_path):\n",
        "        for f in filenames:\n",
        "            fp = os.path.join(dirpath, f)\n",
        "            total_size += os.path.getsize(fp)\n",
        "    return total_size\n",
        "\n",
        "\n",
        "def get_file_count(folder_path):\n",
        "    count = 0\n",
        "    for dirpath, dirnames, filenames in os.walk(folder_path):\n",
        "        for f in filenames:\n",
        "            count += 1\n",
        "    return count\n",
        "\n",
        "\n",
        "def video_extension_fixer(file_path):\n",
        "    dir_path, filename = os.path.split(file_path)\n",
        "\n",
        "    if filename.endswith(\".mp4\") or filename.endswith(\".mkv\"):\n",
        "        pass\n",
        "    # split the file name and the extension\n",
        "    else:\n",
        "        # rename the video file with .mp4 extension\n",
        "        name, ext = os.path.splitext(filename)\n",
        "        os.rename(os.path.join(dir_path, filename), os.path.join(dir_path, name + \".mp4\"))\n",
        "        print(f\"{filename} was changed to {name}.mp4\")\n",
        "\n",
        "\n",
        "async def zip_folder(folder_path):\n",
        "    output_path = folder_path + \".zip\"\n",
        "    # Calculate total size of folder to track progress\n",
        "    total_size = 0\n",
        "    for dirpath, dirnames, filenames in os.walk(folder_path):\n",
        "        for f in filenames:\n",
        "            fp = os.path.join(dirpath, f)\n",
        "            total_size += os.path.getsize(fp)\n",
        "\n",
        "    # Create zip file object\n",
        "    with zipfile.ZipFile(output_path, \"w\", zipfile.ZIP_DEFLATED) as zip_file:\n",
        "        # Walk through each file in the folder\n",
        "        current_size = 0\n",
        "        for dirpath, dirnames, filenames in os.walk(folder_path):\n",
        "            for f in filenames:\n",
        "                fp = os.path.join(dirpath, f)\n",
        "\n",
        "                # Add file to zip file object and print progress\n",
        "                with open(fp, \"rb\") as file:\n",
        "                    relative_path = os.path.relpath(fp, folder_path)\n",
        "                    zip_file.write(fp, arcname=relative_path)\n",
        "                    current_size += os.path.getsize(fp)\n",
        "                    percentage = int((current_size / total_size) * 100)\n",
        "                    print(\n",
        "                        f\"Zipping - {percentage:.2f}%\"\n",
        "                        + f\" ({size_measure(current_size)}/{size_measure(total_size)})\"\n",
        "                    )\n",
        "\n",
        "                    # Delete the file after writing it to the zip object.\n",
        "                    os.remove(fp)\n",
        "\n",
        "                    bar_length = 14\n",
        "                    filled_length = int(percentage / 100 * bar_length)\n",
        "                    bar = \"⬢\" * filled_length + \"⬡\" * (bar_length - filled_length)\n",
        "                    message = (\n",
        "                        f\"\\n[{bar}] » {percentage:.2f}%\"\n",
        "                        + f\"\\n✅ DONE: __{size_measure(current_size)}__ OF __{size_measure(total_size)}__\"\n",
        "                    )\n",
        "\n",
        "                    try:\n",
        "                        # Edit the message with updated progress information.\n",
        "                        if is_time_over(current_time):\n",
        "                            await bot.edit_message_text(\n",
        "                                chat_id=chat_id,\n",
        "                                message_id=msg.id,\n",
        "                                text=down_msg + message,\n",
        "                            )\n",
        "\n",
        "                    except Exception as e:\n",
        "                        # Catch any exceptions that might occur while editing the message.\n",
        "                        print(f\"Error updating progress bar: {str(e)}\")\n",
        "\n",
        "    return output_path\n",
        "\n",
        "\n",
        "async def extract_zip(zip_filepath):\n",
        "    if not os.path.exists(temp_unzip_path):\n",
        "        makedirs(temp_unzip_path)\n",
        "\n",
        "    with zipfile.ZipFile(zip_filepath) as zf:\n",
        "        num_files = len(zf.infolist())\n",
        "\n",
        "        total_size = sum(file.file_size for file in zf.infolist())\n",
        "        extracted_size = 0\n",
        "        print(f\"Extracting {num_files} files...\")\n",
        "        for i, member in enumerate(zf.infolist(), 1):\n",
        "            # print(f\"Extracting {member.filename} ({member.file_size} bytes)\")\n",
        "            extracted_size += member.file_size\n",
        "            zf.extract(member, temp_unzip_path)\n",
        "            percent_complete = (extracted_size / total_size) * 100 if total_size else 0\n",
        "\n",
        "            down_msg = f\"<b>📂 EXTRACTING:</b>\\n\\n<code>{d_name}</code>\\n\"\n",
        "\n",
        "            bar_length = 14\n",
        "            filled_length = int(percent_complete / 100 * bar_length)\n",
        "            bar = \"⬢\" * filled_length + \"⬡\" * (bar_length - filled_length)\n",
        "            message = (\n",
        "                f\"\\n[{bar}] » {percent_complete:.2f}%\"\n",
        "                + f\"\\n✅ DONE: __{size_measure(extracted_size)}__ OF \"\n",
        "                + f\"__{size_measure(os.stat(zip_filepath).st_size)}__\"\n",
        "            )\n",
        "\n",
        "            print(message)\n",
        "\n",
        "            try:\n",
        "                # Edit the message with updated progress information.\n",
        "                if is_time_over(current_time):\n",
        "                    await bot.edit_message_text(\n",
        "                        chat_id=chat_id,\n",
        "                        message_id=msg.id,\n",
        "                        text=down_msg + message,\n",
        "                    )\n",
        "\n",
        "            except Exception as e:\n",
        "                # Catch any exceptions that might occur while editing the message.\n",
        "                print(f\"Error updating progress bar: {str(e)}\")\n",
        "\n",
        "\n",
        "async def size_checker(file_path):\n",
        "    max_size = 2097152000  # 2 GB\n",
        "    file_size = os.stat(file_path).st_size\n",
        "\n",
        "    if file_size > max_size:\n",
        "        print(f\"File size is {size_measure(file_size)} SPLITTING.......\")\n",
        "\n",
        "        if not ospath.exists(temp_lpath):\n",
        "            makedirs(temp_lpath)\n",
        "\n",
        "        await split_zipFile(file_path, max_size)\n",
        "\n",
        "        return True\n",
        "    else:\n",
        "        print(f\"File size is {size_measure(file_size)} MB. NOT SPLITTING.......\")\n",
        "        return False\n",
        "\n",
        "\n",
        "async def split_zipFile(file_path, max_size):\n",
        "    dir_path, filename = os.path.split(file_path)\n",
        "    new_path = f\"{temp_lpath}/{filename}\"\n",
        "    down_msg = (\n",
        "        f\"<b>✂️ SPLITTING !</b>\\n\\n<code>{d_name}</code>\\n\"\n",
        "        + f\"\\nSIZE: {size_measure(os.stat(file_path).st_size)}\\n\"\n",
        "    )\n",
        "    # Get the total size of the file\n",
        "    total_size = os.path.getsize(file_path)\n",
        "\n",
        "    with open(file_path, \"rb\") as f:\n",
        "        chunk = f.read(max_size)\n",
        "        i = 1\n",
        "        bytes_written = 0\n",
        "\n",
        "        while chunk:\n",
        "            # Generate filename for this chunk\n",
        "            ext = str(i).zfill(3)\n",
        "            output_filename = \"{}.{}\".format(new_path, ext)\n",
        "\n",
        "            # Write chunk to file\n",
        "            with open(output_filename, \"wb\") as out:\n",
        "                out.write(chunk)\n",
        "\n",
        "            bytes_written += len(chunk)\n",
        "            progress_percent = bytes_written / total_size * 100\n",
        "\n",
        "            bar_length = 14\n",
        "            filled_length = int(progress_percent / 100 * bar_length)\n",
        "            bar = \"⬢\" * filled_length + \"⬡\" * (bar_length - filled_length)\n",
        "            message = (\n",
        "                f\"\\n[{bar}] » {progress_percent:.2f}%\"\n",
        "                + f\"\\n✅ DONE: __{size_measure(bytes_written)}__ OF __{size_measure(total_size)}__\"\n",
        "            )\n",
        "            print(message)\n",
        "            try:\n",
        "                await bot.edit_message_text(\n",
        "                    chat_id=chat_id,\n",
        "                    message_id=msg.id,\n",
        "                    text=down_msg + message,\n",
        "                )\n",
        "            except Exception as e:\n",
        "                # Catch any exceptions that might occur while editing the message.\n",
        "                print(f\"Error updating progress bar: {str(e)}\")\n",
        "\n",
        "            # Get next chunk\n",
        "            chunk = f.read(max_size)\n",
        "            # Increment chunk counter\n",
        "            i += 1\n",
        "\n",
        "\n",
        "def is_time_over(current_time):\n",
        "    ten_sec_passed = time.time() - current_time[0] >= 3\n",
        "    if ten_sec_passed:\n",
        "        current_time[0] = time.time()\n",
        "    return ten_sec_passed\n",
        "\n",
        "\n",
        "# =================================================================\n",
        "#    Direct Link Handler Functions\n",
        "# =================================================================\n",
        "\n",
        "\n",
        "async def on_output(output: str):\n",
        "    # print(\"=\" * 60 + f\"\\n\\n{output}\\n\\n\" + \"*\" * 60)\n",
        "\n",
        "    total_size = \"0B\"\n",
        "    progress_percentage = \"0B\"\n",
        "    downloaded_bytes = \"0B\"\n",
        "    chunk_size = \"0B\"\n",
        "    eta = \"0S\"\n",
        "    try:\n",
        "        if \"ETA:\" in output:\n",
        "            parts = output.split()\n",
        "            total_size = parts[1].split(\"/\")[1]\n",
        "            total_size = total_size.split(\"(\")[0]\n",
        "            progress_percentage = parts[1][parts[1].find(\"(\") + 1 : parts[1].find(\")\")]\n",
        "            downloaded_bytes = parts[1].split(\"/\")[0]\n",
        "            eta = parts[4].split(\":\")[1][:-1]\n",
        "    except Exception as do:\n",
        "        print(f\"Could't Get Info Due to: {do}\")\n",
        "\n",
        "    # print(\"Total download size:\", total_size)\n",
        "    # print(\"Progress percentage:\", progress_percentage)\n",
        "    # print(\"Downloaded bytes:\", downloaded_bytes)\n",
        "    # print(\"Estimated Time:\", eta)\n",
        "\n",
        "    percentage = re.findall(\"\\d+\\.\\d+|\\d+\", progress_percentage)[0]\n",
        "    down = re.findall(\"\\d+\\.\\d+|\\d+\", downloaded_bytes)[0]\n",
        "    down_unit = re.findall(\"[a-zA-Z]+\", downloaded_bytes)[0]\n",
        "    if \"G\" in down_unit:\n",
        "        spd = 3\n",
        "    elif \"M\" in down_unit:\n",
        "        spd = 2\n",
        "    elif \"K\" in down_unit:\n",
        "        spd = 1\n",
        "    else:\n",
        "        spd = 0\n",
        "\n",
        "    bar_length = 14\n",
        "    filled_length = int(int(percentage) / 100 * bar_length)\n",
        "    bar = \"⬢\" * filled_length + \"⬡\" * (bar_length - filled_length)\n",
        "\n",
        "    # Calculate download speed\n",
        "    elapsed_time_seconds = (datetime.datetime.now() - start_time).seconds\n",
        "    try:\n",
        "        current_speed = (float(down) * 1024**spd) / elapsed_time_seconds\n",
        "        speed_string = f\"{size_measure(current_speed)}/s\"\n",
        "        message = f\"\\n[{bar}] » {percentage}%\\n⚡️ __{speed_string}__  ⏳ ETA: __{eta}__\\n✅ DONE: __{downloaded_bytes}__ OF __{total_size}__\"\n",
        "    except Exception as e1:\n",
        "        print(f\"Error On Output: {e1}\")\n",
        "        message = f\"\\nRetrying updating Progress.....\"\n",
        "    down_msg = f\"<b>📥 DOWNLOADING:</b>\\n\\n<code>{d_name}</code>\\n\"\n",
        "\n",
        "    print(message)\n",
        "\n",
        "    try:\n",
        "        # Edit the message with updated progress information.\n",
        "        if is_time_over(current_time) and total_size != \"0B\":\n",
        "            await bot.edit_message_text(\n",
        "                chat_id=chat_id,\n",
        "                message_id=msg.id,\n",
        "                text=down_msg + message,\n",
        "                reply_markup=InlineKeyboardMarkup(\n",
        "                    [\n",
        "                        [  # First row\n",
        "                            InlineKeyboardButton(  # Opens a web URL\n",
        "                                \"Source URL 🔗\", url=links[0]\n",
        "                            ),\n",
        "                            InlineKeyboardButton(  # Opens a web URL\n",
        "                                \"BOT REPO 🐈‍⬛\",\n",
        "                                url=\"https://github.com/XronTrix10/Telegram-Leecher\",\n",
        "                            ),\n",
        "                        ]\n",
        "                    ]\n",
        "                ),\n",
        "            )\n",
        "\n",
        "    except Exception as e:\n",
        "        # Catch any exceptions that might occur while editing the message.\n",
        "        print(f\"Error updating progress bar: {str(e)}\")\n",
        "\n",
        "\n",
        "async def aria2_Download(link):\n",
        "    # Create a command to run aria2p with the link\n",
        "    command = [\n",
        "        \"aria2c\",\n",
        "        \"--summary-interval=1\",\n",
        "        \"--console-log-level=notice\",\n",
        "        \"-d\",\n",
        "        d_fol_path,\n",
        "        link,\n",
        "    ]\n",
        "\n",
        "    # Run the command using subprocess.Popen\n",
        "    process = subprocess.Popen(\n",
        "        command, bufsize=0, stdout=subprocess.PIPE, stderr=subprocess.PIPE\n",
        "    )\n",
        "\n",
        "    # Read and print output in real-time\n",
        "    while True:\n",
        "        output = process.stdout.readline()\n",
        "\n",
        "        if output == b\"\" and process.poll() is not None:\n",
        "            break\n",
        "        if output:\n",
        "            # sys.stdout.write(output.decode(\"utf-8\"))\n",
        "            # sys.stdout.flush()\n",
        "            await on_output(output.decode(\"utf-8\"))\n",
        "\n",
        "    # Retrieve exit code and any error output\n",
        "    exit_code = process.wait()\n",
        "    error_output = process.stderr.read()\n",
        "    if exit_code != 0:\n",
        "        raise Exception(\n",
        "            f\"aria2c command failed with return code {exit_code}\\n\\nError: {error_output}\"\n",
        "        )\n",
        "\n",
        "\n",
        "# =================================================================\n",
        "#    G Drive Functions\n",
        "# =================================================================\n",
        "\n",
        "\n",
        "def build_service():\n",
        "    # create credentials object from token.pickle file\n",
        "    creds = None\n",
        "    if os.path.exists(\"/content/token.pickle\"):\n",
        "        with open(\"/content/token.pickle\", \"rb\") as token:\n",
        "            creds = pickle.load(token)\n",
        "    else:\n",
        "        exit(1)\n",
        "\n",
        "    # create drive API client\n",
        "    service = build(\"drive\", \"v3\", credentials=creds)\n",
        "\n",
        "    return service\n",
        "\n",
        "\n",
        "async def g_DownLoad(link):\n",
        "    global start_time\n",
        "\n",
        "    file_id = getIDFromURL(link)\n",
        "\n",
        "    meta = getFileMetadata(file_id)\n",
        "\n",
        "    # d_name = meta[\"name\"]\n",
        "    nd_name = meta[\"name\"]\n",
        "\n",
        "    nd_fol_path = f\"{d_fol_path}/{nd_name}\"\n",
        "\n",
        "    if meta.get(\"mimeType\") == \"application/vnd.google-apps.folder\":\n",
        "        folder_info[0] = get_Gfolder_size(file_id)\n",
        "        print(f\"\\nTotal Download size is: {size_measure(folder_info[0])}\")\n",
        "        current_time[0] = time.time()\n",
        "        start_time = datetime.datetime.now()\n",
        "        await gDownloadFolder(file_id, d_fol_path)\n",
        "        clear_output()\n",
        "        print(\"*\" * 40 + \"\\n Folder Download Complete\\n\" + \"*\" * 40)\n",
        "\n",
        "    else:\n",
        "        file_metadata = getFileMetadata(file_id)\n",
        "        folder_info[0] = int(\n",
        "            file_metadata[\"size\"]\n",
        "        )  # Get the file size from the metadata:\n",
        "        print(f\"\\nTotal Download size is: {size_measure(folder_info[0])}\")\n",
        "\n",
        "        if not ospath.exists(nd_fol_path):\n",
        "            makedirs(nd_fol_path)\n",
        "        current_time[0] = time.time()\n",
        "        start_time = datetime.datetime.now()\n",
        "        await gDownloadFile(file_id, nd_fol_path)\n",
        "        clear_output()\n",
        "        print(\"*\" * 40 + \"\\n File Download Complete\\n\" + \"*\" * 40)\n",
        "\n",
        "\n",
        "def getIDFromURL(link: str):\n",
        "    if \"folders\" in link or \"file\" in link:\n",
        "        regex = r\"https:\\/\\/drive\\.google\\.com\\/(?:drive(.*?)\\/folders\\/|file(.*?)?\\/d\\/)([-\\w]+)\"\n",
        "        res = re_search(regex, link)\n",
        "        if res is None:\n",
        "            raise IndexError(\"G-Drive ID not found.\")\n",
        "        return res.group(3)\n",
        "    parsed = urlparse(link)\n",
        "    return parse_qs(parsed.query)[\"id\"][0]\n",
        "\n",
        "\n",
        "def getFilesByFolderID(folder_id):\n",
        "    page_token = None\n",
        "    files = []\n",
        "    while True:\n",
        "        response = (\n",
        "            service.files()\n",
        "            .list(\n",
        "                supportsAllDrives=True,\n",
        "                includeItemsFromAllDrives=True,\n",
        "                q=f\"'{folder_id}' in parents and trashed = false\",\n",
        "                spaces=\"drive\",\n",
        "                pageSize=200,\n",
        "                fields=\"nextPageToken, files(id, name, mimeType, size, shortcutDetails)\",\n",
        "                orderBy=\"folder, name\",\n",
        "                pageToken=page_token,\n",
        "            )\n",
        "            .execute()\n",
        "        )\n",
        "        files.extend(response.get(\"files\", []))\n",
        "        page_token = response.get(\"nextPageToken\")\n",
        "        if page_token is None:\n",
        "            break\n",
        "    return files\n",
        "\n",
        "\n",
        "def getFileMetadata(file_id):\n",
        "    return (\n",
        "        service.files()\n",
        "        .get(fileId=file_id, supportsAllDrives=True, fields=\"name, id, mimeType, size\")\n",
        "        .execute()\n",
        "    )\n",
        "\n",
        "\n",
        "def get_Gfolder_size(folder_id):\n",
        "    try:\n",
        "        query = \"trashed = false and '{0}' in parents\".format(folder_id)\n",
        "        results = (\n",
        "            service.files()\n",
        "            .list(\n",
        "                supportsAllDrives=True,\n",
        "                includeItemsFromAllDrives=True,\n",
        "                q=query,\n",
        "                fields=\"files(id, mimeType, size)\",\n",
        "            )\n",
        "            .execute()\n",
        "        )\n",
        "\n",
        "        total_size = 0\n",
        "        items = results.get(\"files\", [])\n",
        "\n",
        "        folders_without_size = (\n",
        "            item[\"id\"]\n",
        "            for item in items\n",
        "            if item.get(\"size\") is None\n",
        "            and item[\"mimeType\"] == \"application/vnd.google-apps.folder\"\n",
        "        )\n",
        "\n",
        "        for item in items:\n",
        "            # If the item has a size attribute\n",
        "            if \"size\" in item:\n",
        "                total_size += int(item[\"size\"])\n",
        "\n",
        "        # Recursively call the function for folders whose size is not found\n",
        "        for folder_id in folders_without_size:\n",
        "            total_size += get_Gfolder_size(folder_id)\n",
        "\n",
        "        return total_size\n",
        "\n",
        "    except HttpError as error:\n",
        "        print(f\"Error while checking size: {error}\")\n",
        "        return -1\n",
        "\n",
        "\n",
        "async def downloadProgress(file_size):\n",
        "    global start_time\n",
        "\n",
        "    down_done = sum(down_bytes) + file_size\n",
        "\n",
        "    speed_string = \"\"\n",
        "\n",
        "    if down_done > 0:\n",
        "        elapsed_time_seconds = (datetime.datetime.now() - start_time).seconds\n",
        "        down_speed = down_done / elapsed_time_seconds\n",
        "        speed_string = f\"{size_measure(down_speed)}/s\"\n",
        "\n",
        "    eta = (folder_info[0] - down_done) / down_speed\n",
        "    eta = convert_seconds(eta)\n",
        "\n",
        "    down_msg = f\"<b>📥 DOWNLOADING: </b>\\n\\n<code>{d_name}</code>\\n\"\n",
        "\n",
        "    percentage = down_done / folder_info[0] * 100\n",
        "    bar_length = 14\n",
        "    filled_length = int(percentage / 100 * bar_length)\n",
        "    bar = \"⬢\" * filled_length + \"⬡\" * (bar_length - filled_length)\n",
        "    message = f\"\\n[{bar}] » {percentage:.2f}%\\n⚡️ __{speed_string}__  ⏳ ETA: __{eta}__\\n✅ DONE: __{size_measure(down_done)}__ OF __{size_measure(folder_info[0])}__\"\n",
        "    try:\n",
        "        print(message)\n",
        "        # Edit the message with updated progress information.\n",
        "        if is_time_over(current_time):\n",
        "            await bot.edit_message_text(\n",
        "                chat_id=chat_id,\n",
        "                message_id=msg.id,\n",
        "                text=down_msg + message,\n",
        "                reply_markup=InlineKeyboardMarkup(\n",
        "                    [\n",
        "                        [  # First row\n",
        "                            InlineKeyboardButton(  # Opens a web URL\n",
        "                                \"Source URL 🔗\", url=link\n",
        "                            ),\n",
        "                            InlineKeyboardButton(  # Opens a web URL\n",
        "                                \"BOT REPO 🐈‍⬛\",\n",
        "                                url=\"https://github.com/XronTrix10/Telegram-Leecher\",\n",
        "                            ),\n",
        "                        ]\n",
        "                    ]\n",
        "                ),\n",
        "            )\n",
        "\n",
        "    except Exception as e:\n",
        "        # Catch any exceptions that might occur while editing the message.\n",
        "        print(f\"Error updating progress bar: {str(e)}\")\n",
        "\n",
        "\n",
        "async def gDownloadFile(file_id, path):\n",
        "    # Check if the specified file or folder exists and is downloadable.\n",
        "    try:\n",
        "        file = getFileMetadata(file_id)\n",
        "    except HttpError as error:\n",
        "        print(\"An error occurred: {0}\".format(error))\n",
        "        file = None\n",
        "    if file is None:\n",
        "        print(\n",
        "            \"Sorry, the specified file or folder does not exist or is not accessible.\"\n",
        "        )\n",
        "    else:\n",
        "        if file[\"mimeType\"].startswith(\"application/vnd.google-apps\"):\n",
        "            print(\n",
        "                \"Sorry, the specified ID is for a Google Docs, Sheets, Slides, or Forms document. You can only download these types of files in specific formats.\"\n",
        "            )\n",
        "        else:\n",
        "            try:\n",
        "                file_name = file.get(\"name\", f\"untitleddrivefile_{file_id}\")\n",
        "                file_name = os.path.join(path, file_name)\n",
        "                # Create a BytesIO stream to hold the downloaded file data.\n",
        "                file_contents = io.BytesIO()\n",
        "\n",
        "                # Download the file or folder contents to the BytesIO stream.\n",
        "                request = service.files().get_media(\n",
        "                    fileId=file_id, supportsAllDrives=True\n",
        "                )\n",
        "                file_downloader = MediaIoBaseDownload(\n",
        "                    file_contents, request, chunksize=50 * 1024 * 1024\n",
        "                )\n",
        "                done = False\n",
        "                while done is False:\n",
        "                    status, done = file_downloader.next_chunk()\n",
        "                    print(f\"Download progress: {int(status.progress() * 100)}%\")\n",
        "                    # Get current value from file_contents.\n",
        "                    file_contents.seek(0)\n",
        "                    with open(file_name, \"ab\") as f:\n",
        "                        f.write(file_contents.getvalue())\n",
        "                    # Reset the buffer for the next chunk.\n",
        "                    file_contents.seek(0)\n",
        "                    file_contents.truncate()\n",
        "                    # The saved bytes till now\n",
        "                    file_d_size = int(status.progress() * int(file[\"size\"]))\n",
        "                    print(f\"Downloaded size: {size_measure(file_d_size)}\")\n",
        "                    await downloadProgress(file_d_size)\n",
        "\n",
        "                print(f\"DOWNLOADED  =>   {os.path.basename(file_name)}\")\n",
        "                down_bytes.append(int(file[\"size\"]))\n",
        "                down_count[0] += 1\n",
        "\n",
        "            except Exception as e:\n",
        "                print(\"Error downloading: {0}\".format(e))\n",
        "\n",
        "\n",
        "async def gDownloadFolder(folder_id, path):\n",
        "    folder_meta = getFileMetadata(folder_id)\n",
        "    folder_name = folder_meta[\"name\"]\n",
        "    if not ospath.exists(f\"{path}/{folder_name}\"):\n",
        "        makedirs(f\"{path}/{folder_name}\")\n",
        "    path += f\"/{folder_name}\"\n",
        "    result = getFilesByFolderID(folder_id)\n",
        "    if len(result) == 0:\n",
        "        return\n",
        "    result = natsorted(result, key=lambda k: k[\"name\"])\n",
        "    for item in result:\n",
        "        file_id = item[\"id\"]\n",
        "        shortcut_details = item.get(\"shortcutDetails\")\n",
        "        if shortcut_details is not None:\n",
        "            file_id = shortcut_details[\"targetId\"]\n",
        "            mime_type = shortcut_details[\"targetMimeType\"]\n",
        "        else:\n",
        "            mime_type = item.get(\"mimeType\")\n",
        "        if mime_type == \"application/vnd.google-apps.folder\":\n",
        "            await gDownloadFolder(file_id, path)\n",
        "        else:\n",
        "            await gDownloadFile(file_id, path)\n",
        "\n",
        "\n",
        "# =================================================================\n",
        "#    Telegram Upload Functions\n",
        "# =================================================================\n",
        "\n",
        "\n",
        "async def progress_bar(current, total):\n",
        "    global start_time\n",
        "\n",
        "    speed_string = \"\"\n",
        "    upload_speed = 0\n",
        "\n",
        "    if current > 0:\n",
        "        elapsed_time_seconds = (datetime.datetime.now() - start_time).seconds\n",
        "        upload_speed = current / elapsed_time_seconds\n",
        "        speed_string = f\"{size_measure(upload_speed)}/s\"\n",
        "\n",
        "    eta = (total_down_size - current - sum(up_bytes)) / upload_speed\n",
        "    eta = convert_seconds(eta)\n",
        "\n",
        "    percentage = (current + sum(up_bytes)) / total_down_size * 100\n",
        "    bar_length = 14\n",
        "    filled_length = int(percentage / 100 * bar_length)\n",
        "    bar = \"⬢\" * filled_length + \"⬡\" * (bar_length - filled_length)\n",
        "    message = (\n",
        "        f\"\\n[{bar}] » {percentage:.2f}%\\n⚡️ __{speed_string}__\"\n",
        "        + f\" ⏳ ETA: __{eta}__\\n✅ DONE: __{size_measure(current + sum(up_bytes))}__\"\n",
        "        + f\" OF __{size_measure(total_down_size)}__\"\n",
        "    )\n",
        "    try:\n",
        "        print(message)\n",
        "        # Edit the message with updated progress information.\n",
        "        if is_time_over(current_time):\n",
        "            await bot.edit_message_text(\n",
        "                chat_id=chat_id,\n",
        "                message_id=msg.id,\n",
        "                text=text_msg + message,\n",
        "                reply_markup=InlineKeyboardMarkup(\n",
        "                    [\n",
        "                        [  # First row\n",
        "                            InlineKeyboardButton(  # Opens a web URL\n",
        "                                \"Source URL 🔗\", url=link\n",
        "                            ),\n",
        "                            InlineKeyboardButton(  # Opens a web URL\n",
        "                                \"BOT REPO 🐈‍⬛\",\n",
        "                                url=\"https://github.com/XronTrix10/Telegram-Leecher\",\n",
        "                            ),\n",
        "                        ]\n",
        "                    ]\n",
        "                ),\n",
        "            )\n",
        "\n",
        "    except Exception as e:\n",
        "        # Catch any exceptions that might occur while editing the message.\n",
        "        print(f\"Error updating progress bar: {str(e)}\")\n",
        "\n",
        "\n",
        "async def upload_file(file_path, type, file_name):\n",
        "    global sent\n",
        "    # Upload the file\n",
        "    try:\n",
        "        caption = f\"<code>{file_name}</code>\"\n",
        "\n",
        "        if type == \"video\":\n",
        "            with Image.open(thumb_path) as img:\n",
        "                width, height = img.size\n",
        "\n",
        "            data = cv2.VideoCapture(file_path)\n",
        "            frames = data.get(cv2.CAP_PROP_FRAME_COUNT)\n",
        "            fps = data.get(cv2.CAP_PROP_FPS)\n",
        "            seconds = 0\n",
        "            if fps != 0:\n",
        "                seconds = round(frames / fps)\n",
        "\n",
        "            sent = await sent.reply_video(\n",
        "                video=file_path,\n",
        "                supports_streaming=True,\n",
        "                width=width,\n",
        "                height=height,\n",
        "                caption=caption,\n",
        "                thumb=thumb_path,\n",
        "                duration=seconds,\n",
        "                progress=progress_bar,\n",
        "                reply_to_message_id=sent.id,\n",
        "            )\n",
        "\n",
        "        elif type == \"audio\":\n",
        "            sent = await sent.reply_audio(\n",
        "                audio=file_path,\n",
        "                supports_streaming=True,\n",
        "                caption=caption,\n",
        "                thumb=thumb_path,\n",
        "                progress=progress_bar,\n",
        "                reply_to_message_id=sent.id,\n",
        "            )\n",
        "\n",
        "        elif type == \"document\":\n",
        "            sent = await sent.reply_document(\n",
        "                document=file_path,\n",
        "                caption=caption,\n",
        "                thumb=thumb_path,\n",
        "                progress=progress_bar,\n",
        "                reply_to_message_id=sent.id,\n",
        "            )\n",
        "\n",
        "        elif type == \"photo\":\n",
        "            sent = await sent.reply_photo(\n",
        "                photo=file_path,\n",
        "                caption=caption,\n",
        "                progress=progress_bar,\n",
        "                reply_to_message_id=sent.id,\n",
        "            )\n",
        "\n",
        "        clear_output()\n",
        "\n",
        "        sent_file.append(sent)\n",
        "        sent_fileName.append(file_name)\n",
        "        print(f\"\\n{file_name} Sent !\")\n",
        "\n",
        "    except Exception as e:\n",
        "        print(e)\n",
        "\n",
        "\n",
        "async def Leecher(file_path):\n",
        "    global text_msg, start_time, msg, sent\n",
        "\n",
        "    file_type = get_file_type(file_path)\n",
        "    file_name = os.path.basename(file_path)\n",
        "\n",
        "    leech = await size_checker(file_path)\n",
        "\n",
        "    if leech:  # File was splitted\n",
        "        if ospath.exists(file_path):\n",
        "            os.remove(file_path)  # Delete original Big Zip file\n",
        "        print(\"Big Zip File Deleted !\")\n",
        "        # print('\\nNow uploading multiple splitted zip files..........\\n')\n",
        "\n",
        "        dir_list = natsorted(os.listdir(temp_lpath))\n",
        "\n",
        "        count = 1\n",
        "\n",
        "        for dir_path in dir_list:\n",
        "            short_path = os.path.join(temp_lpath, dir_path)\n",
        "            file_type = get_file_type(short_path)\n",
        "            file_name = os.path.basename(short_path)\n",
        "            print(f\"\\nNow uploading {file_name}\\n\")\n",
        "            start_time = datetime.datetime.now()\n",
        "            current_time[0] = time.time()\n",
        "            text_msg = f\"<b>📤 UPLOADING: {count} OF {len(dir_list)} Files</b>\\n\\n<code>{file_name}</code>\\n\"\n",
        "            msg = await bot.edit_message_text(\n",
        "                chat_id=chat_id,\n",
        "                message_id=msg.id,\n",
        "                text=text_msg + \"\\n⏳ __Starting.....__\",\n",
        "            )\n",
        "            await upload_file(short_path, file_type, file_name)\n",
        "            up_bytes.append(os.stat(short_path).st_size)\n",
        "\n",
        "            count += 1\n",
        "\n",
        "        shutil.rmtree(temp_lpath)\n",
        "\n",
        "    else:\n",
        "        file_type = get_file_type(file_path)\n",
        "        file_name = os.path.basename(file_path)\n",
        "        print(f\"\\nNow uploading {file_name}\\n\")\n",
        "        start_time = datetime.datetime.now()\n",
        "        current_time[0] = time.time()\n",
        "        text_msg = f\"<b>📤 UPLOADING:</b>\\n\\n<code>{file_name}</code>\\n\"\n",
        "        msg = await bot.edit_message_text(\n",
        "            chat_id=chat_id, message_id=msg.id, text=text_msg + \"\\n⏳ __Starting.....__\"\n",
        "        )\n",
        "        await upload_file(file_path, file_type, file_name)\n",
        "        up_bytes.append(os.stat(file_path).st_size)\n",
        "\n",
        "        os.remove(file_path)\n",
        "\n",
        "\n",
        "async def Leech(folder_path):\n",
        "    global sent\n",
        "\n",
        "    dump_text = (\n",
        "        f\"<b>📛 Name:</b>  <code>{d_name}</code>\\n\\n<b>📦 Size:</b> <code>{size_measure(total_down_size)}</code>\"\n",
        "        + f\"\\n\\n<b>📂 Total Files:</b>  <code>{get_file_count(folder_path)}</code>\\n\"\n",
        "    )\n",
        "\n",
        "    sent = await bot.send_photo(\n",
        "        chat_id=dump_id,\n",
        "        photo=thumb_path,\n",
        "        caption=dump_text,\n",
        "        reply_markup=InlineKeyboardMarkup(\n",
        "            [\n",
        "                [  # First row\n",
        "                    InlineKeyboardButton(\"Source URL 🔗\", url=link)  # Opens a web URL\n",
        "                ]\n",
        "            ]\n",
        "        ),\n",
        "    )\n",
        "\n",
        "    for dirpath, dirnames, filenames in os.walk(folder_path):\n",
        "        for f in natsorted(filenames):\n",
        "            file_path = os.path.join(dirpath, f)\n",
        "            print(f\"\\nNow uploading {os.path.basename(file_path)}\\n\")\n",
        "            await Leecher(file_path)\n",
        "\n",
        "    shutil.rmtree(folder_path)\n",
        "\n",
        "\n",
        "async def ZipLeech(d_fol_path):\n",
        "    global msg, down_msg, start_time, d_name, total_down_size, sent\n",
        "\n",
        "    down_msg = f\"\\n<b>🔐 ZIPPING:</b>\\n\\n<code>{d_name}</code>\\n\"\n",
        "\n",
        "    try:\n",
        "        msg = await bot.edit_message_text(\n",
        "            chat_id=chat_id,\n",
        "            message_id=msg.id,\n",
        "            text=down_msg,\n",
        "        )\n",
        "    except Exception as e2:\n",
        "        print(f\"Problem in ZipLeech !{e2}\")\n",
        "\n",
        "    print(\"\\nNow Zipping the folder...\")\n",
        "    current_time[0] = time.time()\n",
        "    start_time = datetime.datetime.now()\n",
        "\n",
        "    z_file_path = await zip_folder(d_fol_path)\n",
        "    clear_output()\n",
        "\n",
        "    total_down_size = os.stat(z_file_path).st_size\n",
        "\n",
        "    if total_down_size > 2000 * 1024**2:\n",
        "        leech_count = (total_down_size // (2000 * 1024**2)) + 1\n",
        "    else:\n",
        "        leech_count = 1\n",
        "\n",
        "    dump_text = (\n",
        "        f\"<b>📛 Name:</b>  <code>{d_name}</code>\\n\\n<b>📦 Size:</b> <code>{size_measure(total_down_size)}</code>\"\n",
        "        + f\"\\n\\n<b>📂 Total Files:</b>  <code>{leech_count}</code>\\n\"\n",
        "    )\n",
        "\n",
        "    sent = await bot.send_photo(\n",
        "        chat_id=dump_id,\n",
        "        photo=thumb_path,\n",
        "        caption=dump_text,\n",
        "        reply_markup=InlineKeyboardMarkup(\n",
        "            [\n",
        "                [  # First row\n",
        "                    InlineKeyboardButton(\"Source URL 🔗\", url=link)  # Opens a web URL\n",
        "                ]\n",
        "            ]\n",
        "        ),\n",
        "    )\n",
        "\n",
        "    shutil.rmtree(d_fol_path)\n",
        "\n",
        "    await Leecher(z_file_path)\n",
        "\n",
        "\n",
        "async def UnzipLeech(d_fol_path):\n",
        "    global msg\n",
        "\n",
        "    down_msg = f\"\\n<b>📂 UNZIPPING:</b>\\n\\n<code>{d_name}</code>\\n\"\n",
        "\n",
        "    msg = await bot.edit_message_text(\n",
        "        chat_id=chat_id,\n",
        "        message_id=msg.id,\n",
        "        text=down_msg,\n",
        "    )\n",
        "\n",
        "    for dirpath, dirnames, filenames in os.walk(d_fol_path):\n",
        "        for f in natsorted(filenames):\n",
        "            short_path = os.path.join(dirpath, f)\n",
        "            name, extension = os.path.splitext(short_path)\n",
        "\n",
        "            if extension == \".zip\":\n",
        "                await extract_zip(short_path)\n",
        "                clear_output()\n",
        "                shutil.rmtree(d_fol_path)\n",
        "                await Leech(temp_unzip_path)\n",
        "\n",
        "            else:\n",
        "                clear_output()\n",
        "                print(f\"Unable to extract a {extension} file. Starting Leeching !\")\n",
        "                await Leecher(short_path)\n",
        "\n",
        "\n",
        "async def FinalStep():\n",
        "    final_text = f\"<b>📂 Total Files:</b>  <code>{len(sent_file)}</code>\\n\\n<b>📜 LOG:</b>\\n\"\n",
        "\n",
        "    for i in range(len(sent_file)):\n",
        "        file_link = f\"https://t.me/c/{link_p}/{sent_file[i].id}\"\n",
        "        fileName = sent_fileName[i]\n",
        "        fileText = f\"\\n{i+1}. <a href={file_link}>{fileName}</a>\"\n",
        "        final_text += fileText\n",
        "\n",
        "    last_text = (\n",
        "        f\"<b>LEECH COMPLETE 🔥</b>\\n\\n\"\n",
        "        + f\"<i>📛 Name:</i>  <code>{d_name}</code>\\n\\n\"\n",
        "        + f\"<i>📦 Size: </i><code>{size_measure(total_down_size)}</code>\\n\\n\"\n",
        "    )\n",
        "    await bot.edit_message_text(\n",
        "        chat_id=chat_id,\n",
        "        message_id=msg.id,\n",
        "        text=last_text,\n",
        "        reply_markup=InlineKeyboardMarkup(\n",
        "            [\n",
        "                [  # First row\n",
        "                    InlineKeyboardButton(\n",
        "                        \"Source URL 🔗\", url=links[0]\n",
        "                    ),  # Opens a web URL\n",
        "                    InlineKeyboardButton(  # Opens a web URL\n",
        "                        \"BOT REPO 🔥\",\n",
        "                        url=\"https://github.com/XronTrix10/Telegram-Leecher\",\n",
        "                    ),\n",
        "                ]\n",
        "            ]\n",
        "        ),\n",
        "    )\n",
        "    await bot.send_message(chat_id=chat_id, reply_to_message_id=msg.id, text=final_text)\n",
        "\n",
        "\n",
        "# ****************************************************************\n",
        "#    Main Functions, function calls and variable declarations\n",
        "# ****************************************************************\n",
        "\n",
        "\n",
        "link_p = str(dump_id)[4:]\n",
        "thumb_path = \"/content/thmb.jpg\"\n",
        "d_path = \"/content/Downloads\"\n",
        "d_name = \"\"\n",
        "d_fol_path = d_path  # Initial Declaration\n",
        "temp_lpath = f\"{d_path}/Leeched_Files\"\n",
        "temp_unzip_path = f\"{d_path}/Unzipped_Files\"\n",
        "sent_file = []\n",
        "sent_fileName = []\n",
        "down_bytes = []\n",
        "down_bytes.append(0)\n",
        "up_bytes = []\n",
        "up_bytes.append(0)\n",
        "current_time = []\n",
        "current_time.append(time.time())\n",
        "folder_info = []\n",
        "folder_info.extend([0, 1])\n",
        "down_count = []\n",
        "down_count.append(1)\n",
        "start_time = datetime.datetime.now()\n",
        "text_msg = \"\"\n",
        "service = build_service()\n",
        "\n",
        "if not os.path.exists(thumb_path):\n",
        "    thumb_path = \"/content/Telegram-Leecher/custom_thmb.jpg\"\n",
        "    print(\"Didn't find thumbnail, So switching to default thumbnail\")\n",
        "if not ospath.exists(d_path):\n",
        "    makedirs(d_path)\n",
        "\n",
        "\n",
        "async with Client(\n",
        "    \"my_bot\", api_id=api_id, api_hash=api_hash, bot_token=bot_token\n",
        ") as bot:\n",
        "    while True:\n",
        "        choice = input(\n",
        "            \"Choose the Operation: \\n\\t(1) Leech\\n\\t(2) Zipleech\\n\\t(3) Unzipleech\\n\\nEnter: \"\n",
        "        )\n",
        "        if choice in [\"1\", \"2\", \"3\"]:\n",
        "            clear_output()\n",
        "            break\n",
        "        else:\n",
        "            clear_output()\n",
        "            print(\"Don't you understand ENGLISH ? Enter the option NUMBER !\\n\")\n",
        "\n",
        "    down_msg = f\"<b>📥 DOWNLOADING: </b>\\n\"\n",
        "\n",
        "    try:\n",
        "        links = []\n",
        "\n",
        "        link = \"something\"\n",
        "\n",
        "        while link != \"c\":\n",
        "            link = input(f\"Download link (GDrive / Direct) [ Enter c to Terminate]: \")\n",
        "            if link != \"c\":\n",
        "                links.append(link)\n",
        "\n",
        "        d_name = input(\"Enter the name of the File/Folder: \")\n",
        "        # enter the link for the file or folder that you want to download\n",
        "\n",
        "        d_fol_path = f\"{d_path}/{d_name}\"\n",
        "\n",
        "        if not ospath.exists(d_fol_path):\n",
        "            makedirs(d_fol_path)\n",
        "            \n",
        "        msg = await bot.send_photo(\n",
        "            chat_id=chat_id,\n",
        "            photo=thumb_path,\n",
        "            caption=down_msg + f\"\\n📝 __Calculating DOWNLOAD SIZE...__\",\n",
        "            reply_markup=InlineKeyboardMarkup(\n",
        "                [\n",
        "                    [  # First row\n",
        "                        InlineKeyboardButton(  # Opens a web URL\n",
        "                            \"Source URL 🔗\", url=links[0]\n",
        "                        ),\n",
        "                        InlineKeyboardButton(  # Opens a web URL\n",
        "                            \"Bot REPO 🔥\",\n",
        "                            url=\"https://github.com/XronTrix10/Telegram-Leecher\",\n",
        "                        ),\n",
        "                    ]\n",
        "                ]\n",
        "            ),\n",
        "        )\n",
        "\n",
        "        sent = msg\n",
        "\n",
        "        for link in links:\n",
        "            if \"drive.google.com\" in link:\n",
        "                await g_DownLoad(link)\n",
        "            else:\n",
        "                aria2_dn = f\"<b>PLEASE WAIT ⌛</b>\\n\\n__Getting Download Info For__\\n\\n<code>{link}</code>\"\n",
        "                try:\n",
        "                    await bot.edit_message_text(\n",
        "                        chat_id=chat_id,\n",
        "                        message_id=msg.id,\n",
        "                        text=aria2_dn,\n",
        "                        reply_markup=InlineKeyboardMarkup(\n",
        "                            [\n",
        "                                [  # First row\n",
        "                                    InlineKeyboardButton(  # Opens a web URL\n",
        "                                        \"Bot Repo 🦀\",\n",
        "                                        url=\"https://github.com/XronTrix10/Telegram-Leecher\",\n",
        "                                    )\n",
        "                                ]\n",
        "                            ]\n",
        "                        ),\n",
        "                    )\n",
        "                except Exception as e1:\n",
        "                    print(f\"Couldn't Update text ! Because: {e1}\")\n",
        "\n",
        "                await aria2_Download(link)\n",
        "\n",
        "        total_down_size = get_folder_size(d_fol_path)\n",
        "\n",
        "        clear_output()\n",
        "\n",
        "        if choice == \"1\":\n",
        "            await Leech(d_fol_path)\n",
        "\n",
        "        elif choice == \"2\":\n",
        "            await ZipLeech(d_fol_path)\n",
        "\n",
        "        elif choice == \"3\":\n",
        "            await UnzipLeech(d_fol_path)\n",
        "\n",
        "        await FinalStep()\n",
        "\n",
        "    except Exception as e:\n",
        "        if \"Failed to retrieve\" in str(e):\n",
        "            clear_output()\n",
        "            print(\"Authorization Error with token.pickle ! Maybe file not present !\")\n",
        "\n",
        "        else:\n",
        "            Error_Text = f\"<b>TASK FAILED 💔</b>\\n\\n<b>REASEON:</b>\\n\\n__{e}__\"\n",
        "\n",
        "            print(f\"Error Occured: {e}\")\n",
        "            await bot.edit_message_text(\n",
        "                chat_id=chat_id,\n",
        "                message_id=msg.id,\n",
        "                text=Error_Text,\n",
        "                reply_markup=InlineKeyboardMarkup(\n",
        "                    [\n",
        "                        [  # First row\n",
        "                            InlineKeyboardButton(  # Opens a web URL\n",
        "                                \"Report Issue 🥺\",\n",
        "                                url=\"https://github.com/XronTrix10/Telegram-Leecher/issues\",\n",
        "                            )\n",
        "                        ]\n",
        "                    ]\n",
        "                ),\n",
        "            )\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4ZH0Mx6h2L_9"
      },
      "source": [
        "## Run This cell simultaneously while the upper cell is running to avoid runtime disconnect"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "2F0NVZFA2V1U"
      },
      "outputs": [],
      "source": [
        "while True:pass"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "private_outputs": true,
      "provenance": []
    },
    "gpuClass": "standard",
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python",
      "version": "3.11.2"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}