Downloading Video From the Arlo (No Longer Works)

# python standard library
from pathlib import Path
import argparse
import datetime
import os
import re
import sys

# from pypi
import dateparser
import requests
from Arlo import Arlo
from dotenv import load_dotenv

class Configuration:
    """Loads the credentials and other info for the Arlo

    Args:
     config_path (str): path to the configuration for the arlo
     verbose (bool): emit more messages
    """
    def __init__(self, config_path="~/.config/arlo/config.arlo",
                 verbose=False):
        self.verbose = verbose
        self._config_path = None
        self.config_path = config_path
        self._username = None
        self._password = None
        self._front_camera = None
        self._back_camera = None
        self._kitchen_camra = None
        return

    @property
    def config_path(self):
        """the path to the configuration"""
        return self._config_path

class Paths:
    """Paths for the output

    Args:
     root (str): path to the folder
     verbose (bool): whether to emit more messages
    """
    def __init__(self, root=".", verbose=False):
        # warning: the 'root' setter uses self.verbose
        # so set it before setting self.root
        self.verbose = verbose
        self._root = None
        self.root = root
        return

    @property
    def root(self):
        """path to the folder"""
        return self._root

    @root.setter
    def root(self, path):
        """path to put the files in"""
        if self._root is None:
            self._root = Path(path)
            self._root.mkdir(parents=True, exist_ok=True)
            if self.verbose:
                print("Root Video Path: {}".format(self._root))
        return self._root

    def add_subfolder(self, sub):
        """adds the root to the sub

       creates the sub-folder if it doesn't exist

       Args:
        sub(str): subfolder name

       Returns:
        path: path object for the sub-directory
       """
        path = self.root.joinpath(sub)
        path.mkdir(parents=True, exist_ok=True)
        if self.verbose:
            print("subfolder: {}".format(path))
        return path

class Downloader:
    """Downloads the videos

    Args:
     camera (int): index of the camera to grab the files for
     start (str): date and time for the start of the videos
     end (str): date and time for the end of the videos
     path: object with the path for folders to store
     configuration: object with configuration information about the arlo
     output_timestamp(str): how to timestamp the files saved
     verbose (bool): emit more messages
    """
    date_format = "%Y%m%d"
    video_url = re.compile("^http.+(?P<camera>[A-Z0-9]{13})"
                           "_[0-9]{13}_"
                           "(?P<timestamp>[0-9]{13})")

    def __init__(self, camera, start, end, path,
                 configuration,
                 output_timestamp="%Y-%m-%d_%H_%M_%S",
                 verbose=False,
                 ):
        self.camera = camera
        self.start = start
        self.end = end
        self.path = path
        self.output_timestamp = output_timestamp
        self.verbose = verbose
        self.configuration = configuration
        self._start_time = None
        self._end_time = None
        self._start_date = None
        self._end_date = None
        self._arlo = None
        self._basestations = None
        self._cameras = None
        self._playlist = None
        return

    @property
    def start_time(self):
        """Starting time for the videos

       Returns:
        time (datetime.datetime): the starting time of videos to pull
       """
        if self._start_time is None:
            self._start_time = dateparser.parse(self.start)
            if self.verbose:
                print("Start Time: {}".format(self._start_time))
        return self._start_time

    @property
    def end_time(self):
        """ending time for the videos

       Returns:
        time (datetime.datetime): ending time of videos to pull
       """
        if self._end_time is None:
            self._end_time = dateparser.parse(self.end)
            if self.verbose:
                print("End Time: {}".format(self._end_time))
        return self._end_time

    @property
    def start_date(self):
        """The start date for the playlist

       Returns:
        start-date (`string`): starting date for the recordings
       """
        if self._start_date is None:
            self._start_date = self.start_time.strftime(self.date_format)
            if self.verbose:
                print("Start Date: {}".format(self._start_date))
        return self._start_date

    @property
    def end_date(self):
        """end-date for the playlist

       Returns:
        end-date (`str`): end-date for the recordings
       """
        if self._end_date is None:
            self._end_date = self.end_time.strftime(self.date_format)
            if self.verbose:
                print("End Date: {}".format(self._end_date))
        return self._end_date

    @property
    def arlo(self):
        """The Arlo object

       Instantiating the Arlo object automatically calls Login(), which
       returns an oAuth token that gets cached. Subsequent successful calls
       to login will update the oAuth token

       Returns:
        Arlo: thing to talk to the arlo
       """
        if self._arlo is None:
            self._arlo = Arlo(self.configuration.username,
                              self.configuration.password)
            if self.verbose:
                print("Arlo created")
        return self._arlo

    @property
    def basestations(self):
        """This next part was in the original code but not used

       I'm leaving it in on the chance that it might be needed for the
       side-effects

       Gets the list of devices and filter on device type to only get
       the basestation.
       This will return an array which includes all of the basestation's
       associated metadata.

       Returns:
        list: list of basestations
       """
        if self._basestations is None:
            self._basestations = self.arlo.GetDevices('basestation')
            if self.verbose:
                print("Base Stations retrieved")
        return self._basestations

    @property
    def cameras(self):
        """Get the camera.

       Returns:
         array: the camera's metadata
       """
        if self._cameras is None:
            self._cameras = self.arlo.GetDevices('camera')
            if self.verbose:
                print("Cameras retrieved")
        return self._cameras

    @property
    def playlist(self):
        """the recordings within our date-range

       Raises:
        SystemExit: no playlist for the dates was found
       """
        if self._playlist is None:
            if self.verbose:
                print("Getting Playlist")
            self._playlist = self.arlo.GetCvrPlaylist(
                self.cameras[self.camera],
                self.start_date,
                self.end_date)
            self._playlist = self._playlist["playlist"]
            if not self._playlist:
                sys.exit(
                    ("No playlist found for camera"
                     " {} from {} through {}").format(
                         self.camera,
                         self.start_date,
                         self.end_date,
                     ))
        return self._playlist