mirror of
https://github.com/SinTan1729/TvTimeToTrakt.git
synced 2024-12-25 21:08:37 -06:00
commit
f33b2bfb2e
2 changed files with 213 additions and 164 deletions
249
TimeToTrackt.py
249
TimeToTrackt.py
|
@ -1,37 +1,55 @@
|
|||
# main.py
|
||||
from logging import error
|
||||
import sys
|
||||
from trakt import *
|
||||
import trakt.core
|
||||
import os
|
||||
#!/usr/bin/env python3
|
||||
import csv
|
||||
from datetime import datetime
|
||||
import time
|
||||
from tinydb import TinyDB, Query
|
||||
import json
|
||||
import logging
|
||||
import os
|
||||
import re
|
||||
import sys
|
||||
import time
|
||||
from datetime import datetime
|
||||
from pathlib import Path
|
||||
|
||||
import trakt.core
|
||||
from tinydb import Query, TinyDB
|
||||
from trakt import init
|
||||
from trakt.tv import TVShow
|
||||
|
||||
# Setup logger
|
||||
logging.basicConfig(
|
||||
format="%(asctime)s [%(levelname)7s] :: %(message)s",
|
||||
level=logging.INFO,
|
||||
datefmt="%Y-%m-%d %H:%M:%S",
|
||||
)
|
||||
|
||||
# Adjust this value to increase/decrease your requests between episodes.
|
||||
# Make sure it's above 1 seconds to remain within the rate limit.
|
||||
DELAY_BETWEEN_EPISODES_IN_SECONDS = 5
|
||||
# Make to remain within the rate limit: https://trakt.docs.apiary.io/#introduction/rate-limiting
|
||||
DELAY_BETWEEN_EPISODES_IN_SECONDS = 0.75
|
||||
|
||||
# Create a database to keep track of completed processes
|
||||
database = TinyDB('localStorage.json')
|
||||
syncedEpisodesTable = database.table('SyncedEpisodes')
|
||||
userMatchedShowsTable = database.table('TvTimeTraktUserMatched')
|
||||
database = TinyDB("localStorage.json")
|
||||
syncedEpisodesTable = database.table("SyncedEpisodes")
|
||||
userMatchedShowsTable = database.table("TvTimeTraktUserMatched")
|
||||
|
||||
|
||||
class Expando(object):
|
||||
pass
|
||||
|
||||
|
||||
def isAuthenticated():
|
||||
with open(f"{Path.home()}/.pytrakt.json") as f:
|
||||
data = json.load(f)
|
||||
daysBeforeExpiration = (
|
||||
datetime.fromtimestamp(data["OAUTH_EXPIRES_AT"]) - datetime.now()
|
||||
).days
|
||||
if daysBeforeExpiration < 1:
|
||||
return False
|
||||
return True
|
||||
|
||||
|
||||
def getConfiguration():
|
||||
configEx = Expando()
|
||||
|
||||
with open('config.json') as f:
|
||||
with open("config.json") as f:
|
||||
data = json.load(f)
|
||||
|
||||
configEx.TRAKT_USERNAME = data["TRAKT_USERNAME"]
|
||||
|
@ -58,9 +76,17 @@ def getFollowedShowsPath():
|
|||
|
||||
|
||||
def initTraktAuth():
|
||||
if isAuthenticated():
|
||||
return True
|
||||
# Set the method of authentication
|
||||
trakt.core.AUTH_METHOD = trakt.core.OAUTH_AUTH
|
||||
return init(config.TRAKT_USERNAME, store=True, client_id=config.CLIENT_ID, client_secret=config.CLIENT_SECRET)
|
||||
return init(
|
||||
config.TRAKT_USERNAME,
|
||||
store=True,
|
||||
client_id=config.CLIENT_ID,
|
||||
client_secret=config.CLIENT_SECRET,
|
||||
)
|
||||
|
||||
|
||||
# With a given title, check if it contains a year (e.g Doctor Who (2005))
|
||||
# and then return this value, with the title and year removed to improve
|
||||
|
@ -75,18 +101,19 @@ def getYearFromTitle(title):
|
|||
yearSearch = re.search(r"\(([A-Za-z0-9_]+)\)", title)
|
||||
yearValue = yearSearch.group(1)
|
||||
# Then, get the title without the year value included
|
||||
titleValue = title.split('(')[0].strip()
|
||||
titleValue = title.split("(")[0].strip()
|
||||
# Put this together into an object
|
||||
ex.titleWithoutYear = titleValue
|
||||
ex.yearValue = int(yearValue)
|
||||
return ex
|
||||
except:
|
||||
except Exception:
|
||||
# If the above failed, then the title doesn't include a year
|
||||
# so return the object as is.
|
||||
ex.titleWithoutYear = title
|
||||
ex.yearValue = -1
|
||||
return ex
|
||||
|
||||
|
||||
# Shows in TV Time are often different to Trakt.TV - in order to improve results and automation,
|
||||
# calculate how many words are in the title, and return true if more than 50% of the title is a match,
|
||||
# It seems to improve automation, and reduce manual selection....
|
||||
|
@ -116,6 +143,7 @@ def checkTitleNameMatch(tvTimeTitle, traktTitle):
|
|||
# then return the title as a possibility to use
|
||||
return percentage > 50
|
||||
|
||||
|
||||
# Using TV Time data (Name of Show, Season No and Episode) - find the corresponding show
|
||||
# in Trakt.TV either by automation, or asking the user to confirm.
|
||||
|
||||
|
@ -145,7 +173,7 @@ def getShowByName(name, seasonNo, episodeNo):
|
|||
if checkTitleNameMatch(name, show.title):
|
||||
# If the title included the year of broadcast, then we can be more picky in the results
|
||||
# to look for a show with a broadcast year that matches
|
||||
if doesTitleIncludeYear == True:
|
||||
if doesTitleIncludeYear:
|
||||
# If the show title is a 1:1 match, with the same broadcast year, then bingo!
|
||||
if (name == show.title) and (show.year == titleObj.yearValue):
|
||||
# Clear previous results, and only use this one
|
||||
|
@ -168,7 +196,7 @@ def getShowByName(name, seasonNo, episodeNo):
|
|||
if nameFromSearch.title == name:
|
||||
completeMatchNames.append(nameFromSearch)
|
||||
|
||||
if (len(completeMatchNames) == 1):
|
||||
if len(completeMatchNames) == 1:
|
||||
showsWithSameName = completeMatchNames
|
||||
|
||||
# If the search contains multiple results, then we need to confirm with the user which show
|
||||
|
@ -178,8 +206,7 @@ def getShowByName(name, seasonNo, episodeNo):
|
|||
|
||||
# Query the local database for existing selection
|
||||
userMatchedQuery = Query()
|
||||
queryResult = userMatchedShowsTable.search(
|
||||
userMatchedQuery.ShowName == name)
|
||||
queryResult = userMatchedShowsTable.search(userMatchedQuery.ShowName == name)
|
||||
|
||||
# If the local database already contains an entry for a manual selection
|
||||
# then don't bother prompting the user to select it again!
|
||||
|
@ -187,12 +214,12 @@ def getShowByName(name, seasonNo, episodeNo):
|
|||
# Get the first result from the query
|
||||
firstMatch = queryResult[0]
|
||||
# Get the value contains the selection index
|
||||
firstMatchSelectedIndex = int(firstMatch.get('UserSelectedIndex'))
|
||||
firstMatchSelectedIndex = int(firstMatch.get("UserSelectedIndex"))
|
||||
# Check if the user previously requested to skip the show
|
||||
skipShow = firstMatch.get('SkipShow')
|
||||
skipShow = firstMatch.get("SkipShow")
|
||||
# If the user did not skip, but provided an index selection, get the
|
||||
# matching show
|
||||
if skipShow == False:
|
||||
if not skipShow:
|
||||
return showsWithSameName[firstMatchSelectedIndex]
|
||||
# Otherwise, return None, which will trigger the script to skip
|
||||
# and move onto the next show
|
||||
|
@ -202,22 +229,25 @@ def getShowByName(name, seasonNo, episodeNo):
|
|||
# then prompt the user to make a selection
|
||||
else:
|
||||
print(
|
||||
f"INFO - MANUAL INPUT REQUIRED: The TV Time data for Show '{name}' (Season {seasonNo}, Episode {episodeNo}) has {len(showsWithSameName)} matching Trakt shows with the same name.")
|
||||
f"INFO - MANUAL INPUT REQUIRED: The TV Time data for Show '{name}' (Season {seasonNo}, Episode {episodeNo}) has {len(showsWithSameName)} matching Trakt shows with the same name."
|
||||
)
|
||||
|
||||
# Output each show for manual selection
|
||||
for idx, item in enumerate(showsWithSameName):
|
||||
# Display the show's title, broadcast year, amount of seasons and a link to the Trakt page.
|
||||
# This will provide the user with enough information to make a selection.
|
||||
print(
|
||||
f" ({idx + 1}) {item.title} - {item.year} - {len(item.seasons)} Season(s) - More Info: https://trakt.tv/{item.ext}")
|
||||
f" ({idx + 1}) {item.title} - {item.year} - {len(item.seasons)} Season(s) - More Info: https://trakt.tv/{item.ext}"
|
||||
)
|
||||
|
||||
while(True):
|
||||
while True:
|
||||
try:
|
||||
# Get the user's selection, either a numerical input, or a string 'SKIP' value
|
||||
indexSelected = (input(
|
||||
f"Please make a selection from above (or enter SKIP):"))
|
||||
indexSelected = input(
|
||||
"Please make a selection from above (or enter SKIP):"
|
||||
)
|
||||
|
||||
if indexSelected != 'SKIP':
|
||||
if indexSelected != "SKIP":
|
||||
# Since the value isn't 'skip', check that the result is numerical
|
||||
indexSelected = int(indexSelected) - 1
|
||||
# Exit the selection loop
|
||||
|
@ -229,17 +259,19 @@ def getShowByName(name, seasonNo, episodeNo):
|
|||
except KeyboardInterrupt:
|
||||
sys.exit("Cancel requested...")
|
||||
# Otherwise, the user has entered an invalid value, warn the user to try again
|
||||
except:
|
||||
print(
|
||||
f"Sorry! Please select a value between 0 to {len(showsWithSameName)}")
|
||||
except Exception:
|
||||
logging.error(
|
||||
f"Sorry! Please select a value between 0 to {len(showsWithSameName)}"
|
||||
)
|
||||
|
||||
# If the user entered 'SKIP', then exit from the loop with no selection, which
|
||||
# will trigger the program to move onto the next episode
|
||||
if (indexSelected == 'SKIP'):
|
||||
if indexSelected == "SKIP":
|
||||
# Record that the user has skipped the TV Show for import, so that
|
||||
# manual input isn't required everytime
|
||||
userMatchedShowsTable.insert(
|
||||
{'ShowName': name, 'UserSelectedIndex': 0, 'SkipShow': True})
|
||||
{"ShowName": name, "UserSelectedIndex": 0, "SkipShow": True}
|
||||
)
|
||||
|
||||
return None
|
||||
# Otherwise, return the selection which the user made from the list
|
||||
|
@ -247,18 +279,24 @@ def getShowByName(name, seasonNo, episodeNo):
|
|||
selectedShow = showsWithSameName[int(indexSelected)]
|
||||
|
||||
userMatchedShowsTable.insert(
|
||||
{'ShowName': name, 'UserSelectedIndex': indexSelected, 'SkipShow': False})
|
||||
{
|
||||
"ShowName": name,
|
||||
"UserSelectedIndex": indexSelected,
|
||||
"SkipShow": False,
|
||||
}
|
||||
)
|
||||
|
||||
return selectedShow
|
||||
|
||||
else:
|
||||
if (len(showsWithSameName) > 0):
|
||||
if len(showsWithSameName) > 0:
|
||||
# If the search returned only one result, then awesome!
|
||||
# Return the show, so the import automation can continue.
|
||||
return showsWithSameName[0]
|
||||
else:
|
||||
return None
|
||||
|
||||
|
||||
# Since the Trakt.Py starts the indexing of seasons in the array from 0 (e.g Season 1 in Index 0), then
|
||||
# subtract the TV Time numerical value by 1 so it starts from 0 as well. However, when a TV series includes
|
||||
# a 'special' season, Trakt.Py will place this as the first season in the array - so, don't subtract, since
|
||||
|
@ -279,7 +317,7 @@ def parseSeasonNo(seasonNo, traktShowObj):
|
|||
# Otherwise, if the Trakt seasons start with no specials, then return the seasonNo,
|
||||
# but subtracted by one (e.g Season 1 in TV Time, will be 0)
|
||||
else:
|
||||
# Only subtract is the TV Time season number is greater than 0.
|
||||
# Only subtract if the TV Time season number is greater than 0.
|
||||
if seasonNo != 0:
|
||||
return seasonNo - 1
|
||||
# Otherwise, the TV Time season is a special! Then you don't need to change the starting position
|
||||
|
@ -291,44 +329,33 @@ def processWatchedShows():
|
|||
# Total amount of rows which have been processed in the CSV file
|
||||
rowsCount = 0
|
||||
# Total amount of rows in the CSV file
|
||||
rowsTotal = 0
|
||||
# Total amount of errors which have occurred in one streak
|
||||
errorStreak = 0
|
||||
|
||||
# Get the total amount of rows in the CSV file,
|
||||
# which is helpful for keeping track of progress.
|
||||
# However, if you have a VERY large CSV file (e.g above 100,000 rows)
|
||||
# then it might be a good idea to remove this due to the performance
|
||||
# overhead.
|
||||
with open(getWatchedShowsPath()) as f:
|
||||
rowsTotal = sum(1 for line in f)
|
||||
|
||||
# Open the CSV file within the GDPR exported data
|
||||
with open(getWatchedShowsPath(), newline='') as csvfile:
|
||||
with open(getWatchedShowsPath(), newline="") as csvfile:
|
||||
# Create the CSV reader, which will break up the fields using the delimiter ','
|
||||
showsReader = csv.reader(csvfile, delimiter=',')
|
||||
|
||||
showsReader = csv.DictReader(csvfile, delimiter=",")
|
||||
# Get the total amount of rows in the CSV file,
|
||||
rowsTotal = len(list(showsReader))
|
||||
# Move position to the beginning of the file
|
||||
csvfile.seek(0, 0)
|
||||
# Loop through each line/record of the CSV file
|
||||
for row in showsReader:
|
||||
# Increment the row counter to keep track of progress completing the
|
||||
# records during the import process.
|
||||
rowsCount += 1
|
||||
# Get the name of the TV show
|
||||
tvShowName = row[8]
|
||||
|
||||
# Ignore the header row
|
||||
if rowsCount > 1:
|
||||
next(showsReader, None)
|
||||
for rowsCount, row in enumerate(showsReader):
|
||||
# Get the name of the TV show
|
||||
tvShowName = row["tv_show_name"]
|
||||
# Get the TV Time Episode Id
|
||||
tvShowEpisodeId = row[4]
|
||||
tvShowEpisodeId = row["episode_id"]
|
||||
# Get the TV Time Season Number
|
||||
tvShowSeasonNo = row[5]
|
||||
tvShowSeasonNo = row["episode_season_number"]
|
||||
# Get the TV Time Episode Number
|
||||
tvShowEpisodeNo = row[6]
|
||||
tvShowEpisodeNo = row["episode_number"]
|
||||
# Get the date which the show was marked 'watched' in TV Time
|
||||
tvShowDateWatched = row[7]
|
||||
tvShowDateWatched = row["updated_at"]
|
||||
# Parse the watched date value into a Python type
|
||||
tvShowDateWatchedConverted = datetime.strptime(
|
||||
tvShowDateWatched, '%Y-%m-%d %H:%M:%S')
|
||||
tvShowDateWatched, "%Y-%m-%d %H:%M:%S"
|
||||
)
|
||||
|
||||
# Query the local database for previous entries indicating that
|
||||
# the episode has already been imported in the past. Which will
|
||||
|
@ -336,7 +363,8 @@ def processWatchedShows():
|
|||
# process, and just save time overall without needing to create network requests
|
||||
episodeCompletedQuery = Query()
|
||||
queryResult = syncedEpisodesTable.search(
|
||||
episodeCompletedQuery.episodeId == tvShowEpisodeId)
|
||||
episodeCompletedQuery.episodeId == tvShowEpisodeId
|
||||
)
|
||||
|
||||
# If the query returned no results, then continue to import it into Trakt
|
||||
if len(queryResult) == 0:
|
||||
|
@ -344,9 +372,10 @@ def processWatchedShows():
|
|||
while True:
|
||||
# If more than 10 errors occurred in one streak, whilst trying to import the episode
|
||||
# then give up, and move onto the next episode, but warn the user.
|
||||
if (errorStreak > 10):
|
||||
print(
|
||||
f"WARNING: An error occurred 10 times in a row... skipping episode...")
|
||||
if errorStreak > 10:
|
||||
logging.warning(
|
||||
"An error occurred 10 times in a row... skipping episode..."
|
||||
)
|
||||
break
|
||||
try:
|
||||
# Sleep for a second between each process, before going onto the next watched episode.
|
||||
|
@ -355,25 +384,27 @@ def processWatchedShows():
|
|||
time.sleep(DELAY_BETWEEN_EPISODES_IN_SECONDS)
|
||||
# Search Trakt for the TV show matching TV Time's title value
|
||||
traktShowObj = getShowByName(
|
||||
tvShowName, tvShowSeasonNo, tvShowEpisodeNo)
|
||||
tvShowName, tvShowSeasonNo, tvShowEpisodeNo
|
||||
)
|
||||
# If the method returned 'None', then this is an indication to skip the episode, and
|
||||
# move onto the next one
|
||||
if traktShowObj == None:
|
||||
if traktShowObj is None:
|
||||
break
|
||||
# Show the progress of the import on-screen
|
||||
print(
|
||||
f"({rowsCount}/{rowsTotal}) Processing Show {tvShowName} on Season {tvShowSeasonNo} - Episode {tvShowEpisodeNo}")
|
||||
logging.info(
|
||||
f"({rowsCount+1}/{rowsTotal}) - Processing '{tvShowName}' Season {tvShowSeasonNo} / Episode {tvShowEpisodeNo}"
|
||||
)
|
||||
# Get the season from the Trakt API
|
||||
season = traktShowObj.seasons[parseSeasonNo(
|
||||
tvShowSeasonNo, traktShowObj)]
|
||||
season = traktShowObj.seasons[
|
||||
parseSeasonNo(tvShowSeasonNo, traktShowObj)
|
||||
]
|
||||
# Get the episode from the season
|
||||
episode = season.episodes[int(tvShowEpisodeNo) - 1]
|
||||
# Mark the episode as watched!
|
||||
episode.mark_as_seen(tvShowDateWatchedConverted)
|
||||
# Add the episode to the local database as imported, so it can be skipped,
|
||||
# if the process is repeated
|
||||
syncedEpisodesTable.insert(
|
||||
{'episodeId': tvShowEpisodeId})
|
||||
syncedEpisodesTable.insert({"episodeId": tvShowEpisodeId})
|
||||
# Clear the error streak on completing the method without errors
|
||||
errorStreak = 0
|
||||
break
|
||||
|
@ -381,30 +412,37 @@ def processWatchedShows():
|
|||
# an incorrect Trakt show has been selected, with season/episodes which don't match TV Time.
|
||||
# It can also occur due to a bug in Trakt Py, whereby some seasons contain an empty array of episodes.
|
||||
except IndexError:
|
||||
print(
|
||||
f"({rowsCount}/{rowsTotal}) WARNING: {tvShowName} Season {tvShowSeasonNo}, Episode {tvShowEpisodeNo} does not exist (season/episode index) in Trakt!")
|
||||
tvShowSlug = traktShowObj.to_json()["shows"][0]["ids"]["ids"][
|
||||
"slug"
|
||||
]
|
||||
logging.warning(
|
||||
f"({rowsCount}/{rowsTotal}) - {tvShowName} Season {tvShowSeasonNo}, Episode {tvShowEpisodeNo} does not exist in Trakt! (https://trakt.tv/shows/{tvShowSlug}/seasons/{tvShowSeasonNo}/episodes/{tvShowEpisodeNo})"
|
||||
)
|
||||
break
|
||||
# Catch any errors which are raised because a show could not be found in Trakt
|
||||
except trakt.errors.NotFoundException:
|
||||
print(
|
||||
f"({rowsCount}/{rowsTotal}) WARNING: {tvShowName} Season {tvShowSeasonNo}, Episode {tvShowEpisodeNo} does not exist (search) in Trakt!")
|
||||
logging.warning(
|
||||
f"({rowsCount}/{rowsTotal}) - {tvShowName} Season {tvShowSeasonNo}, Episode {tvShowEpisodeNo} does not exist (search) in Trakt!"
|
||||
)
|
||||
break
|
||||
# Catch errors because of the program breaching the Trakt API rate limit
|
||||
except trakt.errors.RateLimitException:
|
||||
print(
|
||||
"WARNING: The program is running too quickly and has hit Trakt's API rate limit! Please increase the delay between " +
|
||||
"episdoes via the variable 'DELAY_BETWEEN_EPISODES_IN_SECONDS'. The program will now wait 60 seconds before " +
|
||||
"trying again.")
|
||||
logging.warning(
|
||||
"The program is running too quickly and has hit Trakt's API rate limit! Please increase the delay between "
|
||||
+ "episdoes via the variable 'DELAY_BETWEEN_EPISODES_IN_SECONDS'. The program will now wait 60 seconds before "
|
||||
+ "trying again."
|
||||
)
|
||||
time.sleep(60)
|
||||
|
||||
# Mark the exception in the error streak
|
||||
errorStreak += 1
|
||||
# Catch a JSON decode error - this can be raised when the API server is down and produces a HTML page, instead of JSON
|
||||
except json.decoder.JSONDecodeError:
|
||||
print(
|
||||
f"({rowsCount}/{rowsTotal}) WARNING: A JSON decode error occuring whilst processing {tvShowName} " +
|
||||
f"Season {tvShowSeasonNo}, Episode {tvShowEpisodeNo}! This might occur when the server is down and has produced " +
|
||||
"a HTML document instead of JSON. The script will wait 60 seconds before trying again.")
|
||||
logging.warning(
|
||||
f"({rowsCount}/{rowsTotal}) - A JSON decode error occuring whilst processing {tvShowName} "
|
||||
+ f"Season {tvShowSeasonNo}, Episode {tvShowEpisodeNo}! This might occur when the server is down and has produced "
|
||||
+ "a HTML document instead of JSON. The script will wait 60 seconds before trying again."
|
||||
)
|
||||
|
||||
# Wait 60 seconds
|
||||
time.sleep(60)
|
||||
|
@ -416,32 +454,36 @@ def processWatchedShows():
|
|||
sys.exit("Cancel requested...")
|
||||
# Skip the episode
|
||||
else:
|
||||
print(
|
||||
f"({rowsCount}/{rowsTotal}) Skipping '{tvShowName}' Season {tvShowSeasonNo} Episode {tvShowEpisodeNo}. It's already been imported.")
|
||||
logging.info(
|
||||
f"({rowsCount}/{rowsTotal}) - Already imported, skipping '{tvShowName}' Season {tvShowSeasonNo} / Episode {tvShowEpisodeNo}."
|
||||
)
|
||||
|
||||
|
||||
def start():
|
||||
# Create the initial authentication with Trakt, before starting the process
|
||||
if initTraktAuth():
|
||||
# Display a menu selection
|
||||
print(f">> What do you want to do?")
|
||||
print(f" 1) Import Watch History from TV Time")
|
||||
print(">> What do you want to do?")
|
||||
print(" 1) Import Watch History from TV Time")
|
||||
|
||||
while True:
|
||||
try:
|
||||
menuSelection = int(input(f"Enter your menu selection: "))
|
||||
menuSelection = input("Enter your menu selection: ")
|
||||
menuSelection = 1 if not menuSelection else int(menuSelection)
|
||||
break
|
||||
except ValueError:
|
||||
print("Invalid input. Please enter a numerical number.")
|
||||
logging.warning("Invalid input. Please enter a numerical number.")
|
||||
# Start the process which is required
|
||||
if menuSelection == 1:
|
||||
# Invoke the method which will import episodes which have been watched
|
||||
# from TV Time into Trakt
|
||||
processWatchedShows()
|
||||
else:
|
||||
print("Sorry - that's an unknown menu selection")
|
||||
logging.warning("Sorry - that's an unknown menu selection")
|
||||
else:
|
||||
print("ERROR: Unable to complete authentication to Trakt - please try again.")
|
||||
logging.error(
|
||||
"ERROR: Unable to complete authentication to Trakt - please try again."
|
||||
)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
|
@ -451,7 +493,12 @@ if __name__ == "__main__":
|
|||
if os.path.isdir(config.GDPR_WORKSPACE_PATH):
|
||||
start()
|
||||
else:
|
||||
print("Oops! The TV Time GDPR folder '" + config.GDPR_WORKSPACE_PATH +
|
||||
"' does not exist on the local system. Please check it, and try again.")
|
||||
logging.error(
|
||||
"Oops! The TV Time GDPR folder '"
|
||||
+ config.GDPR_WORKSPACE_PATH
|
||||
+ "' does not exist on the local system. Please check it, and try again."
|
||||
)
|
||||
else:
|
||||
print(f"ERROR: The 'config.json' file cannot be found - have you created it yet?")
|
||||
logging.error(
|
||||
"The 'config.json' file cannot be found - have you created it yet?"
|
||||
)
|
||||
|
|
2
requirements.txt
Normal file
2
requirements.txt
Normal file
|
@ -0,0 +1,2 @@
|
|||
trakt==3.4.0
|
||||
tinydb==4.6.1
|
Loading…
Reference in a new issue