bel
/
JellyPlex-Watched
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #65 from luigi311/dev 

Dev
pull/78/head v4.5.0
Luigi311 2023-04-11 09:29:08 -06:00 committed by GitHub
parent c69d59858d fc80f50560
commit 18df322c41
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
10 changed files with 979 additions and 458 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
.env.sample
View File

@ -9,6 +9,9 @@ DEBUG = "False"
## Debugging level, "info" is default, "debug" is more verbose ## Debugging level, "info" is default, "debug" is more verbose
DEBUG_LEVEL = "info" DEBUG_LEVEL = "info"
## If set to true then the script will only run once and then exit
RUN_ONLY_ONCE = "False"
## How often to run the script in seconds ## How often to run the script in seconds
SLEEP_DURATION = "3600" SLEEP_DURATION = "3600"
@ -27,7 +30,7 @@ LOGFILE = "log.log"
## Comma separated for multiple options ## Comma separated for multiple options
#BLACKLIST_LIBRARY = "" #BLACKLIST_LIBRARY = ""
#WHITELIST_LIBRARY = "" #WHITELIST_LIBRARY = ""
#BLACKLIST_LIBRARY_TYPE = "" #BLACKLIST_LIBRARY_TYPE = ""
#WHITELIST_LIBRARY_TYPE = "" #WHITELIST_LIBRARY_TYPE = ""
#BLACKLIST_USERS = "" #BLACKLIST_USERS = ""
WHITELIST_USERS = "testuser1,testuser2" WHITELIST_USERS = "testuser1,testuser2"

333
README.md
View File

@ -1,149 +1,184 @@
# JellyPlex-Watched # JellyPlex-Watched
[![Codacy Badge](https://app.codacy.com/project/badge/Grade/26b47c5db63942f28f02f207f692dc85)](https://www.codacy.com/gh/luigi311/JellyPlex-Watched/dashboard?utm_source=github.com&utm_medium=referral&utm_content=luigi311/JellyPlex-Watched&utm_campaign=Badge_Grade) [![Codacy Badge](https://app.codacy.com/project/badge/Grade/26b47c5db63942f28f02f207f692dc85)](https://www.codacy.com/gh/luigi311/JellyPlex-Watched/dashboard?utm_source=github.com\&utm_medium=referral\&utm_content=luigi311/JellyPlex-Watched\&utm_campaign=Badge_Grade)
Sync watched between jellyfin and plex locally Sync watched between jellyfin and plex locally
## Description ## Description
Keep in sync all your users watched history between jellyfin and plex servers locally. This uses file names and provider ids to find the correct episode/movie between the two. This is not perfect but it works for most cases. You can use this for as many servers as you want by entering multiple options in the .env plex/jellyfin section separated by commas. Keep in sync all your users watched history between jellyfin and plex servers locally. This uses file names and provider ids to find the correct episode/movie between the two. This is not perfect but it works for most cases. You can use this for as many servers as you want by entering multiple options in the .env plex/jellyfin section separated by commas.
## Configuration ## Features
```bash ### Plex
# Global Settings
* \[x] Match via Filenames
## Do not mark any shows/movies as played and instead just output to log if they would of been marked. * \[x] Match via provider ids
DRYRUN = "True" * \[x] Map usersnames
* \[x] Use single login
## Additional logging information * \[x] One Way/Multi Way sync
DEBUG = "False" * \[x] Sync Watched
* \[x] Sync Inprogress
## Debugging level, "info" is default, "debug" is more verbose
DEBUG_LEVEL = "info" ### Jellyfin
## How often to run the script in seconds * \[x] Match via Filenames
SLEEP_DURATION = "3600" * \[x] Match via provider ids
* \[x] Map usersnames
## Log file where all output will be written to * \[x] Use single login
LOGFILE = "log.log" * \[x] One Way/Multi Way sync
* \[x] Sync Watched
## Map usernames between servers in the event that they are different, order does not matter * \[ ] Sync Inprogress
## Comma separated for multiple options
USER_MAPPING = { "testuser2": "testuser3", "testuser1":"testuser4" } ### Emby
## Map libraries between servers in the even that they are different, order does not matter * \[ ] Match via Filenames
## Comma separated for multiple options * \[ ] Match via provider ids
LIBRARY_MAPPING = { "Shows": "TV Shows", "Movie": "Movies" } * \[ ] Map usersnames
* \[ ] Use single login
## Blacklisting/Whitelisting libraries, library types such as Movies/TV Shows, and users. Mappings apply so if the mapping for the user or library exist then both will be excluded. * \[ ] One Way/Multi Way sync
## Comma separated for multiple options * \[ ] Sync Watched
BLACKLIST_LIBRARY = "" * \[ ] Sync Inprogress
WHITELIST_LIBRARY = ""
BLACKLIST_LIBRARY_TYPE = "" ## Configuration
WHITELIST_LIBRARY_TYPE = ""
BLACKLIST_USERS = "" ```bash
WHITELIST_USERS = "testuser1,testuser2" # Global Settings
## Do not mark any shows/movies as played and instead just output to log if they would of been marked.
DRYRUN = "True"
# Plex
## Additional logging information
## Recommended to use token as it is faster to connect as it is direct to the server instead of going through the plex servers DEBUG = "False"
## URL of the plex server, use hostname or IP address if the hostname is not resolving correctly
## Comma separated list for multiple servers ## Debugging level, "info" is default, "debug" is more verbose
PLEX_BASEURL = "http://localhost:32400, https://nas:32400" DEBUG_LEVEL = "info"
## Plex token https://support.plex.tv/articles/204059436-finding-an-authentication-token-x-plex-token/ ## If set to true then the script will only run once and then exit
## Comma separated list for multiple servers RUN_ONLY_ONCE = "False"
PLEX_TOKEN = "SuperSecretToken, SuperSecretToken2"
## How often to run the script in seconds
## If not using plex token then use username and password of the server admin along with the servername SLEEP_DURATION = "3600"
## Comma separated for multiple options
#PLEX_USERNAME = "PlexUser, PlexUser2" ## Log file where all output will be written to
#PLEX_PASSWORD = "SuperSecret, SuperSecret2" LOGFILE = "log.log"
#PLEX_SERVERNAME = "Plex Server1, Plex Server2"
## Map usernames between servers in the event that they are different, order does not matter
## Skip hostname validation for ssl certificates. ## Comma separated for multiple options
## Set to True if running into ssl certificate errors USER_MAPPING = { "testuser2": "testuser3", "testuser1":"testuser4" }
SSL_BYPASS = "False"
## Map libraries between servers in the even that they are different, order does not matter
## Comma separated for multiple options
## control the direction of syncing. e.g. SYNC_FROM_PLEX_TO_JELLYFIN set to true will cause the updates from plex LIBRARY_MAPPING = { "Shows": "TV Shows", "Movie": "Movies" }
## to be updated in jellyfin. SYNC_FROM_PLEX_TO_PLEX set to true will sync updates between multiple plex servers
SYNC_FROM_PLEX_TO_JELLYFIN = "True" ## Blacklisting/Whitelisting libraries, library types such as Movies/TV Shows, and users. Mappings apply so if the mapping for the user or library exist then both will be excluded.
SYNC_FROM_JELLYFIN_TO_PLEX = "True" ## Comma separated for multiple options
SYNC_FROM_PLEX_TO_PLEX = "True" BLACKLIST_LIBRARY = ""
SYNC_FROM_JELLYFIN_TO_JELLYFIN = "True" WHITELIST_LIBRARY = ""
BLACKLIST_LIBRARY_TYPE = ""
WHITELIST_LIBRARY_TYPE = ""
# Jellyfin BLACKLIST_USERS = ""
WHITELIST_USERS = "testuser1,testuser2"
## Jellyfin server URL, use hostname or IP address if the hostname is not resolving correctly
## Comma separated list for multiple servers
JELLYFIN_BASEURL = "http://localhost:8096, http://nas:8096"
# Plex
## Jellyfin api token, created manually by logging in to the jellyfin server admin dashboard and creating an api key
## Comma separated list for multiple servers ## Recommended to use token as it is faster to connect as it is direct to the server instead of going through the plex servers
JELLYFIN_TOKEN = "SuperSecretToken, SuperSecretToken2" ## URL of the plex server, use hostname or IP address if the hostname is not resolving correctly
``` ## Comma separated list for multiple servers
PLEX_BASEURL = "http://localhost:32400, https://nas:32400"
## Installation
## Plex token https://support.plex.tv/articles/204059436-finding-an-authentication-token-x-plex-token/
### Baremetal ## Comma separated list for multiple servers
PLEX_TOKEN = "SuperSecretToken, SuperSecretToken2"
- Setup virtualenv of your choice
## If not using plex token then use username and password of the server admin along with the servername
- Install dependencies ## Comma separated for multiple options
#PLEX_USERNAME = "PlexUser, PlexUser2"
```bash #PLEX_PASSWORD = "SuperSecret, SuperSecret2"
pip install -r requirements.txt #PLEX_SERVERNAME = "Plex Server1, Plex Server2"
```
## Skip hostname validation for ssl certificates.
- Create a .env file similar to .env.sample, uncomment whitelist and blacklist if needed, fill in baseurls and tokens ## Set to True if running into ssl certificate errors
SSL_BYPASS = "False"
- Run
```bash ## control the direction of syncing. e.g. SYNC_FROM_PLEX_TO_JELLYFIN set to true will cause the updates from plex
python main.py ## to be updated in jellyfin. SYNC_FROM_PLEX_TO_PLEX set to true will sync updates between multiple plex servers
``` SYNC_FROM_PLEX_TO_JELLYFIN = "True"
SYNC_FROM_JELLYFIN_TO_PLEX = "True"
### Docker SYNC_FROM_PLEX_TO_PLEX = "True"
SYNC_FROM_JELLYFIN_TO_JELLYFIN = "True"
- Build docker image
```bash # Jellyfin
docker build -t jellyplex-watched .
``` ## Jellyfin server URL, use hostname or IP address if the hostname is not resolving correctly
## Comma separated list for multiple servers
- or use pre-built image JELLYFIN_BASEURL = "http://localhost:8096, http://nas:8096"
```bash ## Jellyfin api token, created manually by logging in to the jellyfin server admin dashboard and creating an api key
docker pull luigi311/jellyplex-watched:latest ## Comma separated list for multiple servers
``` JELLYFIN_TOKEN = "SuperSecretToken, SuperSecretToken2"
```
#### With variables
## Installation
- Run
### Baremetal
```bash
docker run --rm -it -e PLEX_TOKEN='SuperSecretToken' luigi311/jellyplex-watched:latest * Setup virtualenv of your choice
```
* Install dependencies
#### With .env
```bash
- Create a .env file similar to .env.sample and set the variables to match your setup pip install -r requirements.txt
```
- Run
* Create a .env file similar to .env.sample, uncomment whitelist and blacklist if needed, fill in baseurls and tokens
```bash
docker run --rm -it -v "$(pwd)/.env:/app/.env" luigi311/jellyplex-watched:latest * Run
```
```bash
## Contributing python main.py
```
I am open to receiving pull requests. If you are submitting a pull request, please make sure run it locally for a day or two to make sure it is working as expected and stable. Make all pull requests against the dev branch and nothing will be merged into the main without going through the lower branches.
### Docker
## License
* Build docker image
This is currently under the GNU General Public License v3.0.
```bash
docker build -t jellyplex-watched .
```
* or use pre-built image
```bash
docker pull luigi311/jellyplex-watched:latest
```
#### With variables
* Run
```bash
docker run --rm -it -e PLEX_TOKEN='SuperSecretToken' luigi311/jellyplex-watched:latest
```
#### With .env
* Create a .env file similar to .env.sample and set the variables to match your setup
* Run
```bash
docker run --rm -it -v "$(pwd)/.env:/app/.env" luigi311/jellyplex-watched:latest
```
## Contributing
I am open to receiving pull requests. If you are submitting a pull request, please make sure run it locally for a day or two to make sure it is working as expected and stable. Make all pull requests against the dev branch and nothing will be merged into the main without going through the lower branches.
## License
This is currently under the GNU General Public License v3.0.

8
src/functions.py
View File

@ -39,6 +39,14 @@ def str_to_bool(value: any) -> bool:
return str(value).lower() in ("y", "yes", "t", "true", "on", "1") return str(value).lower() in ("y", "yes", "t", "true", "on", "1")
# Search for nested element in list
def contains_nested(element, lst):
for i, item in enumerate(lst):
if element in item:
return i
return None
# Get mapped value # Get mapped value
def search_mapping(dictionary: dict, key_value: str): def search_mapping(dictionary: dict, key_value: str):
if key_value in dictionary.keys(): if key_value in dictionary.keys():

331
src/jellyfin.py
View File

@ -1,9 +1,7 @@
import asyncio, aiohttp, traceback import asyncio, aiohttp, traceback
from math import floor
from src.functions import ( from src.functions import logger, search_mapping, contains_nested
logger,
search_mapping,
)
from src.library import ( from src.library import (
check_skip_logic, check_skip_logic,
generate_library_guids_dict, generate_library_guids_dict,
@ -13,6 +11,56 @@ from src.watched import (
) )
def get_movie_guids(movie):
if "ProviderIds" in movie:
logger(
f"Jellyfin: {movie['Name']} {movie['ProviderIds']} {movie['MediaSources']}",
3,
)
else:
logger(
f"Jellyfin: {movie['Name']} {movie['MediaSources']['Path']}",
3,
)
# Create a dictionary for the movie with its title
movie_guids = {"title": movie["Name"]}
# If the movie has provider IDs, add them to the dictionary
if "ProviderIds" in movie:
movie_guids.update({k.lower(): v for k, v in movie["ProviderIds"].items()})
# If the movie has media sources, add them to the dictionary
if "MediaSources" in movie:
movie_guids["locations"] = tuple(
[x["Path"].split("/")[-1] for x in movie["MediaSources"]]
)
movie_guids["status"] = {
"completed": movie["UserData"]["Played"],
# Convert ticks to milliseconds to match Plex
"time": floor(movie["UserData"]["PlaybackPositionTicks"] / 10000),
}
return movie_guids
def get_episode_guids(episode):
# Create a dictionary for the episode with its provider IDs and media sources
episode_dict = {k.lower(): v for k, v in episode["ProviderIds"].items()}
episode_dict["title"] = episode["Name"]
episode_dict["locations"] = tuple(
[x["Path"].split("/")[-1] for x in episode["MediaSources"]]
)
episode_dict["status"] = {
"completed": episode["UserData"]["Played"],
"time": floor(episode["UserData"]["PlaybackPositionTicks"] / 10000),
}
return episode_dict
class Jellyfin: class Jellyfin:
def __init__(self, baseurl, token): def __init__(self, baseurl, token):
self.baseurl = baseurl self.baseurl = baseurl
@ -114,48 +162,43 @@ class Jellyfin:
session, session,
) )
in_progress = await self.query(
f"/Users/{user_id}/Items"
+ f"?ParentId={library_id}&Filters=IsResumable&IncludeItemTypes=Movie&Recursive=True&Fields=ItemCounts,ProviderIds,MediaSources",
"get",
session,
)
for movie in watched["Items"]: for movie in watched["Items"]:
# Check if the movie has been played if "MediaSources" in movie and movie["MediaSources"] != {}:
if (
movie["UserData"]["Played"] is True
and "MediaSources" in movie
and movie["MediaSources"] is not {}
):
logger( logger(
f"Jellyfin: Adding {movie['Name']} to {user_name} watched list", f"Jellyfin: Adding {movie['Name']} to {user_name} watched list",
3, 3,
) )
if "ProviderIds" in movie:
logger(
f"Jellyfin: {movie['Name']} {movie['ProviderIds']} {movie['MediaSources']}",
3,
)
else:
logger(
f"Jellyfin: {movie['Name']} {movie['MediaSources']['Path']}",
3,
)
# Create a dictionary for the movie with its title # Get the movie's GUIDs
movie_guids = {"title": movie["Name"]} movie_guids = get_movie_guids(movie)
# If the movie has provider IDs, add them to the dictionary # Append the movie dictionary to the list for the given user and library
if "ProviderIds" in movie: user_watched[user_name][library_title].append(movie_guids)
movie_guids.update( logger(
{ f"Jellyfin: Added {movie_guids} to {user_name} watched list",
k.lower(): v 3,
for k, v in movie["ProviderIds"].items() )
}
)
# If the movie has media sources, add them to the dictionary # Get all partially watched movies greater than 1 minute
if "MediaSources" in movie: for movie in in_progress["Items"]:
movie_guids["locations"] = tuple( if "MediaSources" in movie and movie["MediaSources"] != {}:
[ if movie["UserData"]["PlaybackPositionTicks"] < 600000000:
x["Path"].split("/")[-1] continue
for x in movie["MediaSources"]
] logger(
) f"Jellyfin: Adding {movie['Name']} to {user_name} watched list",
3,
)
# Get the movie's GUIDs
movie_guids = get_movie_guids(movie)
# Append the movie dictionary to the list for the given user and library # Append the movie dictionary to the list for the given user and library
user_watched[user_name][library_title].append(movie_guids) user_watched[user_name][library_title].append(movie_guids)
@ -244,16 +287,26 @@ class Jellyfin:
season_identifiers = dict(seasons["Identifiers"]) season_identifiers = dict(seasons["Identifiers"])
season_identifiers["season_id"] = season["Id"] season_identifiers["season_id"] = season["Id"]
season_identifiers["season_name"] = season["Name"] season_identifiers["season_name"] = season["Name"]
episode_task = asyncio.ensure_future( watched_task = asyncio.ensure_future(
self.query( self.query(
f"/Shows/{season_identifiers['show_id']}/Episodes" f"/Shows/{season_identifiers['show_id']}/Episodes"
+ f"?seasonId={season['Id']}&userId={user_id}&isPlaceHolder=false&isPlayed=true&Fields=ProviderIds,MediaSources", + f"?seasonId={season['Id']}&userId={user_id}&isPlaceHolder=false&Filters=IsPlayed&Fields=ProviderIds,MediaSources",
"get", "get",
session, session,
frozenset(season_identifiers.items()), frozenset(season_identifiers.items()),
) )
) )
episodes_tasks.append(episode_task) in_progress_task = asyncio.ensure_future(
self.query(
f"/Shows/{season_identifiers['show_id']}/Episodes"
+ f"?seasonId={season['Id']}&userId={user_id}&isPlaceHolder=false&Filters=IsResumable&Fields=ProviderIds,MediaSources",
"get",
session,
frozenset(season_identifiers.items()),
)
)
episodes_tasks.append(watched_task)
episodes_tasks.append(in_progress_task)
# Retrieve the episodes for each watched season # Retrieve the episodes for each watched season
watched_episodes = await asyncio.gather(*episodes_tasks) watched_episodes = await asyncio.gather(*episodes_tasks)
@ -268,24 +321,19 @@ class Jellyfin:
season_dict["Episodes"] = [] season_dict["Episodes"] = []
for episode in episodes["Items"]: for episode in episodes["Items"]:
if ( if (
episode["UserData"]["Played"] is True "MediaSources" in episode
and "MediaSources" in episode
and episode["MediaSources"] is not {} and episode["MediaSources"] is not {}
): ):
# Create a dictionary for the episode with its provider IDs and media sources # If watched or watched more than a minute
episode_dict = { if (
k.lower(): v episode["UserData"]["Played"] == True
for k, v in episode["ProviderIds"].items() or episode["UserData"]["PlaybackPositionTicks"]
} > 600000000
episode_dict["title"] = episode["Name"] ):
episode_dict["locations"] = tuple( episode_dict = get_episode_guids(episode)
[ # Add the episode dictionary to the season's list of episodes
x["Path"].split("/")[-1] season_dict["Episodes"].append(episode_dict)
for x in episode["MediaSources"]
]
)
# Add the episode dictionary to the season's list of episodes
season_dict["Episodes"].append(episode_dict)
# Add the season dictionary to the show's list of seasons # Add the season dictionary to the show's list of seasons
if ( if (
season_dict["Identifiers"]["show_guids"] season_dict["Identifiers"]["show_guids"]
@ -498,18 +546,30 @@ class Jellyfin:
session, session,
) )
for jellyfin_video in jellyfin_search["Items"]: for jellyfin_video in jellyfin_search["Items"]:
movie_found = False movie_status = None
if "MediaSources" in jellyfin_video: if "MediaSources" in jellyfin_video:
for movie_location in jellyfin_video["MediaSources"]: for movie_location in jellyfin_video["MediaSources"]:
if ( if (
movie_location["Path"].split("/")[-1] contains_nested(
in videos_movies_ids["locations"] movie_location["Path"].split("/")[-1],
videos_movies_ids["locations"],
)
is not None
): ):
movie_found = True for video in videos:
if (
contains_nested(
movie_location["Path"].split("/")[-1],
video["locations"],
)
is not None
):
movie_status = video["status"]
break
break break
if not movie_found: if not movie_status:
for ( for (
movie_provider_source, movie_provider_source,
movie_provider_id, movie_provider_id,
@ -521,21 +581,37 @@ class Jellyfin:
movie_provider_source.lower() movie_provider_source.lower()
] ]
): ):
movie_found = True for video in videos:
if (
movie_provider_id.lower()
in video[movie_provider_source.lower()]
):
movie_status = video["status"]
break
break break
if movie_found: if movie_status:
jellyfin_video_id = jellyfin_video["Id"] jellyfin_video_id = jellyfin_video["Id"]
msg = f"{jellyfin_video['Name']} as watched for {user_name} in {library} for Jellyfin" if movie_status["completed"]:
if not dryrun: msg = f"{jellyfin_video['Name']} as watched for {user_name} in {library} for Jellyfin"
logger(f"Marking {msg}", 0) if not dryrun:
await self.query( logger(f"Marking {msg}", 0)
f"/Users/{user_id}/PlayedItems/{jellyfin_video_id}", await self.query(
"post", f"/Users/{user_id}/PlayedItems/{jellyfin_video_id}",
session, "post",
) session,
)
else:
logger(f"Dryrun {msg}", 0)
else: else:
logger(f"Dryrun {msg}", 0) # TODO add support for partially watched movies
msg = f"{jellyfin_video['Name']} as partially watched for {floor(movie_status['time'] / 60_000)} minutes for {user_name} in {library} for Jellyfin"
if not dryrun:
pass
# logger(f"Marked {msg}", 0)
else:
pass
# logger(f"Dryrun {msg}", 0)
else: else:
logger( logger(
f"Jellyfin: Skipping movie {jellyfin_video['Name']} as it is not in mark list for {user_name}", f"Jellyfin: Skipping movie {jellyfin_video['Name']} as it is not in mark list for {user_name}",
@ -558,10 +634,27 @@ class Jellyfin:
if "Path" in jellyfin_show: if "Path" in jellyfin_show:
if ( if (
jellyfin_show["Path"].split("/")[-1] contains_nested(
in videos_shows_ids["locations"] jellyfin_show["Path"].split("/")[-1],
videos_shows_ids["locations"],
)
is not None
): ):
show_found = True show_found = True
episode_videos = []
for show, seasons in videos.items():
show = {k: v for k, v in show}
if (
contains_nested(
jellyfin_show["Path"].split("/")[-1],
show["locations"],
)
is not None
):
for season in seasons.values():
for episode in season:
episode_videos.append(episode)
if not show_found: if not show_found:
for show_provider_source, show_provider_id in jellyfin_show[ for show_provider_source, show_provider_id in jellyfin_show[
@ -575,7 +668,16 @@ class Jellyfin:
] ]
): ):
show_found = True show_found = True
break episode_videos = []
for show, seasons in videos.items():
show = {k: v for k, v in show}
if (
show_provider_id.lower()
in show[show_provider_source.lower()]
):
for season in seasons.values():
for episode in season:
episode_videos.append(episode)
if show_found: if show_found:
logger( logger(
@ -591,20 +693,34 @@ class Jellyfin:
) )
for jellyfin_episode in jellyfin_episodes["Items"]: for jellyfin_episode in jellyfin_episodes["Items"]:
episode_found = False episode_status = None
if "MediaSources" in jellyfin_episode: if "MediaSources" in jellyfin_episode:
for episode_location in jellyfin_episode[ for episode_location in jellyfin_episode[
"MediaSources" "MediaSources"
]: ]:
if ( if (
episode_location["Path"].split("/")[-1] contains_nested(
in videos_episodes_ids["locations"] episode_location["Path"].split("/")[-1],
videos_episodes_ids["locations"],
)
is not None
): ):
episode_found = True for episode in episode_videos:
if (
contains_nested(
episode_location["Path"].split(
"/"
)[-1],
episode["locations"],
)
is not None
):
episode_status = episode["status"]
break
break break
if not episode_found: if not episode_status:
for ( for (
episode_provider_source, episode_provider_source,
episode_provider_id, episode_provider_id,
@ -619,24 +735,48 @@ class Jellyfin:
episode_provider_source.lower() episode_provider_source.lower()
] ]
): ):
episode_found = True for episode in episode_videos:
if (
episode_provider_id.lower()
in episode[
episode_provider_source.lower()
]
):
episode_status = episode[
"status"
]
break
break break
if episode_found: if episode_status:
jellyfin_episode_id = jellyfin_episode["Id"] if episode_status["completed"]:
msg = ( jellyfin_episode_id = jellyfin_episode["Id"]
f"{jellyfin_episode['SeriesName']} {jellyfin_episode['SeasonName']} Episode {jellyfin_episode['Name']}" msg = (
+ f" as watched for {user_name} in {library} for Jellyfin" f"{jellyfin_episode['SeriesName']} {jellyfin_episode['SeasonName']} Episode {jellyfin_episode['IndexNumber']} {jellyfin_episode['Name']}"
) + f" as watched for {user_name} in {library} for Jellyfin"
if not dryrun:
logger(f"Marked {msg}", 0)
await self.query(
f"/Users/{user_id}/PlayedItems/{jellyfin_episode_id}",
"post",
session,
) )
if not dryrun:
logger(f"Marked {msg}", 0)
await self.query(
f"/Users/{user_id}/PlayedItems/{jellyfin_episode_id}",
"post",
session,
)
else:
logger(f"Dryrun {msg}", 0)
else: else:
logger(f"Dryrun {msg}", 0) # TODO add support for partially watched episodes
jellyfin_episode_id = jellyfin_episode["Id"]
msg = (
f"{jellyfin_episode['SeriesName']} {jellyfin_episode['SeasonName']} Episode {jellyfin_episode['IndexNumber']} {jellyfin_episode['Name']}"
+ f" as partially watched for {floor(episode_status['time'] / 60_000)} minutes for {user_name} in {library} for Jellyfin"
)
if not dryrun:
pass
# logger(f"Marked {msg}", 0)
else:
pass
# logger(f"Dryrun {msg}", 0)
else: else:
logger( logger(
f"Jellyfin: Skipping episode {jellyfin_episode['Name']} as it is not in mark list for {user_name}", f"Jellyfin: Skipping episode {jellyfin_episode['Name']} as it is not in mark list for {user_name}",
@ -663,6 +803,7 @@ class Jellyfin:
f"Jellyfin: Error updating watched for {user_name} in library {library}, {e}", f"Jellyfin: Error updating watched for {user_name} in library {library}, {e}",
2, 2,
) )
logger(traceback.format_exc(), 2)
raise Exception(e) raise Exception(e)
async def update_watched( async def update_watched(

76
src/library.py
View File

@ -132,6 +132,8 @@ def check_whitelist_logic(
def show_title_dict(user_list: dict): def show_title_dict(user_list: dict):
try: try:
show_output_dict = {} show_output_dict = {}
show_output_dict["locations"] = []
show_counter = 0 # Initialize a counter for the current show position
show_output_keys = user_list.keys() show_output_keys = user_list.keys()
show_output_keys = [dict(x) for x in list(show_output_keys)] show_output_keys = [dict(x) for x in list(show_output_keys)]
@ -141,15 +143,19 @@ def show_title_dict(user_list: dict):
if provider_key.lower() == "title": if provider_key.lower() == "title":
continue continue
if provider_key.lower() not in show_output_dict: if provider_key.lower() not in show_output_dict:
show_output_dict[provider_key.lower()] = [] show_output_dict[provider_key.lower()] = [None] * show_counter
if provider_key.lower() == "locations": if provider_key.lower() == "locations":
for show_location in provider_value: show_output_dict[provider_key.lower()].append(provider_value)
show_output_dict[provider_key.lower()].append(show_location)
else: else:
show_output_dict[provider_key.lower()].append( show_output_dict[provider_key.lower()].append(
provider_value.lower() provider_value.lower()
) )
show_counter += 1
for key in show_output_dict:
if len(show_output_dict[key]) < show_counter:
show_output_dict[key].append(None)
return show_output_dict return show_output_dict
except Exception: except Exception:
logger("Generating show_output_dict failed, skipping", 1) logger("Generating show_output_dict failed, skipping", 1)
@ -159,22 +165,52 @@ def show_title_dict(user_list: dict):
def episode_title_dict(user_list: dict): def episode_title_dict(user_list: dict):
try: try:
episode_output_dict = {} episode_output_dict = {}
episode_output_dict["completed"] = []
episode_output_dict["time"] = []
episode_output_dict["locations"] = []
episode_counter = 0 # Initialize a counter for the current episode position
# Iterate through the shows, seasons, and episodes in user_list
for show in user_list: for show in user_list:
for season in user_list[show]: for season in user_list[show]:
for episode in user_list[show][season]: for episode in user_list[show][season]:
# Iterate through the keys and values in each episode
for episode_key, episode_value in episode.items(): for episode_key, episode_value in episode.items():
if episode_key.lower() not in episode_output_dict: # If the key is not "status", add the key to episode_output_dict if it doesn't exist
episode_output_dict[episode_key.lower()] = [] if episode_key != "status":
if episode_key.lower() not in episode_output_dict:
# Initialize the list with None values up to the current episode position
episode_output_dict[episode_key.lower()] = [
None
] * episode_counter
# If the key is "locations", append each location to the list
if episode_key == "locations": if episode_key == "locations":
for episode_location in episode_value: episode_output_dict[episode_key.lower()].append(
episode_output_dict[episode_key.lower()].append( episode_value
episode_location )
)
# If the key is "status", append the "completed" and "time" values
elif episode_key == "status":
episode_output_dict["completed"].append(
episode_value["completed"]
)
episode_output_dict["time"].append(episode_value["time"])
# For other keys, append the value to the list
else: else:
episode_output_dict[episode_key.lower()].append( episode_output_dict[episode_key.lower()].append(
episode_value.lower() episode_value.lower()
) )
# Increment the episode_counter
episode_counter += 1
# Extend the lists in episode_output_dict with None values to match the current episode_counter
for key in episode_output_dict:
if len(episode_output_dict[key]) < episode_counter:
episode_output_dict[key].append(None)
return episode_output_dict return episode_output_dict
except Exception: except Exception:
logger("Generating episode_output_dict failed, skipping", 1) logger("Generating episode_output_dict failed, skipping", 1)
@ -184,16 +220,30 @@ def episode_title_dict(user_list: dict):
def movies_title_dict(user_list: dict): def movies_title_dict(user_list: dict):
try: try:
movies_output_dict = {} movies_output_dict = {}
movies_output_dict["completed"] = []
movies_output_dict["time"] = []
movies_output_dict["locations"] = []
movie_counter = 0 # Initialize a counter for the current movie position
for movie in user_list: for movie in user_list:
for movie_key, movie_value in movie.items(): for movie_key, movie_value in movie.items():
if movie_key.lower() not in movies_output_dict: if movie_key != "status":
movies_output_dict[movie_key.lower()] = [] if movie_key.lower() not in movies_output_dict:
movies_output_dict[movie_key.lower()] = []
if movie_key == "locations": if movie_key == "locations":
for movie_location in movie_value: movies_output_dict[movie_key.lower()].append(movie_value)
movies_output_dict[movie_key.lower()].append(movie_location) elif movie_key == "status":
movies_output_dict["completed"].append(movie_value["completed"])
movies_output_dict["time"].append(movie_value["time"])
else: else:
movies_output_dict[movie_key.lower()].append(movie_value.lower()) movies_output_dict[movie_key.lower()].append(movie_value.lower())
movie_counter += 1
for key in movies_output_dict:
if len(movies_output_dict[key]) < movie_counter:
movies_output_dict[key].append(None)
return movies_output_dict return movies_output_dict
except Exception: except Exception:
logger("Generating movies_output_dict failed, skipping", 1) logger("Generating movies_output_dict failed, skipping", 1)

7
src/main.py
View File

@ -365,6 +365,7 @@ def main_loop():
def main(): def main():
run_only_once = str_to_bool(os.getenv("RUN_ONLY_ONCE", "False"))
sleep_duration = float(os.getenv("SLEEP_DURATION", "3600")) sleep_duration = float(os.getenv("SLEEP_DURATION", "3600"))
times = [] times = []
while True: while True:
@ -377,6 +378,9 @@ def main():
if len(times) > 0: if len(times) > 0:
logger(f"Average time: {sum(times) / len(times)}", 0) logger(f"Average time: {sum(times) / len(times)}", 0)
if run_only_once:
break
logger(f"Looping in {sleep_duration}") logger(f"Looping in {sleep_duration}")
sleep(sleep_duration) sleep(sleep_duration)
@ -389,6 +393,9 @@ def main():
logger(traceback.format_exc(), 2) logger(traceback.format_exc(), 2)
if run_only_once:
break
logger(f"Retrying in {sleep_duration}", log_type=0) logger(f"Retrying in {sleep_duration}", log_type=0)
sleep(sleep_duration) sleep(sleep_duration)

261
src/plex.py
View File

@ -1,5 +1,6 @@
import re, requests, os, traceback import re, requests, os, traceback
from urllib3.poolmanager import PoolManager from urllib3.poolmanager import PoolManager
from math import floor
from plexapi.server import PlexServer from plexapi.server import PlexServer
from plexapi.myplex import MyPlexAccount from plexapi.myplex import MyPlexAccount
@ -8,6 +9,7 @@ from src.functions import (
logger, logger,
search_mapping, search_mapping,
future_thread_executor, future_thread_executor,
contains_nested,
) )
from src.library import ( from src.library import (
check_skip_logic, check_skip_logic,
@ -27,14 +29,70 @@ class HostNameIgnoringAdapter(requests.adapters.HTTPAdapter):
) )
def get_movie_guids(video, completed=True):
logger(f"Plex: {video.title} {video.guids} {video.locations}", 3)
movie_guids = {}
try:
for guid in video.guids:
# Extract source and id from guid.id
m = re.match(r"(.*)://(.*)", guid.id)
guid_source, guid_id = m.group(1).lower(), m.group(2)
movie_guids[guid_source] = guid_id
except Exception:
logger(f"Plex: Failed to get guids for {video.title}, Using location only", 1)
movie_guids["title"] = video.title
movie_guids["locations"] = tuple([x.split("/")[-1] for x in video.locations])
movie_guids["status"] = {
"completed": completed,
"time": video.viewOffset,
}
return movie_guids
def get_episode_guids(episode, show, completed=True):
episode_guids_temp = {}
try:
for guid in episode.guids:
# Extract after :// from guid.id
m = re.match(r"(.*)://(.*)", guid.id)
guid_source, guid_id = m.group(1).lower(), m.group(2)
episode_guids_temp[guid_source] = guid_id
except Exception:
logger(
f"Plex: Failed to get guids for {episode.title} in {show.title}, Using location only",
1,
)
episode_guids_temp["title"] = episode.title
episode_guids_temp["locations"] = tuple(
[x.split("/")[-1] for x in episode.locations]
)
episode_guids_temp["status"] = {
"completed": completed,
"time": episode.viewOffset,
}
return episode_guids_temp
def get_user_library_watched_show(show): def get_user_library_watched_show(show):
try: try:
show_guids = {} show_guids = {}
for show_guid in show.guids: try:
# Extract source and id from guid.id for show_guid in show.guids:
m = re.match(r"(.*)://(.*)", show_guid.id) # Extract source and id from guid.id
show_guid_source, show_guid_id = m.group(1).lower(), m.group(2) m = re.match(r"(.*)://(.*)", show_guid.id)
show_guids[show_guid_source] = show_guid_id show_guid_source, show_guid_id = m.group(1).lower(), m.group(2)
show_guids[show_guid_source] = show_guid_id
except Exception:
logger(
f"Plex: Failed to get guids for {show.title}, Using location only", 1
)
show_guids["title"] = show.title show_guids["title"] = show.title
show_guids["locations"] = tuple([x.split("/")[-1] for x in show.locations]) show_guids["locations"] = tuple([x.split("/")[-1] for x in show.locations])
@ -42,30 +100,23 @@ def get_user_library_watched_show(show):
# Get all watched episodes for show # Get all watched episodes for show
episode_guids = {} episode_guids = {}
watched_episodes = show.watched() watched = show.watched()
for episode in watched_episodes:
episode_guids_temp = {} for episode in show.episodes():
try: if episode in watched:
if len(episode.guids) > 0: if episode.parentTitle not in episode_guids:
for guid in episode.guids: episode_guids[episode.parentTitle] = []
# Extract after :// from guid.id
m = re.match(r"(.*)://(.*)", guid.id) episode_guids[episode.parentTitle].append(
guid_source, guid_id = m.group(1).lower(), m.group(2) get_episode_guids(episode, show, completed=True)
episode_guids_temp[guid_source] = guid_id
except Exception:
logger(
f"Plex: Failed to get guids for {episode.title} in {show.title}, Using location only",
1,
) )
elif episode.viewOffset > 0:
if episode.parentTitle not in episode_guids:
episode_guids[episode.parentTitle] = []
episode_guids_temp["locations"] = tuple( episode_guids[episode.parentTitle].append(
[x.split("/")[-1] for x in episode.locations] get_episode_guids(episode, show, completed=False)
) )
if episode.parentTitle not in episode_guids:
episode_guids[episode.parentTitle] = []
episode_guids[episode.parentTitle].append(episode_guids_temp)
return show_guids, episode_guids return show_guids, episode_guids
@ -89,32 +140,37 @@ def get_user_library_watched(user, user_plex, library):
if library.type == "movie": if library.type == "movie":
user_watched[user_name][library.title] = [] user_watched[user_name][library.title] = []
# Get all watched movies
for video in library_videos.search(unwatched=False): for video in library_videos.search(unwatched=False):
logger(f"Plex: Adding {video.title} to {user_name} watched list", 3) logger(f"Plex: Adding {video.title} to {user_name} watched list", 3)
logger(f"Plex: {video.title} {video.guids} {video.locations}", 3)
movie_guids = {} movie_guids = get_movie_guids(video, completed=True)
for guid in video.guids:
# Extract source and id from guid.id user_watched[user_name][library.title].append(movie_guids)
m = re.match(r"(.*)://(.*)", guid.id)
guid_source, guid_id = m.group(1).lower(), m.group(2) # Get all partially watched movies greater than 1 minute
movie_guids[guid_source] = guid_id for video in library_videos.search(inProgress=True):
if video.viewOffset < 60000:
movie_guids["title"] = video.title continue
movie_guids["locations"] = tuple(
[x.split("/")[-1] for x in video.locations] logger(f"Plex: Adding {video.title} to {user_name} watched list", 3)
)
movie_guids = get_movie_guids(video, completed=False)
user_watched[user_name][library.title].append(movie_guids) user_watched[user_name][library.title].append(movie_guids)
logger(f"Plex: Added {movie_guids} to {user_name} watched list", 3)
elif library.type == "show": elif library.type == "show":
user_watched[user_name][library.title] = {} user_watched[user_name][library.title] = {}
shows = library_videos.search(unwatched=False)
# Parallelize show processing # Parallelize show processing
args = [] args = []
for show in shows:
# Get all watched shows
for show in library_videos.search(unwatched=False):
args.append([get_user_library_watched_show, show])
# Get all partially watched shows
for show in library_videos.search(inProgress=True):
args.append([get_user_library_watched_show, show]) args.append([get_user_library_watched_show, show])
for show_guids, episode_guids in future_thread_executor( for show_guids, episode_guids in future_thread_executor(
@ -144,11 +200,26 @@ def get_user_library_watched(user, user_plex, library):
return {} return {}
def find_video(plex_search, video_ids): def find_video(plex_search, video_ids, videos=None):
try: try:
for location in plex_search.locations: for location in plex_search.locations:
if location.split("/")[-1] in video_ids["locations"]: if (
return True contains_nested(location.split("/")[-1], video_ids["locations"])
is not None
):
episode_videos = []
if videos:
for show, seasons in videos.items():
show = {k: v for k, v in show}
if (
contains_nested(location.split("/")[-1], show["locations"])
is not None
):
for season in seasons.values():
for episode in season:
episode_videos.append(episode)
return True, episode_videos
for guid in plex_search.guids: for guid in plex_search.guids:
guid_source = re.search(r"(.*)://", guid.id).group(1).lower() guid_source = re.search(r"(.*)://", guid.id).group(1).lower()
@ -157,11 +228,52 @@ def find_video(plex_search, video_ids):
# If show provider source and show provider id are in videos_shows_ids exactly, then the show is in the list # If show provider source and show provider id are in videos_shows_ids exactly, then the show is in the list
if guid_source in video_ids.keys(): if guid_source in video_ids.keys():
if guid_id in video_ids[guid_source]: if guid_id in video_ids[guid_source]:
return True episode_videos = []
if videos:
for show, seasons in videos.items():
show = {k: v for k, v in show}
if guid_source in show["ids"].keys():
if guid_id in show["ids"][guid_source]:
for season in seasons:
for episode in season:
episode_videos.append(episode)
return False return True, episode_videos
return False, []
except Exception: except Exception:
return False return False, []
def get_video_status(plex_search, video_ids, videos):
try:
for location in plex_search.locations:
if (
contains_nested(location.split("/")[-1], video_ids["locations"])
is not None
):
for video in videos:
if (
contains_nested(location.split("/")[-1], video["locations"])
is not None
):
return video["status"]
for guid in plex_search.guids:
guid_source = re.search(r"(.*)://", guid.id).group(1).lower()
guid_id = re.search(r"://(.*)", guid.id).group(1)
# If show provider source and show provider id are in videos_shows_ids exactly, then the show is in the list
if guid_source in video_ids.keys():
if guid_id in video_ids[guid_source]:
for video in videos:
if guid_source in video["ids"].keys():
if guid_id in video["ids"][guid_source]:
return video["status"]
return None
except Exception:
return None
def update_user_watched(user, user_plex, library, videos, dryrun): def update_user_watched(user, user_plex, library, videos, dryrun):
@ -180,13 +292,24 @@ def update_user_watched(user, user_plex, library, videos, dryrun):
library_videos = user_plex.library.section(library) library_videos = user_plex.library.section(library)
if videos_movies_ids: if videos_movies_ids:
for movies_search in library_videos.search(unwatched=True): for movies_search in library_videos.search(unwatched=True):
if find_video(movies_search, videos_movies_ids): video_status = get_video_status(
msg = f"{movies_search.title} as watched for {user.title} in {library} for Plex" movies_search, videos_movies_ids, videos
if not dryrun: )
logger(f"Marked {msg}", 0) if video_status:
movies_search.markWatched() if video_status["completed"]:
else: msg = f"{movies_search.title} as watched for {user.title} in {library} for Plex"
logger(f"Dryrun {msg}", 0) if not dryrun:
logger(f"Marked {msg}", 0)
movies_search.markWatched()
else:
logger(f"Dryrun {msg}", 0)
elif video_status["time"] > 60_000:
msg = f"{movies_search.title} as partially watched for {floor(video_status['time'] / 60_000)} minutes for {user.title} in {library} for Plex"
if not dryrun:
logger(f"Marked {msg}", 0)
movies_search.updateProgress(video_status["time"])
else:
logger(f"Dryrun {msg}", 0)
else: else:
logger( logger(
f"Plex: Skipping movie {movies_search.title} as it is not in mark list for {user.title}", f"Plex: Skipping movie {movies_search.title} as it is not in mark list for {user.title}",
@ -195,15 +318,29 @@ def update_user_watched(user, user_plex, library, videos, dryrun):
if videos_shows_ids and videos_episodes_ids: if videos_shows_ids and videos_episodes_ids:
for show_search in library_videos.search(unwatched=True): for show_search in library_videos.search(unwatched=True):
if find_video(show_search, videos_shows_ids): show_found, episode_videos = find_video(
show_search, videos_shows_ids, videos
)
if show_found:
for episode_search in show_search.episodes(): for episode_search in show_search.episodes():
if find_video(episode_search, videos_episodes_ids): video_status = get_video_status(
msg = f"{show_search.title} {episode_search.title} as watched for {user.title} in {library} for Plex" episode_search, videos_episodes_ids, episode_videos
if not dryrun: )
logger(f"Marked {msg}", 0) if video_status:
episode_search.markWatched() if video_status["completed"]:
msg = f"{show_search.title} {episode_search.title} as watched for {user.title} in {library} for Plex"
if not dryrun:
logger(f"Marked {msg}", 0)
episode_search.markWatched()
else:
logger(f"Dryrun {msg}", 0)
else: else:
logger(f"Dryrun {msg}", 0) msg = f"{show_search.title} {episode_search.title} as partially watched for {floor(video_status['time'] / 60_000)} minutes for {user.title} in {library} for Plex"
if not dryrun:
logger(f"Marked {msg}", 0)
episode_search.updateProgress(video_status["time"])
else:
logger(f"Dryrun {msg}", 0)
else: else:
logger( logger(
f"Plex: Skipping episode {episode_search.title} as it is not in mark list for {user.title}", f"Plex: Skipping episode {episode_search.title} as it is not in mark list for {user.title}",

120
src/watched.py
View File

@ -1,9 +1,6 @@
import copy import copy
from src.functions import ( from src.functions import logger, search_mapping, contains_nested
logger,
search_mapping,
)
from src.library import generate_library_guids_dict from src.library import generate_library_guids_dict
@ -29,6 +26,48 @@ def combine_watched_dicts(dicts: list):
return combined_dict return combined_dict
def check_remove_entry(video, library, video_index, library_watched_list_2):
if video_index is not None:
if (
library_watched_list_2["completed"][video_index]
== video["status"]["completed"]
) and (library_watched_list_2["time"][video_index] == video["status"]["time"]):
logger(
f"Removing {video['title']} from {library} due to exact match",
3,
)
return True
elif (
library_watched_list_2["completed"][video_index] == True
and video["status"]["completed"] == False
):
logger(
f"Removing {video['title']} from {library} due to being complete in one library and not the other",
3,
)
return True
elif (
library_watched_list_2["completed"][video_index] == False
and video["status"]["completed"] == False
) and (video["status"]["time"] < library_watched_list_2["time"][video_index]):
logger(
f"Removing {video['title']} from {library} due to more time watched in one library than the other",
3,
)
return True
elif (
library_watched_list_2["completed"][video_index] == True
and video["status"]["completed"] == True
):
logger(
f"Removing {video['title']} from {library} due to being complete in both libraries",
3,
)
return True
return False
def cleanup_watched( def cleanup_watched(
watched_list_1, watched_list_2, user_mapping=None, library_mapping=None watched_list_1, watched_list_2, user_mapping=None, library_mapping=None
): ):
@ -60,31 +99,37 @@ def cleanup_watched(
# Movies # Movies
if isinstance(watched_list_1[user_1][library_1], list): if isinstance(watched_list_1[user_1][library_1], list):
for movie in watched_list_1[user_1][library_1]: for movie in watched_list_1[user_1][library_1]:
if is_movie_in_dict(movie, movies_watched_list_2_keys_dict): movie_index = get_movie_index_in_dict(
logger(f"Removing {movie} from {library_1}", 3) movie, movies_watched_list_2_keys_dict
modified_watched_list_1[user_1][library_1].remove(movie) )
if movie_index is not None:
if check_remove_entry(
movie,
library_1,
movie_index,
movies_watched_list_2_keys_dict,
):
modified_watched_list_1[user_1][library_1].remove(movie)
# TV Shows # TV Shows
elif isinstance(watched_list_1[user_1][library_1], dict): elif isinstance(watched_list_1[user_1][library_1], dict):
for show_key_1 in watched_list_1[user_1][library_1].keys(): for show_key_1 in watched_list_1[user_1][library_1].keys():
show_key_dict = dict(show_key_1) show_key_dict = dict(show_key_1)
for season in watched_list_1[user_1][library_1][show_key_1]: for season in watched_list_1[user_1][library_1][show_key_1]:
for episode in watched_list_1[user_1][library_1][show_key_1][ for episode in watched_list_1[user_1][library_1][show_key_1][
season season
]: ]:
if is_episode_in_dict( episode_index = get_episode_index_in_dict(
episode, episode_watched_list_2_keys_dict episode, episode_watched_list_2_keys_dict
): )
if ( if episode_index is not None:
episode if check_remove_entry(
in modified_watched_list_1[user_1][library_1][ episode,
show_key_1 library_1,
][season] episode_index,
episode_watched_list_2_keys_dict,
): ):
logger(
f"Removing {episode} from {show_key_dict['title']}",
3,
)
modified_watched_list_1[user_1][library_1][ modified_watched_list_1[user_1][library_1][
show_key_1 show_key_1
][season].remove(episode) ][season].remove(episode)
@ -148,7 +193,7 @@ def get_other(watched_list, object_1, object_2):
return None return None
def is_movie_in_dict(movie, movies_watched_list_2_keys_dict): def get_movie_index_in_dict(movie, movies_watched_list_2_keys_dict):
# Iterate through the keys and values of the movie dictionary # Iterate through the keys and values of the movie dictionary
for movie_key, movie_value in movie.items(): for movie_key, movie_value in movie.items():
# If the key is "locations", check if the "locations" key is present in the movies_watched_list_2_keys_dict dictionary # If the key is "locations", check if the "locations" key is present in the movies_watched_list_2_keys_dict dictionary
@ -156,37 +201,40 @@ def is_movie_in_dict(movie, movies_watched_list_2_keys_dict):
if "locations" in movies_watched_list_2_keys_dict.keys(): if "locations" in movies_watched_list_2_keys_dict.keys():
# Iterate through the locations in the movie dictionary # Iterate through the locations in the movie dictionary
for location in movie_value: for location in movie_value:
# If the location is in the movies_watched_list_2_keys_dict dictionary, return True # If the location is in the movies_watched_list_2_keys_dict dictionary, return index of the key
if location in movies_watched_list_2_keys_dict["locations"]: return contains_nested(
return True location, movies_watched_list_2_keys_dict["locations"]
)
# If the key is not "locations", check if the movie_key is present in the movies_watched_list_2_keys_dict dictionary # If the key is not "locations", check if the movie_key is present in the movies_watched_list_2_keys_dict dictionary
else: else:
if movie_key in movies_watched_list_2_keys_dict.keys(): if movie_key in movies_watched_list_2_keys_dict.keys():
# If the movie_value is in the movies_watched_list_2_keys_dict dictionary, return True # If the movie_value is in the movies_watched_list_2_keys_dict dictionary, return True
if movie_value in movies_watched_list_2_keys_dict[movie_key]: if movie_value in movies_watched_list_2_keys_dict[movie_key]:
return True return movies_watched_list_2_keys_dict[movie_key].index(movie_value)
# If the loop completes without finding a match, return False # If the loop completes without finding a match, return False
return False return None
def is_episode_in_dict(episode, episode_watched_list_2_keys_dict): def get_episode_index_in_dict(episode, episode_watched_list_2_keys_dict):
# Iterate through the keys and values of the episode dictionary # Iterate through the keys and values of the episode dictionary
for episode_key, episode_value in episode.items(): for episode_key, episode_value in episode.items():
# If the key is "locations", check if the "locations" key is present in the episode_watched_list_2_keys_dict dictionary if episode_key in episode_watched_list_2_keys_dict.keys():
if episode_key == "locations": if episode_key == "locations":
if "locations" in episode_watched_list_2_keys_dict.keys():
# Iterate through the locations in the episode dictionary # Iterate through the locations in the episode dictionary
for location in episode_value: for location in episode_value:
# If the location is in the episode_watched_list_2_keys_dict dictionary, return True # If the location is in the episode_watched_list_2_keys_dict dictionary, return index of the key
if location in episode_watched_list_2_keys_dict["locations"]: return contains_nested(
return True location, episode_watched_list_2_keys_dict["locations"]
# If the key is not "locations", check if the episode_key is present in the episode_watched_list_2_keys_dict dictionary )
else:
if episode_key in episode_watched_list_2_keys_dict.keys(): else:
# If the episode_value is in the episode_watched_list_2_keys_dict dictionary, return True # If the episode_value is in the episode_watched_list_2_keys_dict dictionary, return True
if episode_value in episode_watched_list_2_keys_dict[episode_key]: if episode_value in episode_watched_list_2_keys_dict[episode_key]:
return True return episode_watched_list_2_keys_dict[episode_key].index(
episode_value
)
# If the loop completes without finding a match, return False # If the loop completes without finding a match, return False
return False return None

35
test/test_library.py
View File

@ -49,8 +49,11 @@ show_list = {
"tmdb": "2181581", "tmdb": "2181581",
"tvdb": "8444132", "tvdb": "8444132",
"locations": ( "locations": (
"The Last of Us - S01E01 - When You're Lost in the Darkness WEBDL-1080p.mkv", (
"The Last of Us - S01E01 - When You're Lost in the Darkness WEBDL-1080p.mkv",
)
), ),
"status": {"completed": True, "time": 0},
} }
] ]
} }
@ -60,29 +63,41 @@ movie_list = [
"title": "Coco", "title": "Coco",
"imdb": "tt2380307", "imdb": "tt2380307",
"tmdb": "354912", "tmdb": "354912",
"locations": ("Coco (2017) Remux-2160p.mkv", "Coco (2017) Remux-1080p.mkv"), "locations": [("Coco (2017) Remux-2160p.mkv", "Coco (2017) Remux-1080p.mkv")],
"status": {"completed": True, "time": 0},
} }
] ]
show_titles = { show_titles = {
"imdb": ["tt3581920"], "imdb": ["tt3581920"],
"locations": ["The Last of Us"], "locations": [("The Last of Us",)],
"tmdb": ["100088"], "tmdb": ["100088"],
"tvdb": ["392256"], "tvdb": ["392256"],
} }
episode_titles = { episode_titles = {
"imdb": ["tt11957006"], "imdb": ["tt11957006"],
"locations": [ "locations": [
"The Last of Us - S01E01 - When You're Lost in the Darkness WEBDL-1080p.mkv" ("The Last of Us - S01E01 - When You're Lost in the Darkness WEBDL-1080p.mkv",)
], ],
"tmdb": ["2181581"], "tmdb": ["2181581"],
"tvdb": ["8444132"], "tvdb": ["8444132"],
"completed": [True],
"time": [0],
} }
movie_titles = { movie_titles = {
"imdb": ["tt2380307"], "imdb": ["tt2380307"],
"locations": ["Coco (2017) Remux-2160p.mkv", "Coco (2017) Remux-1080p.mkv"], "locations": [
[
(
"Coco (2017) Remux-2160p.mkv",
"Coco (2017) Remux-1080p.mkv",
)
]
],
"title": ["coco"], "title": ["coco"],
"tmdb": ["354912"], "tmdb": ["354912"],
"completed": [True],
"time": [0],
} }
@ -133,7 +148,7 @@ def test_check_skip_logic():
library_mapping, library_mapping,
) )
assert skip_reason == None assert skip_reason is None
def test_check_blacklist_logic(): def test_check_blacklist_logic():
@ -182,7 +197,7 @@ def test_check_blacklist_logic():
library_other, library_other,
) )
assert skip_reason == None assert skip_reason is None
library_title = "Movies" library_title = "Movies"
library_type = "movies" library_type = "movies"
@ -195,7 +210,7 @@ def test_check_blacklist_logic():
library_other, library_other,
) )
assert skip_reason == None assert skip_reason is None
def test_check_whitelist_logic(): def test_check_whitelist_logic():
@ -244,7 +259,7 @@ def test_check_whitelist_logic():
library_other, library_other,
) )
assert skip_reason == None assert skip_reason is None
library_title = "Movies" library_title = "Movies"
library_type = "movies" library_type = "movies"
@ -257,7 +272,7 @@ def test_check_whitelist_logic():
library_other, library_other,
) )
assert skip_reason == None assert skip_reason is None
def test_show_title_dict(): def test_show_title_dict():

261
test/test_watched.py
View File

@ -30,42 +30,43 @@ tv_shows_watched_list_1 = {
"imdb": "tt0550489", "imdb": "tt0550489",
"tmdb": "282843", "tmdb": "282843",
"tvdb": "176357", "tvdb": "176357",
"title": "Extreme Aggressor",
"locations": ( "locations": (
"Criminal Minds S01E01 Extreme Aggressor WEBDL-720p.mkv", "Criminal Minds S01E01 Extreme Aggressor WEBDL-720p.mkv",
), ),
"status": {"completed": True, "time": 0},
}, },
{ {
"imdb": "tt0550487", "imdb": "tt0550487",
"tmdb": "282861", "tmdb": "282861",
"tvdb": "300385", "tvdb": "300385",
"title": "Compulsion",
"locations": ("Criminal Minds S01E02 Compulsion WEBDL-720p.mkv",), "locations": ("Criminal Minds S01E02 Compulsion WEBDL-720p.mkv",),
"status": {"completed": True, "time": 0},
}, },
] ]
}, },
frozenset({("title", "Test"), ("locations", ("Test",))}): { frozenset({("title", "Test"), ("locations", ("Test",))}): {
"Season 1": [ "Season 1": [
{"locations": ("Test S01E01.mkv",)}, {
{"locations": ("Test S01E02.mkv",)}, "title": "S01E01",
"locations": ("Test S01E01.mkv",),
"status": {"completed": True, "time": 0},
},
{
"title": "S01E02",
"locations": ("Test S01E02.mkv",),
"status": {"completed": True, "time": 0},
},
{
"title": "S01E04",
"locations": ("Test S01E04.mkv",),
"status": {"completed": False, "time": 5},
},
] ]
}, },
} }
movies_watched_list_1 = [
{
"imdb": "tt2380307",
"tmdb": "354912",
"title": "Coco",
"locations": ("Coco (2017) Remux-1080p.mkv",),
},
{
"tmdbcollection": "448150",
"imdb": "tt1431045",
"tmdb": "293660",
"title": "Deadpool",
"locations": ("Deadpool (2016) Remux-1080p.mkv",),
},
]
tv_shows_watched_list_2 = { tv_shows_watched_list_2 = {
frozenset( frozenset(
{ {
@ -81,32 +82,146 @@ tv_shows_watched_list_2 = {
"imdb": "tt0550487", "imdb": "tt0550487",
"tmdb": "282861", "tmdb": "282861",
"tvdb": "300385", "tvdb": "300385",
"title": "Compulsion",
"locations": ("Criminal Minds S01E02 Compulsion WEBDL-720p.mkv",), "locations": ("Criminal Minds S01E02 Compulsion WEBDL-720p.mkv",),
"status": {"completed": True, "time": 0},
}, },
{ {
"imdb": "tt0550498", "imdb": "tt0550498",
"tmdb": "282865", "tmdb": "282865",
"tvdb": "300474", "tvdb": "300474",
"title": "Won't Get Fooled Again",
"locations": ( "locations": (
"Criminal Minds S01E03 Won't Get Fooled Again WEBDL-720p.mkv", "Criminal Minds S01E03 Won't Get Fooled Again WEBDL-720p.mkv",
), ),
"status": {"completed": True, "time": 0},
}, },
] ]
}, },
frozenset({("title", "Test"), ("locations", ("Test",))}): { frozenset({("title", "Test"), ("locations", ("Test",))}): {
"Season 1": [ "Season 1": [
{"locations": ("Test S01E02.mkv",)}, {
{"locations": ("Test S01E03.mkv",)}, "title": "S01E02",
"locations": ("Test S01E02.mkv",),
"status": {"completed": False, "time": 10},
},
{
"title": "S01E03",
"locations": ("Test S01E03.mkv",),
"status": {"completed": True, "time": 0},
},
{
"title": "S01E04",
"locations": ("Test S01E04.mkv",),
"status": {"completed": False, "time": 10},
},
] ]
}, },
} }
expected_tv_show_watched_list_1 = {
frozenset(
{
("tvdb", "75710"),
("title", "Criminal Minds"),
("imdb", "tt0452046"),
("locations", ("Criminal Minds",)),
("tmdb", "4057"),
}
): {
"Season 1": [
{
"imdb": "tt0550489",
"tmdb": "282843",
"tvdb": "176357",
"title": "Extreme Aggressor",
"locations": (
"Criminal Minds S01E01 Extreme Aggressor WEBDL-720p.mkv",
),
"status": {"completed": True, "time": 0},
}
]
},
frozenset({("title", "Test"), ("locations", ("Test",))}): {
"Season 1": [
{
"title": "S01E01",
"locations": ("Test S01E01.mkv",),
"status": {"completed": True, "time": 0},
},
{
"title": "S01E02",
"locations": ("Test S01E02.mkv",),
"status": {"completed": True, "time": 0},
},
]
},
}
expected_tv_show_watched_list_2 = {
frozenset(
{
("tvdb", "75710"),
("title", "Criminal Minds"),
("imdb", "tt0452046"),
("locations", ("Criminal Minds",)),
("tmdb", "4057"),
}
): {
"Season 1": [
{
"imdb": "tt0550498",
"tmdb": "282865",
"tvdb": "300474",
"title": "Won't Get Fooled Again",
"locations": (
"Criminal Minds S01E03 Won't Get Fooled Again WEBDL-720p.mkv",
),
"status": {"completed": True, "time": 0},
}
]
},
frozenset({("title", "Test"), ("locations", ("Test",))}): {
"Season 1": [
{
"title": "S01E03",
"locations": ("Test S01E03.mkv",),
"status": {"completed": True, "time": 0},
},
{
"title": "S01E04",
"locations": ("Test S01E04.mkv",),
"status": {"completed": False, "time": 10},
},
]
},
}
movies_watched_list_1 = [
{
"imdb": "tt2380307",
"tmdb": "354912",
"title": "Coco",
"locations": ("Coco (2017) Remux-1080p.mkv",),
"status": {"completed": True, "time": 0},
},
{
"tmdbcollection": "448150",
"imdb": "tt1431045",
"tmdb": "293660",
"title": "Deadpool",
"locations": ("Deadpool (2016) Remux-1080p.mkv",),
"status": {"completed": True, "time": 0},
},
]
movies_watched_list_2 = [ movies_watched_list_2 = [
{ {
"imdb": "tt2380307", "imdb": "tt2380307",
"tmdb": "354912", "tmdb": "354912",
"title": "Coco", "title": "Coco",
"locations": ("Coco (2017) Remux-1080p.mkv",), "locations": ("Coco (2017) Remux-1080p.mkv",),
"status": {"completed": True, "time": 0},
}, },
{ {
"imdb": "tt0384793", "imdb": "tt0384793",
@ -114,9 +229,33 @@ movies_watched_list_2 = [
"tvdb": "9103", "tvdb": "9103",
"title": "Accepted", "title": "Accepted",
"locations": ("Accepted (2006) Remux-1080p.mkv",), "locations": ("Accepted (2006) Remux-1080p.mkv",),
"status": {"completed": True, "time": 0},
}, },
] ]
expected_movie_watched_list_1 = [
{
"tmdbcollection": "448150",
"imdb": "tt1431045",
"tmdb": "293660",
"title": "Deadpool",
"locations": ("Deadpool (2016) Remux-1080p.mkv",),
"status": {"completed": True, "time": 0},
}
]
expected_movie_watched_list_2 = [
{
"imdb": "tt0384793",
"tmdb": "9788",
"tvdb": "9103",
"title": "Accepted",
"locations": ("Accepted (2006) Remux-1080p.mkv",),
"status": {"completed": True, "time": 0},
}
]
# Test to see if objects get deleted all the way up to the root. # Test to see if objects get deleted all the way up to the root.
tv_shows_2_watched_list_1 = { tv_shows_2_watched_list_1 = {
frozenset( frozenset(
@ -133,86 +272,16 @@ tv_shows_2_watched_list_1 = {
"imdb": "tt0550489", "imdb": "tt0550489",
"tmdb": "282843", "tmdb": "282843",
"tvdb": "176357", "tvdb": "176357",
"title": "Extreme Aggressor",
"locations": ( "locations": (
"Criminal Minds S01E01 Extreme Aggressor WEBDL-720p.mkv", "Criminal Minds S01E01 Extreme Aggressor WEBDL-720p.mkv",
), ),
"status": {"completed": True, "time": 0},
}, },
] ]
} }
} }
expected_tv_show_watched_list_1 = {
frozenset(
{
("tvdb", "75710"),
("title", "Criminal Minds"),
("imdb", "tt0452046"),
("locations", ("Criminal Minds",)),
("tmdb", "4057"),
}
): {
"Season 1": [
{
"imdb": "tt0550489",
"tmdb": "282843",
"tvdb": "176357",
"locations": (
"Criminal Minds S01E01 Extreme Aggressor WEBDL-720p.mkv",
),
}
]
},
frozenset({("title", "Test"), ("locations", ("Test",))}): {
"Season 1": [{"locations": ("Test S01E01.mkv",)}]
},
}
expected_movie_watched_list_1 = [
{
"tmdbcollection": "448150",
"imdb": "tt1431045",
"tmdb": "293660",
"title": "Deadpool",
"locations": ("Deadpool (2016) Remux-1080p.mkv",),
}
]
expected_tv_show_watched_list_2 = {
frozenset(
{
("tvdb", "75710"),
("title", "Criminal Minds"),
("imdb", "tt0452046"),
("locations", ("Criminal Minds",)),
("tmdb", "4057"),
}
): {
"Season 1": [
{
"imdb": "tt0550498",
"tmdb": "282865",
"tvdb": "300474",
"locations": (
"Criminal Minds S01E03 Won't Get Fooled Again WEBDL-720p.mkv",
),
}
]
},
frozenset({("title", "Test"), ("locations", ("Test",))}): {
"Season 1": [{"locations": ("Test S01E03.mkv",)}]
},
}
expected_movie_watched_list_2 = [
{
"imdb": "tt0384793",
"tmdb": "9788",
"tvdb": "9103",
"title": "Accepted",
"locations": ("Accepted (2006) Remux-1080p.mkv",),
}
]
def test_simple_cleanup_watched(): def test_simple_cleanup_watched():
user_watched_list_1 = { user_watched_list_1 = {
@ -311,18 +380,21 @@ def test_combine_watched_dicts():
"tmdb": "12429", "tmdb": "12429",
"imdb": "tt0876563", "imdb": "tt0876563",
"locations": ("Ponyo (2008) Bluray-1080p.mkv",), "locations": ("Ponyo (2008) Bluray-1080p.mkv",),
"status": {"completed": True, "time": 0},
}, },
{ {
"title": "Spirited Away", "title": "Spirited Away",
"tmdb": "129", "tmdb": "129",
"imdb": "tt0245429", "imdb": "tt0245429",
"locations": ("Spirited Away (2001) Bluray-1080p.mkv",), "locations": ("Spirited Away (2001) Bluray-1080p.mkv",),
"status": {"completed": True, "time": 0},
}, },
{ {
"title": "Castle in the Sky", "title": "Castle in the Sky",
"tmdb": "10515", "tmdb": "10515",
"imdb": "tt0092067", "imdb": "tt0092067",
"locations": ("Castle in the Sky (1986) Bluray-1080p.mkv",), "locations": ("Castle in the Sky (1986) Bluray-1080p.mkv",),
"status": {"completed": True, "time": 0},
}, },
] ]
} }
@ -349,6 +421,7 @@ def test_combine_watched_dicts():
"locations": ( "locations": (
"11.22.63 S01E01 The Rabbit Hole Bluray-1080p.mkv", "11.22.63 S01E01 The Rabbit Hole Bluray-1080p.mkv",
), ),
"status": {"completed": True, "time": 0},
} }
] ]
} }
@ -365,18 +438,21 @@ def test_combine_watched_dicts():
"tmdb": "12429", "tmdb": "12429",
"imdb": "tt0876563", "imdb": "tt0876563",
"locations": ("Ponyo (2008) Bluray-1080p.mkv",), "locations": ("Ponyo (2008) Bluray-1080p.mkv",),
"status": {"completed": True, "time": 0},
}, },
{ {
"title": "Spirited Away", "title": "Spirited Away",
"tmdb": "129", "tmdb": "129",
"imdb": "tt0245429", "imdb": "tt0245429",
"locations": ("Spirited Away (2001) Bluray-1080p.mkv",), "locations": ("Spirited Away (2001) Bluray-1080p.mkv",),
"status": {"completed": True, "time": 0},
}, },
{ {
"title": "Castle in the Sky", "title": "Castle in the Sky",
"tmdb": "10515", "tmdb": "10515",
"imdb": "tt0092067", "imdb": "tt0092067",
"locations": ("Castle in the Sky (1986) Bluray-1080p.mkv",), "locations": ("Castle in the Sky (1986) Bluray-1080p.mkv",),
"status": {"completed": True, "time": 0},
}, },
], ],
"Anime Shows": {}, "Anime Shows": {},
@ -399,6 +475,7 @@ def test_combine_watched_dicts():
"locations": ( "locations": (
"11.22.63 S01E01 The Rabbit Hole Bluray-1080p.mkv", "11.22.63 S01E01 The Rabbit Hole Bluray-1080p.mkv",
), ),
"status": {"completed": True, "time": 0},
} }
] ]
} }