Bug patches and features

Changes being made:
* Patch a handful of existing bugs present in the previous version of the script
* Prevent the script from generating strm files for deleted items - deleted items will now be ignored.
* Introduce a flag to be able to see realtime updates being pushed to the console (and being able to turn this off)
* Introduce a flag to customise the title of the root directory being created by the script.
* Update readme with the changes being made.
* Additional minor changes to the readme to explain stuff in a more simple manner.

Author: notsatan

.gitignore

@@ -1,5 +1,6 @@
 # The virtual environment.
 .venv/
+venv/
 
 # Cache files stored by VS Code.
 .vscode/

readme.md

@@ -35,25 +35,33 @@
 <!-- TABLE OF CONTENTS -->
 
 ## Table of Contents
-- [Table of Contents](#table-of-contents)
 - [About The Project](#about-the-project)
   - [What is a strm file?](#what-is-a-strm-file)
 - [Pre-Requisites](#pre-requisites)
 - [Setup](#setup)
+    - [What do the setup scripts do?](#what-do-the-setup-scripts-do)
 - [Usage](#usage)
   - [Generating strm files](#generating-strm-files)
-  - [Where are the strm files stored?](#where-are-the-strm-files-stored)
+  - [Where are the strm files placed?](#where-are-the-strm-files-placed)
 - [Custom Arguments](#custom-arguments)
-  - [Scanning a particular folder](#scanning-a-particular-folder)
-  - [Modifying the directory where strm files are generated](#modifying-the-directory-where-strm-files-are-generated)
+    - [Scanning Selective Folders](#scanning-selective-folders)
+    - [Custom Destination Directory](#custom-destination-directory)
+    - [Realtime Updates](#realtime-updates)
+    - [Custom Name for Root Directory](#custom-name-for-root-directory)
+- [Resources](#resources)
     - [Getting Folder ID's](#getting-folder-ids)
-    - [Example; Using Custom Arguments](#example-using-custom-arguments)
-  - [How is this script better than the existing add-on?](#how-is-this-script-better-than-the-existing-add-on)
-- [How does this script work](#how-does-this-script-work)
+    - [Destination Directory vs Root Directory](#destination-directory-vs-root-directory)
+- [Examples](#examples)
+    - [Custom destination](#custom-destination)
+    - [Scanning a folder selectively](#scanning-a-folder-selectively)
+    - [Custom root directory](#custom-root-directory)
+  - [Miscellaneous Examples](#miscellaneous-examples)
+- [Is this script better than the existing add-on?](#is-this-script-better-than-the-existing-add-on)
+  - [How does this script work](#how-does-this-script-work)
 - [Advanced Setup](#advanced-setup)
 - [Roadmap](#roadmap)
     - [A list of *possible* improvements;](#a-list-of-possible-improvements)
-- [Contributing](#contributing)
+- [Contributions](#contributions)
 - [License](#license)
 - [Acknowledgements](#acknowledgements)
   - [Just some fun](#just-some-fun)
@@ -65,13 +73,13 @@
 
 A simple python script to complement the functionality of [Google Drive AddOn](https://kodi.tv/addon/music-add-ons-picture-add-ons-plugins-video-add-ons/google-drive) for Kodi.
 
-For an add-on that [claims to be "*extremely fast*"](https://github.com/cguZZman/plugin.googledrive), I found the add-on to be quite slow (*and unreliable*). It crashes way too frequently, is slow, and gets stuck way too often (this happened frequently enough, to the point I decided to make this project just to solve this problem).
+For an add-on that [claims to be "*extremely fast*"](https://github.com/cguZZman/plugin.googledrive#google-drive-kodi-addon), I found the add-on to be quite slow (*and unreliable*). It crashes way too frequently, is slow, and gets stuck way too often (this happened frequently enough, to the point I decided to make this project just to solve this problem).
 
 The main purpose of this project is to generate strm files for media file(s) present in a directory on Google Drive - and achieve this more reliably than the Kodi AddOn.
 
 ### What is a strm file?
 
-In simple terms, *strm* files refer to files having an extension of `.strm`. They usually created and used by multimedia applications (Kodi and Plex being the main examples). They are used to store URL(s).
+In simple terms, *strm* files refer to files having an extension of `.strm`. They usually created and used by multimedia applications (Kodi and Plex being the main examples). They are used to store URL pointing to the actual media file(s) stored on in a remote server/cloud.
 
 This URL is then used by the application to stream the actual media file when required.
 
@@ -84,30 +92,31 @@ This URL is then used by the application to stream the actual media file when re
 ## Setup
 1. Create a [Google Project](http://console.developers.google.com/) and [enable Google Drive API](https://developers.google.com/drive/api/v3/enable-drive-api).
 2. Once you enable the Drive API for your project, setup credentials required to use this API.
-3. Download the credentials as a JSON file and rename the file as `credentials.json`.
-4. Move the `credentials,json` file into the same directory containing the python script.
+3. Download the credentials as a JSON file and rename this file as `credentials.json`.
+4. Move the `credentials.json` file into the same directory containing the python script.
 5. Install the python dependencies.
     <br> `pip install -r requirements.txt`
 6. Install [Kodi AddOn for Google Drive](https://kodi.tv/addon/music-add-ons-picture-add-ons-plugins-video-add-ons/google-drive) in your Kodi installation.
 7. Login to the add-on. Make sure that you use the same Google account while logging into this script and the Google add-on.
 
 Alternatively, for the fourth step, you can directly use the `setup.sh` or `setup.bat` scripts and have them create an efficient setup for you.
 
-> #### What do the setup scripts do?
->
-> The setup script will;
-> * Update `pip`
-> * Install `virtualenv`
-> * Create a virtual environment named `.venv`
-> * Install required packages into this virtual environment.
+#### What do the setup scripts do?
 
-While anyone is free to use the direct setup files, do note that they are primarily for my use (to quickly setup a system for usage/testing/debugging) - and are not guaranteed to work in your system.
+The setup script will;
+ * Update `pip`
+ * Install `virtualenv`
+ * Create a virtual environment named `.venv`
+ * Activate this virtual package
+ * Install required python packages into this virtual environment.
+
+While anyone is free to use the direct setup files, do note that they are primarily for my use (to quickly setup a system for usage/testing/debugging) - and are *not guaranteed* to work in your system.
 
 ## Usage
 
 Executing the python script directly (without custom arguments) will fetch a list of all teamdrives to which the account has access -- allowing you to select a teamdrive from this list which will then be scanned for media files.
 
-Alternatively, you can pass [custom arguments](#custom-arguments) to the script to scan a particular folder, or to modify the directory where the strm files are stored after being generated.
+Alternatively, you can pass [custom arguments](#custom-arguments) to the script to modify the default behaviour.
 
 Once the script finishes generating strm files after a scan, add the resulting [directory as a source](https://kodi.wiki/view/Adding_video_sources) in your Kodi installation. From there on, Kodi will treat these `.strm` files as actual media files and will be able to scan/play them normally.
 
@@ -121,66 +130,170 @@ Once you're comfortable with the usage of this script, you might want to take a
 
 Running the python script without any custom arguments will fetch a list of all team-drives that are connected to the account, selecting a teamdrive from this list will make the script scan the contents of the particular teamdrive.
 
-### Where are the strm files stored?
+### Where are the strm files placed?
 
 By default, the strm files generated after a scan are stored in the **working directory**. Use `pwd` in Unix-based systems, or `cd` in Windows get the location of current working directory. 
 
-Look for a directory with the **same name as the source** (the Google folder/teamdrive) scanned.
+By deafult, the strm files are placed inside a directory with the **same name as the source** (the Google folder/teamdrive) scanned.
+
+Note: Take a look at the flags for [custom destination directory](#custom-destination-directory) and [custom root directory](#custom-name-for-root-directory) to modify the directory inside which strm files are being generated.
 
 ## Custom Arguments
 
-Using custom arguments, you can control the folder that is being scanned, and/or modify the directory in which the strm files are being placed after a scan.
+Using custom arguments, you can control the folder that is being scanned, modify the directory in which the strm files are being placed after a scan, modify the name of the root directory being used, choose if you want the script to run in silent mode or not and more.
+
+Note: These flags can be passed only if the script is being executed from the terminal. 
+
+#### Scanning Selective Folders
+
+**Flag:** `--source=<folder-id>`  
+**Value Expected:** ID of an existing folder on Google Drive.
+
+By default, the script will prompt you to select a teamdrive as the source - the selected teamdrive will be completely scanned by the script. This might not always be desired. 
+
+This flag allows you to scan the contents of any particular directory as needed, i.e. with the help of this flag instead of scanning a complete teamdrive (or the main drive), an individual folder can be selectively scanned using its ID.
+
+> Note: Check [Getting the Folder ID](#getting-folder-ids) section to get the ID of a folder in Google Drive.
+
+Side Note: Drive API treats teamdrives as folders, meaning that this flag can also be used to scan a teamdrive with it's ID.
+
+[>> Using this Flag; Example](#scanning-a-folder-selectively)
+
+#### Custom Destination Directory
+
+**Flag:** `--dest="</path/to/destination>"`  
+**Expected Value:** Path to an ***existing*** directory.
 
-This enables scanning a particular folder in a teamdrive instead of scanning the entire teamdrive, or to scan the contents of the *My Drive* section.
+This flag is used to decide the destination directory in which the root directory (containing the strm files) will be placed.
 
-Note: These flags can only be passed if you execute the script from the terminal. 
+[>> Resource: Destination Directory vs Root Directory](#destination-directory-vs-root-directory)
 
-### Scanning a particular folder
+Make sure that path supplied as a value with this flag belongs to an **existing directory**. If the path contains spaces, wrap it inside double quotes.
 
-Add `--source=<folder-id>` flag while executing the python script to force it to scan a particular directory. [Example](#example-using-custom-arguments)
+[>> Using this Flag; Example](#custom-destination)
 
-> Note: Check [Getting the Folder ID](#getting-folder-ids) section to get the folder id for a particular folder in Google Drive.
+#### Realtime Updates
 
+**Flag:** `--updates=<value>`  
+**Expected Value:** `on` OR `off`
 
-### Modifying the directory where strm files are generated
+This is an optional flag to see real-time progress as the script is scanning items from the source. The value of `off` implies no updates are to be printed to the console - effectively running the script silently.
 
-Add `--dest=<destination>` flag while executing the python script to store the generated strm files in a particular directory. Make sure that the destination points to an existing directory. 
+Having realtime updates might not always be desirable (especially if script is being run in the backgrond - me for one). Setting the value of this flag to `off` will run the script in silent mode - under silent mode, the only time this script will print to the console will be to notify that a scan has completed.
 
-Inside the destination directory, this script will make a directory with the same name as the source folder on Google Drive. If the destination contains a space, wrap it inside the double quotes before adding it as a flag.
+By default, the value of this flag is `on`, i.e. realtime progress will be displayed on the console.
+
+[>> Using this Flag; Example](#miscellaneous-examples)
+
+#### Custom Name for Root Directory
+
+**Flag:** `--rootname=<root-directory>`  
+**Expected Value:** Name for the root directory
+
+Optional flag to modify the name of root directory that is created by this script during runtime.
+
+[>> Resource: Destination Directory vs Root Directory](#destination-directory-vs-root-directory)
+
+Be default, the name of the teamdrive/folder being scanned  will be used as the name of the root directory.
+
+Important: If a directory with the same name as the root directory already exists inside destination directory, this script will ***erase the existing root directory***.
+
+[>> Using this Flag; Example](#custom-root-directory)
+
+## Resources
 
 #### Getting Folder ID's
 
 You can get the id for a particular folder by opening the folder and copying the id from the url.
 
 For example, in the URL `https://drive.google.com/drive/folders/0AOC6NXsE2KJMUk9PTA`, the folder-id is `0AOC6NXsE2KJMUk9PTA`.
 
-This method can also be used to get the ID of a particular TeamDrive and use it as a [custom argument](#scanning-a-particular-folder) to directly scan the teamdrive.
+This method can also be used to get the ID of a particular TeamDrive and use it as a [custom argument](#scanning-selective-folders) to directly scan the teamdrive.
+
+
+#### Destination Directory vs Root Directory
+
+In basic terms, when the script scans a folder on drive, it creates a directory which will contain all the strm files being generated. 
 
-#### Example; Using Custom Arguments
- 
-Running the following command will scan the folder `0AOC6NXsE2KJMUk9PVA` and generate strm files inside the directory `/home/kodi libraries` instead of resorting to the defaults.
+This directory that has been created by the script, during the runtime is the ***Root Directory***. The parent directory that contains the root directory is termed as the ***Destination Directory***.
 
-`python strm-generator.py --source=0AOC6NXsE2KJMUk9PVA --dest="/home/kodi libraries"`
+The path being used as the parent/destination directory should point to an already existing directory. On the other hand, if a directory with the same name as root directory is already present inside the destination, it will be wiped off.
+
+As an example, take a look at this directory structure;
+
+``` bash
+│── E:
+│   ├── Kodi Library
+│   │   ├── Downloaded Media
+│   │   │    ├── new-file.mp4.strm
+│   │   │    ├── old-file-02.mp4.strm
+│   │   ├── Collection
+│   │   │    ├── movie-file.mkv.strm
+│   ├── STRM Files
+│   │   ├── Content Media
+│   │   │    ├── movie-01.mkv.strm
+│   │   │    ├── movie-02.mp4.strm
+│   │   │    ├── trailer.mkv.strm
+```
+
+From above, strm files are present inside three directories, namely, `Downloaded Media`, `Collection` and `Content Media` - these are the *Root Directories*. The directories containing these root directories then become the `Destination Directory`. Meaning that, there are two destination directories, `Kodi Library` and `STRM Files`.
+
+
+## Examples
+
+#### Custom destination
+Running the following command will generate the root directory (containing strm files) at the destination `/home/kodi library`. Make sure that this is a valid path and points to a directory.
+
+`python strm-generator.py --dest="/home/kodi library"`
+
+Note that since the path contains space, it has been wrapped in double spaces.
+
+#### Scanning a folder selectively
+
+Running the following command will scan a folder with the ID `0AOC6NXsE2KJMUk9PVA` on Google Drive. Make sure that the account you signed into the script with has access to this folder.
+
+`python strm-generator.py --source=0AOC6NXsE2KJMUk9PVA --dest="/home/kodi library"`
+
+Note the additional destination flag in the command, instead of placing the results in the working directory, the script will now place them inside `/home/kodi library`.
+
+#### Custom root directory
+
+Running the following command will generate strm files inside a directory named `new root directory`
+
+`python strm-generator.py --source=0AOC6NXsE2KJMUk9PVA --dest="/home/kodi library" --rootname="new root directory"`
+
+The strm files will be present in a directory named `new root directory` (this is the root directory). The root directory by itself will be present inside `"/home/kodi library"` (this being the destination directory).
+
+### Miscellaneous Examples
+
+* Scanning a particular folder on drive, with custom destination and root directories, plus no updates to the console (using all the flags at once).
+> `python strm-generator.py --source=0AOC6NXsE2KJMUk9PVA --dest="/home/kodi libraries" --rootname="Staging; Media" --updates=off`
+
+* Scanning a particular folder with no updates
+> `python strm-generator.py --source=0AOC6NXsE2KJMUk9PVA --updates=off`
+
+* Scanning a folder selectively with custom root directory
+> `python strm-generator.py --source=0AOC6NXsE2KJMUk9PVA --rootname="Media"`
+
+* Scanning a folder with custom destination directory and no updates on console
+> `python strm-generator.py --source=0AOC6NXsE2KJMUk9PVA --dest="/home/Videos" --updates=off`
 
-If you're unsure about using custom arguments, feel free to just replace the values in the command above with **valid** values, and you're good to go!
 
 ---
 
-### How is this script better than the existing add-on?
+## Is this script better than the existing add-on?
 
-Based on the tests I have run upto now, this script didn't crash or lag, and was quite a bit faster than the add-on. Honestly, I'm not sure about why this happens. While the add-on is [open source](https://github.com/cguZZman/plugin.googledrive), I'm yet to take a look at the source code and determine why.
+Based on the tests I have run, this script didn't crash or lag, and was quite a bit faster than the add-on. Honestly, I'm not sure why this happens - while the Google Drive add-on is [open source](https://github.com/cguZZman/plugin.googledrive), I'm yet to take a proper look at it.
 
 What I do know is, this script is as simple as it can be. There is no clever hack, or any trick present. Yet, all the tests I ran prove that this script is somehow better than the add-on (and no, this is **definitely not** because of any hardware limitation at my end).
 
 It is possible that this difference is being caused by Kodi (or the integration between the add-on and Kodi). Regardless, I noticed a flaw, and wrote a simple script to overcome it effectively.
 
-## How does this script work
+### How does this script work
 
 The basic functioning of this script revolves around traversing a directory on Google Drive, iterating through each file present in this directory and generating an equivalent `.strm` file for every media file. An important part of this is to be able to recognize media files.
 
-The most important step while creating a strm file is to ensure that the contents of the file are stored in such a manner that they can be parsed by the Google Drive add-on.
-
-The last step above ensures that this script does not need to handle the part of using these strm files to stream the video. Once this script generates the strm files, everything else is being handled by the Kodi add-on, this includes parsing the strm file to get the actual URL, streaming contents from the URL and everything else.
+The most important step while creating a strm file is to ensure that the contents of the file are stored in such a manner that they can be parsed by the Google Drive add-on. This ensures that this script does not need to handle the part of using these strm files to stream the video. Once an strm file has been generated, everything else is being handled by the Kodi add-on, this includes parsing the strm file to get the actual URL and streaming media from the URL.
 
 ## Advanced Setup
 
@@ -194,9 +307,7 @@ Whenever I open up Kodi, it automatically scrapes the new files, and adds them t
 
 If needed, the systemd service can be modified to run the script multiple times, scanning different sources each time to be able to scale my current setup to span across multiple teamdrives/folders, all this without requiring any sort of input.
 
-Windows users can achieve the same functionality as systemd.service using [Windows Task Scheduler](https://en.wikipedia.org/wiki/Windows_Task_Scheduler).
-
-In case someone wants to replicate a similar setup as mine, here are some useful links to help you get started.
+Windows users can achieve the same functionality as systemd.service using [Windows Task Scheduler](https://en.wikipedia.org/wiki/Windows_Task_Scheduler). In case someone wants to replicate a similar setup as mine, here are some useful links to help you get started.
 
 - [Creating a systemd.service](https://medium.com/@benmorel/creating-a-linux-service-with-systemd-611b5c8b91d6)
 - [Using Windows Task Scheduler](https://windowsreport.com/schedule-tasks-windows-10)
@@ -213,10 +324,11 @@ Based on the tests I've run, this script is ~20% faster than the Google Drive Ad
 > *For the curious, yes, I ran the test on the exact same source without any modifications. The results are as accurate as possible.*
 
 #### A list of *possible* improvements;
-- Improvement(s) on the GUI - updating progress on the terminal while the script is running.
-- Multithreading (still not sure on this one) - despite GIL, the execution speed can be improved to some extent.
+- Improvement(s) on the GUI - ~~updating progress on the terminal while the script is running~~ added in [e451e08
+](https://github.com/demon-rem/kodi-strm/commit/e451e087adcc3bc116f1718e0bc5a9100b81555a).
+- Multithreading (still not sure on this one) - despite GIL, the execution speed can be improved to *some* extent.
 
-## Contributing
+## Contributions
 
 Contributions are what make the open source community such an amazing place to learn, inspire, and create. Any contributions made are **extremely appreciated**.
 
@@ -230,9 +342,10 @@ Contributions are what make the open source community such an amazing place to l
 Distributed under the MIT License. See [`LICENSE`](./LICENSE). for more information.
 
 ## Acknowledgements
-* [Img Shields](https://shields.io)
-* [Google API Python Client](https://github.com/googleapis/google-api-python-client)
-* [Coloroma](https://github.com/tartley/colorama)
+* [Img Shields](https://shields.io): for the badges being used in this readme.
+* [Google API Python Client](https://github.com/googleapis/google-api-python-client): a python wrapper to work with Drive API.
+* [Coloroma](https://github.com/tartley/colorama): Used to print the names of teamdrives in separate colors while selecting a source in interactive mode.
+* [Reprint](https://github.com/Yinzo/reprint): Used to provide updates on the console.
 * Special credits to [Satan](https://github.com/not-satan) for being annoying enough to force me to work on this repo as a priority.
 
 <br>
@@ -246,4 +359,4 @@ Distributed under the MIT License. See [`LICENSE`](./LICENSE). for more informat
 [license]: https://img.shields.io/github/license/demon-rem/kodi-strm?style=for-the-badge
 [latest-release]: https://img.shields.io/github/v/release/demon-rem/kodi-strm?style=for-the-badge
 [release-date]: https://img.shields.io/github/release-date/demon-rem/kodi-strm?style=for-the-badge
-[issues-url]: https://img.shields.io/github/issues-raw/demon-rem/kodi-strm?style=for-the-badge
+[issues-url]: https://img.shields.io/github/issues-raw/demon-rem/kodi-strm?style=for-the-badge

requirements.txt

@@ -1,5 +1,6 @@
 astroid==2.4.2
 autopep8==1.5.4
+backports.shutil-get-terminal-size==1.0.0
 cachetools==4.1.1
 certifi==2020.6.20
 chardet==3.0.4
@@ -22,6 +23,7 @@ pyasn1-modules==0.2.8
 pycodestyle==2.6.0
 pylint==2.6.0
 pytz==2020.1
+reprint==0.5.2
 requests==2.24.0
 requests-oauthlib==1.3.0
 rsa==4.6

setup.bat

@@ -1,21 +1,23 @@
-Upgrading pip
+@echo off
+
+echo Upgrading pip
 python -m pip install --upgrade pip
 
-Installing virtual-environment
+echo Installing virtual-environment
 pip install --upgrade virtualenv
 
-Creating a virutal environment
+echo Creating a virutal environment
 virtualenv .venv
 
 REM Activating the virtual environment.
 .venv\Scripts\activate
 
-Installing the required packages
+echo Installing the required packages
 pip install -r requirements.txt
 
-Setup executed successfully.
-
-Activate the virtual-environment using 
-    `.venv\Scripts\activate`
+echo Setup executed successfully.
 
-Once done, follow the rest of instructions in the setup.
+echo Activate the virtual-environment using 
+echo    `.venv\Scripts\activate`
+echo(
+echo Once done, follow the rest of instructions in the setup.

strm-generator.py

@@ -2,11 +2,11 @@
 
 import sys
 from os import getcwd, mkdir, system
-from shutil import rmtree
-from os.path import exists, isdir, join
+from os.path import basename, dirname, exists, isdir, join
 from pickle import dump as dump_pickle
 from pickle import load as load_pickle
 from re import match, sub
+from shutil import rmtree
 from time import sleep
 from typing import Dict, List, Optional
 
@@ -15,9 +15,12 @@
 from google.oauth2.credentials import Credentials
 from google_auth_oauthlib.flow import InstalledAppFlow
 from googleapiclient.discovery import Resource, build
+from reprint import output
 
-files = 0
-directories = 0
+files_scanned = 0
+directories_scanned = 0
+files_skipped = 0
+bytes_scanned = 0
 
 
 def authenticate() -> Resource:
@@ -60,6 +63,42 @@ def authenticate() -> Resource:
     return service
 
 
+def update(files: int, directories: int, skipped: int, size: int, out_stream):
+    """
+        Prints updates to the screen.
+
+        Parameters
+        -----------
+        files: Integer containing the number of files that have been scanned. \n
+        directories: Integer containing number of directories that have been scanned. \n
+        skipped: Integer containing the number of files that have been skipped. \n
+        size: Integer containing the raw size of files scanned (in bytes). \n
+        out_stream: A dictionary object to which new lines are to be written as needed. \n
+    """
+
+    # The value of `size` will be an integer containing the raw size of the file(s) traversed
+    # in bytes. Starting by converting this into a readable format.
+
+    # An array size units. Will be used to convert raw size into a readble format.
+    sizes = ['B', 'KiB', 'MiB', 'GiB', 'TiB', 'PiB', 'EiB']
+
+    counter = 0
+    while size >= 1024:
+        size /= 1024
+        counter += 1
+
+    # Forming a string containing readable size, this will be used to directly convert th e
+    readable_size = '{:.3f} {}'.format(
+        size,
+        sizes[counter]
+    )
+
+    out_stream[2] = f'Directories Scanned: {directories}'
+    out_stream[3] = f'Files Scanned: {files}'
+    out_stream[4] = f'Bytes Scanned: {readable_size}'
+    out_stream[5] = f'Files Skipped: {skipped}'
+
+
 def select_teamdrive(service: Resource) -> str:
     """
         Allows the user to select the teamdrive for which strm files are to be generated.
@@ -140,7 +179,32 @@ def select_teamdrive(service: Resource) -> str:
             print(f'\t{Fore.RED}Incorrect input detected. {Style.RESET_ALL}\n')
 
 
-def walk(origin_id: str, service: Resource, cur_path: str, item_details: Dict[str, str]):
+def shrink_path(full_path: str, max_len: int = 70) -> str:
+    """
+        Shrinks the path name to fit into a fixed number of characters.
+
+        Parameters
+        -----------
+        full_path: String containing the full path that is to be printed. \n
+        max_len: Integer containing the maximum length for the final path. Should be
+        more than 10 characters. Default: 15 \n
+
+        Returns
+        --------
+        String containing path after shrinking it. Will be atmost `max_len` characters
+        in length.
+    """
+
+    if len(full_path) <= max_len:
+        # Directly return the path if it fits within the maximum length allowed.
+        return full_path
+
+    allowed_len = max_len - 6
+    return f'{full_path[:int(allowed_len / 2)]}......{full_path[-int(allowed_len / 2):]}'
+
+
+def walk(origin_id: str, service: Resource, orig_path: str, item_details: Dict[str, str], out_stream,
+         push_updates: bool, drive_path='~'):
     """
         Traverses directories in Google Drive and replicates the file/folder structure similar to
         Google Drive.
@@ -156,57 +220,97 @@ def walk(origin_id: str, service: Resource, cur_path: str, item_details: Dict[st
         Every directory present inside this directory will be traversed, and a `.strm` file will be generated
         for every video file present inside this directory. \n
         service: Instance of `Resource` object used to interact with Google Drive API. \n
+        orig_path: Path to the directory in which strm files are to be placed once generated. This directory
+        will be made by THIS method internally. \n
+        item_details: Dictionary containing details of the directory being scanned from Google drive. \n
+        out_stream: Dictioanry object to which the output is to be written to once (if updates are needed). \n
+        push_updates: Boolean indicating if updates are to be pushed to the screen or not. \n
     """
 
-    global files, directories
+    global files_scanned, directories_scanned, bytes_scanned, files_skipped
 
     if not isinstance(origin_id, str) or not isinstance(service, Resource):
         raise TypeError('Unexpected argument type')
 
-    # print(item_details)
-    if item_details['mimeType'] != 'application/vnd.google-apps.folder':
-        raise TypeError('Expected the id for a directory')
-
     # Updating the current path to be inside the path where this directory is to be created.
-    cur_path = join(cur_path, item_details['name'])
+    cur_path = join(orig_path, item_details['name'])
 
-    # Creating the root directory for this search.
-    try:
-        mkdir(cur_path)
-    except:
-        pass
+    # Creating the root directory.
+    mkdir(cur_path)
 
     page_token = None
 
+    if push_updates:
+        out_stream[0] = f'Scanning Directory: {shrink_path(drive_path)}/'
+        out_stream[1] = '\n'  # Blank line
+
     while True:
         result = service.files().list(
+            # Getting the maximum number of items avaiable in a single API call
+            # to reduce the calls required.
             pageSize=1000,
             pageToken=page_token,
-            fields='files(name, id, mimeType, teamDriveId)',
+
+            # The fields that are to be included in the response.
+            fields='files(name, id, mimeType, teamDriveId, size)',
+
+            # Getting itesm from all drives, this allows scanning team-drives too.
             supportsAllDrives=True,
             includeItemsFromAllDrives=True,
-            q=f"'{origin_id}' in parents"
+
+            # Skipping trashed files and directories
+            q=f"'{origin_id}' in parents and trashed=false"
         ).execute()
 
-        # print(f'Found {len(result["files"])}')
         for item in result['files']:
             if item['mimeType'] == 'application/vnd.google-apps.folder':
-                # If the current object is a folder, recursively calling the same method.
-                directories += 1
-                walk(item['id'], service, cur_path, item)
+                # If the current object is a folder, incrementing the folder count and recursively
+                # calling the same method over the new directory encountered.
+                directories_scanned += 1
+
+                walk(
+                    origin_id=item['id'],
+                    service=service,
+                    orig_path=cur_path,
+                    item_details=item,
+                    out_stream=out_stream,
+                    push_updates=push_updates,
+                    drive_path=f'{join(drive_path, item["name"])}'
+                )
             elif 'video' in item['mimeType'] or match(r'.*\.(mkv|mp4)$', item['name']):
-                try:
-                    file_content = f'plugin://plugin.googledrive/?action=play&item_id={item["id"]}'
-                    if 'teamDriveId' in item:
-                        # Adding this part only for items present in a teamdrive.
-                        file_content += f'&item_driveid={item["teamDriveId"]}&teamDriveId={item["teamDriveId"]}'
-
-                    file_content += f'&content_type=video'
-                    with open(join(cur_path, item['name']+'.strm'), 'w+') as f:
-                        f.write(file_content)
-                    files += 1
-                except:
-                    pass
+                # Scanning the file, and creating an equivalent strm file if the file is a media file
+                # Since the mime-type of files in drive can be modified externally, scanning the file
+                # as a media file if the file has an extension of `.mp4` or `.mkv`.
+
+                # Forming the string that is to be placed inside the strm file to ensure that the file
+                # can be used by the drive add-on.
+                file_content = f'plugin://plugin.googledrive/?action=play&item_id={item["id"]}'
+                if 'teamDriveId' in item:
+                    # Adding this part only for items present in a teamdrive.
+                    file_content += f'&item_driveid={item["teamDriveId"]}&teamDriveId={item["teamDriveId"]}'
+
+                file_content += f'&content_type=video'
+                with open(join(cur_path, item['name']+'.strm'), 'w+') as f:
+                    f.write(file_content)
+
+                # Updating the counter for files scanned as well as bytes scanned.
+                files_scanned += 1
+                bytes_scanned += int(item['size'])
+            else:
+                # Skipping the file if the file is not a video file (i.e. mime type does not match), and the
+                # file does not have an extension of `.mp4` or `.mkv`. Updating the counter to increment the
+                # number of files that have been skipped from the scan.
+                files_skipped += 1
+
+            if push_updates:
+                # Updating counter on the screen if updates are to be pushed to the screen.
+                update(
+                    files=files_scanned,
+                    directories=directories_scanned,
+                    skipped=files_skipped,
+                    size=bytes_scanned,
+                    out_stream=out_stream
+                )
 
         if 'nextPageToken' not in result:
             break
@@ -218,11 +322,17 @@ def walk(origin_id: str, service: Resource, cur_path: str, item_details: Dict[st
 
     destination = getcwd()
     source = None
+    updates = True  # True by default.
+    dir_name = None  # The name of the directory to store the strm files in.
 
     # Pattern(s) that are to be used to match against the source argument. The group is important since
     # this pattern is also being used to extract the value from argument.
     pattern_source = r'^--source=(.*)'
-    patter_dest = r'^--dest="?(.*)"?'
+    pattern_output = r'^--updates="?(off|on)"?$'
+
+    # TODO: Might want to differentiate between platforms here. Especially for custom directories.
+    pattern_custom_dir = r'^--rootname="?(.*)"?$'
+    pattern_dest = r'^--dest="?(.*)"?$'
 
     # Looping over all arguments that are passed to the script. The first (zeroe-th) value shall be the
     # name of the python script.
@@ -239,15 +349,22 @@ def walk(origin_id: str, service: Resource, cur_path: str, item_details: Dict[st
 
             # Extracting id from the argument using substitution. Substituting everything from the
             # argument string except for the value :p
-            source = sub(pattern_source, r'\1', sys.argv[i])
-        elif match(patter_dest, sys.argv[i]):
+            source = match(pattern_source, sys.argv[i]).groups()[0]
+        elif match(pattern_dest, sys.argv[i]):
             # Again, extracting the value using regex substitution.
-            destination = sub(patter_dest, r'\1', sys.argv[i])
+            destination = match(pattern_dest, sys.argv[i]).groups()[0]
 
             if not isdir(destination):
                 print(f'Error: `{sys.argv[i]}` is not a directory.\n')
                 exit(10)  # Force quit.
-
+        elif match(pattern_output, sys.argv[i]):
+            # Switching the updates off if the argument has been passed.
+            # Since the default value is to allow updates, no change is required incase
+            # updates are explicitly being allowed.
+            if match(pattern_output, sys.argv[i]).groups()[0] == 'off':
+                updates = False
+        elif match(pattern_custom_dir, sys.argv[i]):
+            dir_name = match(pattern_custom_dir, sys.argv[i]).groups()[0]
         else:
             print(f'Unknown argument detected `{sys.argv[i]}`')
             exit(10)  # Non-zero exit code to indicate error.
@@ -265,17 +382,32 @@ def walk(origin_id: str, service: Resource, cur_path: str, item_details: Dict[st
     if 'teamDriveId' in item_details and item_details['id'] == item_details['teamDriveId']:
         # If the source is a teamdrive, attempting to fetch details for the teamdrive instead.
         item_details = service.drives().get(
-            teamDriveId=item_details['teamDriveId']
+            driveId=item_details['teamDriveId']
         ).execute()
 
+    if dir_name is not None:
+        # If the name of the root directory is not set, using the name of the teamdrive/drive.
+        item_details['name'] = dir_name
+
     # Clearing the destination directory (if it exists).
-    final_path=join(destination, item_details['name'])
+    final_path = join(destination, dir_name)
     if isdir(final_path):
         rmtree(final_path)
 
-    print(f'\n\tSaving the output at `{destination}`')
+    print()  # Empty print.
 
     # Calling the method to walk through the drive directory.
-    walk(source, service, destination, item_details)
-
-    print(f'Completed. Traversed through {directories} directories and {files} files.')
+    with output(output_type='list', initial_len=6, interval=0) as out_stream:
+        # Creating the output object here to ensure that the same object is being used
+        # for updates internally.
+
+        walk(
+            origin_id=source,
+            service=service,
+            orig_path=destination,
+            item_details=item_details,
+            out_stream=out_stream,
+            push_updates=updates
+        )
+
+    print(f'\n\tTask completed. Saved the output at `{final_path}`')