| import datetime
|
| import json
|
| import logging
|
| import os
|
| import re
|
| import urllib
|
|
|
| import googleapiclient
|
| import requests
|
| import src.functions.drivetools
|
|
|
| LOGGER = logging.getLogger()
|
|
|
|
|
| def parseMovie(name):
|
|
|
| reg_1 = r"^[\(\[\{](?P<year>\d{4})[\)\]\}]\s(?P<title>[^.]+).*(?P<extention>\..*)?$"
|
|
|
| reg_2 = r"^(?P<title>.*)\s[\(\[\{](?P<year>\d{4})[\)\]\}].*(?P<extention>\..*)?$"
|
|
|
| reg_3 = r"^(?P<title>(?:(?!\.\d{4}).)*)\.(?P<year>\d{4}).*(?P<extention>\..*)?$"
|
| reg_4 = r"^(?P<year>)(?P<title>.*).*(?P<extention>\..*?$)"
|
| if re.match(reg_1, name):
|
| match = re.search(reg_1, name)
|
| elif re.match(reg_2, name):
|
| match = re.search(reg_2, name)
|
| elif re.match(reg_3, name):
|
| match = re.search(reg_3, name)
|
| return match["title"].replace(".", " "), match["year"]
|
| elif re.match(reg_4, name):
|
| match = re.search(reg_4, name)
|
| else:
|
| return None, None
|
| return match["title"], match["year"]
|
|
|
|
|
| def parseTV(name):
|
|
|
| reg_1 = r"^[\(\[\{](?P<year>\d{4})[\)\]\}]\s(?P<title>[^.]+).*$"
|
|
|
| reg_2 = r"^(?P<title>.*)\s[\(\[\{](?P<year>\d{4})[\)\]\}].*$"
|
|
|
| reg_3 = r"^(?P<title>(?:(?!\.\d{4}).)*)\.(?P<year>\d{4}).*$"
|
| reg_4 = r"^(?P<year>)(?P<title>.*)$"
|
| if re.match(reg_1, name):
|
| match = re.search(reg_1, name)
|
| elif re.match(reg_2, name):
|
| match = re.search(reg_2, name)
|
| elif re.match(reg_3, name):
|
| match = re.search(reg_3, name)
|
| return match["title"].replace(".", " "), match["year"]
|
| elif re.match(reg_4, name):
|
| match = re.search(reg_4, name)
|
| else:
|
| return None, None
|
| return match["title"], match["year"]
|
|
|
|
|
| def mediaIdentifier(
|
| ider_vars,
|
| title,
|
| year,
|
| movie=False,
|
| tv=False,
|
| anime=False,
|
| ):
|
| if year == None or year == "":
|
| tmp_year = "1900"
|
| else:
|
| tmp_year = year
|
| header = {
|
| 'x-cors-api-key': 'temp_4f366722ffa4bdd63246e0a9227c56e8',
|
| }
|
| if movie == True and anime == False:
|
| if ider_vars["adult"] == True:
|
| search_url = "https://proxy.cors.sh/https://api.themoviedb.org/3/search/movie?api_key=%s&query=%s&primary_release_year=%s&language=%s&include_adult=true" % (
|
| ider_vars["tmdb_api_key"],
|
| urllib.parse.quote(title.encode("utf-8")),
|
| year,
|
| ider_vars["language"],
|
| )
|
| else:
|
| search_url = "https://proxy.cors.sh/https://api.themoviedb.org/3/search/movie?api_key=%s&query=%s&primary_release_year=%s&language=%s" % (
|
| ider_vars["tmdb_api_key"],
|
| urllib.parse.quote(title.encode("utf-8")),
|
| year,
|
| ider_vars["language"],
|
| )
|
| try:
|
| search_content = requests.get(search_url, headers=header).json()
|
| except Exception as e:
|
| search_content = {"total_results": 0}
|
| LOGGER.error(
|
| "\033[31mERROR RETRIEVING TMDB DATA FOR '%s'!\033[0m" % (title),
|
| )
|
| LOGGER.error(str(e))
|
| if search_content.get("total_results", 0) > 0:
|
| data = search_content["results"][0]
|
| if data.get("backdrop_path"):
|
| data["backdrop_path"] = ider_vars["backdrop_base_url"] + data.get(
|
| "backdrop_path"
|
| )
|
| else:
|
| data["backdrop_path"] = None
|
| if data.get("poster_path"):
|
| data["poster_path"] = ider_vars["poster_base_url"] + data.get(
|
| "poster_path"
|
| )
|
| else:
|
| data["poster_path"] = None
|
| else:
|
| data = dict(
|
| {
|
| "adult": False,
|
| "backdrop_path": None,
|
| "genre_ids": [],
|
| "id": None,
|
| "original_language": None,
|
| "overview": None,
|
| "popularity": 70.412,
|
| "poster_path": None,
|
| "release_date": "%s-01-01" % (tmp_year),
|
| "title": title,
|
| "vote_average": 0.0,
|
| },
|
| )
|
| adult = data.get("adult", False)
|
| apiId = data.get("id")
|
| backdropPath = data.get("backdrop_path", None)
|
| genres = data.get("genre_ids", [])
|
| tmp_genres = []
|
| for genre in genres:
|
| for item in ider_vars["movie_genre_ids"]["genres"]:
|
| if item["id"] == genre:
|
| tmp_genres.append(item["name"])
|
| break
|
| genres = tmp_genres
|
| language = data.get("original_language", None)
|
| overview = data.get("overview", None)
|
| popularity = data.get("popularity", 0.0)
|
| posterPath = data.get("poster_path", None)
|
| releaseDate = data.get("release_date", "%s-01-01" % (tmp_year))
|
| title = data.get("title", title)
|
| voteAverage = data.get("vote_average", 0.0)
|
| return (
|
| adult,
|
| apiId,
|
| backdropPath,
|
| genres,
|
| language,
|
| overview,
|
| popularity,
|
| posterPath,
|
| releaseDate,
|
| title,
|
| voteAverage,
|
| )
|
| elif tv == True and anime == False:
|
| if ider_vars["adult"] == True:
|
| search_url = "https://proxy.cors.sh/https://api.themoviedb.org/3/search/tv?api_key=%s&query=%s&first_air_date_year=%s&language=%s&include_adult=true" % (
|
| ider_vars["tmdb_api_key"],
|
| urllib.parse.quote(title.encode("utf-8")),
|
| year,
|
| ider_vars["language"],
|
| )
|
| else:
|
| search_url = "https://proxy.cors.sh/https://api.themoviedb.org/3/search/tv?api_key=%s&query=%s&first_air_date_year=%s&language=%s" % (
|
| ider_vars["tmdb_api_key"],
|
| urllib.parse.quote(title.encode("utf-8")),
|
| year,
|
| ider_vars["language"],
|
| )
|
| try:
|
| header = {
|
| 'x-cors-api-key': 'temp_4f366722ffa4bdd63246e0a9227c56e8',
|
| }
|
| search_content = requests.get(search_url, headers=header).json()
|
| except Exception as e:
|
| search_content = {"total_results": 0}
|
| LOGGER.error(
|
| "\033[31mERROR RETRIEVING TMDB DATA FOR '%s'!\033[0m" % (title,),
|
| )
|
| LOGGER.error(str(e))
|
| if search_content.get("total_results", 0) > 0:
|
| data = search_content["results"][0]
|
| if data.get("backdrop_path"):
|
| data["backdrop_path"] = ider_vars["backdrop_base_url"] + data.get(
|
| "backdrop_path"
|
| )
|
| else:
|
| data["backdrop_path"] = None
|
| if data.get("poster_path"):
|
| data["poster_path"] = ider_vars["poster_base_url"] + data.get(
|
| "poster_path"
|
| )
|
| else:
|
| data["poster_path"] = None
|
| else:
|
| data = dict(
|
| {
|
| "backdrop_path": None,
|
| "first_air_date": "%s-01-01" % (tmp_year),
|
| "genre_ids": [],
|
| "id": None,
|
| "name": title,
|
| "original_language": None,
|
| "overview": None,
|
| "popularity": 0.0,
|
| "poster_path": None,
|
| "vote_average": 0.0,
|
| },
|
| )
|
| apiId = data.get("id")
|
| backdropPath = data.get("backdrop_path", None)
|
| genres = data.get("genre_ids", [])
|
| tmp_genres = []
|
| for genre in genres:
|
| for item in ider_vars["tv_genre_ids"]["genres"]:
|
| if item["id"] == genre:
|
| tmp_genres.append(item["name"])
|
| break
|
| genres = tmp_genres
|
| language = data.get("original_language", None)
|
| overview = data.get("overview", None)
|
| popularity = data.get("popularity", 0.0)
|
| posterPath = data.get("poster_path", None)
|
| releaseDate = data.get("first_air_date", "%s-01-01" % (tmp_year))
|
| title = data.get("name", title)
|
| voteAverage = data.get("vote_average", 0.0)
|
| return (
|
| apiId,
|
| backdropPath,
|
| genres,
|
| language,
|
| overview,
|
| popularity,
|
| posterPath,
|
| releaseDate,
|
| title,
|
| voteAverage,
|
| )
|
| elif movie == True and anime == True:
|
| query = """
|
| query ($search: String, $seasonYear: Int, $isAdult: Boolean) {
|
| Media(search: $search, seasonYear: $seasonYear, type: ANIME, isAdult: $isAdult) {
|
| title {
|
| english
|
| romaji
|
| native
|
| }
|
| id
|
| description
|
| genres
|
| isAdult
|
| averageScore
|
| popularity
|
| startDate {
|
| year
|
| month
|
| day
|
| }
|
| bannerImage
|
| coverImage {
|
| large
|
| }
|
| }
|
| }
|
| """
|
| variables = {"search": title}
|
| if ider_vars["adult"] == False:
|
| variables["isAdult"] = False
|
| if year != None and year != "":
|
| variables["seasonYear"] = year
|
| try:
|
| response = requests.post(
|
| "https://graphql.anilist.co",
|
| json={"query": query, "variables": variables},
|
| ).json()
|
| except Exception as e:
|
| response = None
|
| LOGGER.error(
|
| "\033[31mERROR RETRIEVING ANILIST DATA FOR '%s'!\033[0m" % (title),
|
| )
|
| LOGGER.error(str(e))
|
| data = dict(
|
| {
|
| "isAdult": False,
|
| "id": None,
|
| "title": {"english": title},
|
| "startDate": {"year": tmp_year, "month": "01", "day": "01"},
|
| "genres": [],
|
| "original_language": None,
|
| "description": None,
|
| "popularity": 0.0,
|
| "bannerImage": "",
|
| "coverImage": {"large": None},
|
| "averageScore": 0.0,
|
| },
|
| )
|
| if response != None:
|
| if isinstance(response.get("data"), dict):
|
| if response.get("data", {}).get("Media", None):
|
| data = response["data"]["Media"]
|
| if data.get("title", {}).get("english") == None:
|
| if data.get("title", {}).get("romaji") == None:
|
| if data.get("title", {}).get("native") == None:
|
| data["title"] = title
|
| else:
|
| data["title"] = data["title"]["native"]
|
| else:
|
| data["title"] = data["title"]["romaji"]
|
| else:
|
| data["title"] = data["title"]["english"]
|
| startDate = data.get("startDate", {})
|
| releases_date = "%s-%s-%s" % (
|
| startDate.get("year", tmp_year),
|
| startDate.get("month", "01"),
|
| startDate.get("day", "01"),
|
| )
|
| if "None" in releases_date:
|
| releases_date = "%s-%s-%s" % (tmp_year, "01", "01")
|
| genres = []
|
| for genre in data.get("genres", []):
|
| genres.append(genre)
|
| if data.get("bannerImage") != None and data.get("bannerImage") != "":
|
| data["bannerImage"] = data["bannerImage"].replace("/small/", "/large/")
|
| if data.get("description") != None and data.get("description") != "":
|
| data["description"] = re.sub(re.compile("<.*?>"), "", data["description"])
|
| return (
|
| data.get("isAdult", False),
|
| data.get("id"),
|
| data.get("bannerImage"),
|
| genres,
|
| data.get("original_language"),
|
| data.get("description"),
|
| data.get("popularity", 0.0),
|
| data.get("coverImage", {}).get("large"),
|
| releases_date,
|
| data.get("title", title),
|
| data.get("averageScore", 0.0),
|
| )
|
| elif tv == True and anime == True:
|
| query = """
|
| query ($search: String, $seasonYear: Int, $isAdult: Boolean) {
|
| Media(search: $search, seasonYear: $seasonYear, type: ANIME, isAdult: $isAdult) {
|
| title {
|
| english
|
| romaji
|
| native
|
| }
|
| id
|
| description
|
| genres
|
| isAdult
|
| averageScore
|
| popularity
|
| startDate {
|
| year
|
| month
|
| day
|
| }
|
| bannerImage
|
| coverImage {
|
| large
|
| }
|
| }
|
| }
|
| """
|
| variables = {"search": title}
|
| if ider_vars["adult"] == False:
|
| variables["isAdult"] = False
|
| if year != None and year != "":
|
| variables["seasonYear"] = year
|
| try:
|
| response = requests.post(
|
| "https://graphql.anilist.co",
|
| json={"query": query, "variables": variables},
|
| ).json()
|
| except Exception as e:
|
| response = None
|
| LOGGER.error(
|
| "\033[31mERROR RETRIEVING ANILIST DATA FOR '%s'!\033[0m" % (title),
|
| )
|
| LOGGER.error(str(e))
|
| data = dict(
|
| {
|
| "isAdult": False,
|
| "id": None,
|
| "title": {"english": title},
|
| "startDate": {"year": tmp_year, "month": "01", "day": "01"},
|
| "genres": [],
|
| "original_language": None,
|
| "description": None,
|
| "popularity": 0.0,
|
| "bannerImage": "",
|
| "coverImage": {"large": None},
|
| "averageScore": 0.0,
|
| },
|
| )
|
| if response != None:
|
| if isinstance(response.get("data"), dict):
|
| if response.get("data", {}).get("Media", None):
|
| data = response["data"]["Media"]
|
| title_dict = data.get("title", {})
|
| if title_dict.get("english") == None:
|
| if title_dict.get("romaji") == None:
|
| if title_dict.get("native") == None:
|
| data["title"] = title
|
| else:
|
| data["title"] = title_dict["native"]
|
| else:
|
| data["title"] = title_dict["romaji"]
|
| else:
|
| data["title"] = title_dict["english"]
|
| startDate = data.get("startDate", {})
|
| releases_date = "%s-%s-%s" % (
|
| startDate.get("year", tmp_year),
|
| startDate.get("month", "01"),
|
| startDate.get("day", "01"),
|
| )
|
| if "None" in releases_date:
|
| releases_date = "%s-%s-%s" % (tmp_year, "01", "01")
|
| genres = []
|
| for genre in data.get("genres", []):
|
| genres.append(genre)
|
| if data.get("bannerImage") != None and data.get("bannerImage") != "":
|
| data["bannerImage"] = data["bannerImage"].replace("/small/", "/large/")
|
| if data.get("description") != None and data.get("description") != "":
|
| data["description"] = re.sub(re.compile("<.*?>"), "", data["description"])
|
| return (
|
| data.get("isAdult", False),
|
| data.get("id"),
|
| data.get("bannerImage"),
|
| genres,
|
| data.get("original_language"),
|
| data.get("description"),
|
| data.get("popularity", 0.0),
|
| data.get("coverImage", {}).get("large"),
|
| releases_date,
|
| data.get("title", title),
|
| data.get("averageScore", 0.0),
|
| )
|
|
|
|
|
| def readMetadata(config):
|
| if os.path.exists("./metadata.json"):
|
| with open("./metadata.json", "r") as r:
|
| metadata = json.load(r)
|
| else:
|
| metadata = []
|
| build_interval = config.get("build_interval")
|
| if not build_interval:
|
| build_interval = 0
|
| for category in config["category_list"]:
|
| tmp = {
|
| "kind": "drive#file",
|
| "id": "",
|
| "name": "",
|
| "mimeType": "application/vnd.google-apps.folder",
|
| "teamDriveId": "",
|
| "driveId": "",
|
| "type": "directory",
|
| "children": [],
|
| "categoryInfo": category,
|
| "length": 0,
|
| "buildTime": str(
|
| datetime.datetime.utcnow()
|
| - datetime.timedelta(minutes=build_interval + 1)
|
| ),
|
| }
|
| metadata.append(tmp)
|
| return metadata
|
|
|
|
|
| def writeMetadata(config):
|
| header = {
|
| 'x-cors-api-key': 'temp_4f366722ffa4bdd63246e0a9227c56e8',
|
| }
|
| configuration_content = json.loads(
|
| requests.get(
|
| "https://proxy.cors.sh/https://api.themoviedb.org/3/configuration?api_key=%s"
|
| % (config.get("tmdb_api_key")), headers=header
|
| ).content
|
| )
|
| backdrop_base_url = (
|
| configuration_content["images"]["secure_base_url"]
|
| + configuration_content["images"]["backdrop_sizes"][3]
|
| )
|
| poster_base_url = (
|
| configuration_content["images"]["secure_base_url"]
|
| + configuration_content["images"]["poster_sizes"][3]
|
| )
|
| header = {
|
| 'x-cors-api-key': 'temp_4f366722ffa4bdd63246e0a9227c56e8',
|
| }
|
| movie_genre_ids = json.loads(
|
| requests.get(
|
| "https://proxy.cors.sh/https://api.themoviedb.org/3/genre/movie/list?api_key=%s"
|
| % (config.get("tmdb_api_key")), headers=header
|
| ).content
|
| )
|
| tv_genre_ids = json.loads(
|
| requests.get(
|
| "https://proxy.cors.sh/https://api.themoviedb.org/3/genre/tv/list?api_key=%s"
|
| % (config.get("tmdb_api_key")), headers=header
|
| ).content
|
| )
|
|
|
| placeholder_metadata = []
|
| count = 0
|
| for category in config["category_list"]:
|
| ider_vars = {
|
| "tmdb_api_key": config.get("tmdb_api_key"),
|
| "backdrop_base_url": backdrop_base_url,
|
| "poster_base_url": poster_base_url,
|
| "movie_genre_ids": movie_genre_ids,
|
| "tv_genre_ids": tv_genre_ids,
|
| "language": category.get("language", config.get("language", "en")),
|
| "adult": category.get("adult", config.get("adult", False)),
|
| }
|
| count += 1
|
| start_time = datetime.datetime.utcnow()
|
| config, drive = src.functions.credentials.refreshCredentials(config)
|
| LOGGER.info(
|
| "\033[32mBUILDING METADATA FOR CATEGORY %s/%s %s...\033[0m\n"
|
| % (count, len(config["category_list"]), category["name"])
|
| )
|
| try:
|
| root = (
|
| drive.files()
|
| .get(fileId=category["id"], supportsAllDrives=True)
|
| .execute()
|
| )
|
| except Exception as e:
|
| LOGGER.error(
|
| "\033[31mERROR RETRIEVING FOLDER '%s'!\033[0m" % (category["name"]),
|
| )
|
| LOGGER.error(str(e))
|
| if category["type"] == "Movies":
|
| tree = root
|
| tree["type"] = "directory"
|
| tree["children"] = []
|
| tmp_metadata = src.functions.drivetools.driveWalk(
|
| root, drive, root, "video"
|
| )
|
| tmp_metadata["categoryInfo"] = category
|
| tmp_metadata["length"] = len(tmp_metadata["children"])
|
| tmp_metadata["buildTime"] = str(datetime.datetime.utcnow())
|
| if category.get("anilist") == True:
|
| items_count = 0
|
| items_length = len(tmp_metadata["children"])
|
| for item in tmp_metadata["children"]:
|
| items_count += 1
|
| LOGGER.info(
|
| "\033[93mSCRAPING %s/%s %s...\033[0m"
|
| % (items_count, items_length, item["name"]),
|
| )
|
| if item["type"] == "file":
|
| title, year = parseMovie(item["name"])
|
| if title == None:
|
| title = item["name"]
|
| if year == None:
|
| year = ""
|
| item["api"] = "anilist"
|
| (
|
| item["adult"],
|
| item["apiId"],
|
| item["backdropPath"],
|
| item["genres"],
|
| item["language"],
|
| item["overview"],
|
| item["popularity"],
|
| item["posterPath"],
|
| item["releaseDate"],
|
| item["title"],
|
| item["voteAverage"],
|
| ) = mediaIdentifier(
|
| ider_vars,
|
| title,
|
| year,
|
| movie=True,
|
| tv=False,
|
| anime=True,
|
| )
|
| else:
|
| items_count = 0
|
| items_length = len(tmp_metadata["children"])
|
| for item in tmp_metadata["children"]:
|
| items_count += 1
|
| LOGGER.info(
|
| "\033[93mSCRAPING %s/%s %s...\033[0m"
|
| % (items_count, items_length, item["name"])
|
| )
|
| if item["type"] == "file":
|
| title, year = parseMovie(item["name"])
|
| if title == None:
|
| title = item["name"]
|
| if year == None:
|
| year = ""
|
| item["api"] = "tmdb"
|
| (
|
| item["adult"],
|
| item["apiId"],
|
| item["backdropPath"],
|
| item["genres"],
|
| item["language"],
|
| item["overview"],
|
| item["popularity"],
|
| item["posterPath"],
|
| item["releaseDate"],
|
| item["title"],
|
| item["voteAverage"],
|
| ) = mediaIdentifier(
|
| ider_vars,
|
| title,
|
| year,
|
| movie=True,
|
| tv=False,
|
| anime=False,
|
| )
|
|
|
| placeholder_metadata.append(tmp_metadata)
|
| elif category["type"] == "TV Shows":
|
| if root["mimeType"] == "application/vnd.google-apps.folder":
|
| if config.get("build_type") == "full":
|
| root["type"] = "directory"
|
| root["children"] = []
|
| for item in src.functions.drivetools.driveIter(
|
| root, drive, "video"
|
| ):
|
| if root["mimeType"] == "application/vnd.google-apps.folder":
|
| item["children"] = []
|
| for x in src.functions.drivetools.driveIter(
|
| item, drive, "video"
|
| ):
|
| if (
|
| x["mimeType"]
|
| == "application/vnd.google-apps.folder"
|
| ):
|
| x["children"] = []
|
| for y in src.functions.drivetools.driveIter(
|
| x, drive, "video"
|
| ):
|
| if "video" in y["mimeType"]:
|
| x["children"].append(y)
|
| item["children"].append(x)
|
| root["children"].append(item)
|
| else:
|
| root["type"] = "directory"
|
| root["children"] = []
|
| for item in src.functions.drivetools.driveIter(
|
| root, drive, "video"
|
| ):
|
| if root["mimeType"] == "application/vnd.google-apps.folder":
|
| root["children"].append(item)
|
| tmp_metadata = root
|
| tmp_metadata["categoryInfo"] = category
|
| tmp_metadata["length"] = len(tmp_metadata["children"])
|
| tmp_metadata["buildTime"] = str(datetime.datetime.utcnow())
|
| if category.get("anilist") == True:
|
| items_count = 0
|
| items_length = len(tmp_metadata["children"])
|
| for item in tmp_metadata["children"]:
|
| items_count += 1
|
| LOGGER.info(
|
| "\033[93mSCRAPING %s/%s %s...\033[0m"
|
| % (items_count, items_length, item["name"]),
|
| )
|
| if item["type"] == "directory":
|
| title, year = parseTV(item["name"])
|
| if title == None:
|
| title = item["name"]
|
| if year == None:
|
| year = ""
|
| item["api"] = "anilist"
|
| (
|
| item["adult"],
|
| item["apiId"],
|
| item["backdropPath"],
|
| item["genres"],
|
| item["language"],
|
| item["overview"],
|
| item["popularity"],
|
| item["posterPath"],
|
| item["releaseDate"],
|
| item["title"],
|
| item["voteAverage"],
|
| ) = mediaIdentifier(
|
| ider_vars,
|
| title,
|
| year,
|
| movie=False,
|
| tv=True,
|
| anime=True,
|
| )
|
| else:
|
| items_count = 0
|
| items_length = len(tmp_metadata["children"])
|
| for item in tmp_metadata["children"]:
|
| items_count += 1
|
| LOGGER.info(
|
| "\033[93mSCRAPING %s/%s %s...\033[0m"
|
| % (items_count, items_length, item["name"]),
|
| )
|
| if item["type"] == "directory":
|
| title, year = parseTV(item["name"])
|
| if title == None:
|
| title = item["name"]
|
| if year == None:
|
| year = ""
|
| item["api"] = "tmdb"
|
| (
|
| item["apiId"],
|
| item["backdropPath"],
|
| item["genres"],
|
| item["language"],
|
| item["overview"],
|
| item["popularity"],
|
| item["posterPath"],
|
| item["releaseDate"],
|
| item["title"],
|
| item["voteAverage"],
|
| ) = mediaIdentifier(
|
| ider_vars,
|
| title,
|
| year,
|
| movie=False,
|
| tv=True,
|
| anime=False,
|
| )
|
|
|
| placeholder_metadata.append(tmp_metadata)
|
| LOGGER.info("\nDONE IN %s.\n" % (str(datetime.datetime.utcnow() - start_time)))
|
|
|
| metadata = placeholder_metadata
|
|
|
| with open("./metadata.json", "w+") as w:
|
| json.dump(obj=metadata, fp=w, sort_keys=True, indent=4)
|
|
|
| if os.getenv("LIBDRIVE_CLOUD"):
|
| config, drive = src.functions.credentials.refreshCredentials(config)
|
| params = {
|
| "supportsAllDrives": True,
|
| "includeItemsFromAllDrives": True,
|
| "fields": "files(id,name)",
|
| "q": "'%s' in parents and trashed = false and mimeType = 'application/json'"
|
| % (os.getenv("LIBDRIVE_CLOUD")),
|
| }
|
| files = drive.files().list(**params).execute()["files"]
|
| metadata_file = next((i for i in files if i["name"] == "metadata.json"), None)
|
| file_metadata = {
|
| "name": "metadata.json",
|
| "mimeType": "application/json",
|
| "parents": [os.getenv("LIBDRIVE_CLOUD")],
|
| }
|
| media = googleapiclient.http.MediaFileUpload(
|
| "./metadata.json", mimetype="application/json", resumable=True
|
| )
|
| if metadata_file:
|
| params = {
|
| "fileId": metadata_file["id"],
|
| "media_body": media,
|
| "supportsAllDrives": True,
|
| }
|
| drive.files().update(**params).execute()
|
| else:
|
| params = {
|
| "body": file_metadata,
|
| "media_body": media,
|
| "supportsAllDrives": True,
|
| }
|
| drive.files().create(**params).execute()
|
| return metadata
|
|
|
|
|
| def jsonExtract(obj, key, val, multi=False):
|
| arr = []
|
|
|
| def extract(obj, arr, key, val):
|
| if isinstance(obj, dict):
|
| for k, v in obj.items():
|
| if isinstance(v, (dict, list)):
|
| extract(v, arr, key, val)
|
| elif key and val:
|
| if k == key and v == val:
|
| arr.append(obj)
|
| elif key or val:
|
| if k == key or v == val:
|
| arr.append(obj)
|
| elif isinstance(obj, list):
|
| for item in obj:
|
| extract(item, arr, key, val)
|
| return arr
|
|
|
| results = extract(obj, arr, key, val)
|
| if multi == False and len(results) > 0:
|
| return results[0]
|
| elif multi == True and len(results) > 0:
|
| return results
|
| else:
|
| return None
|
|
|
