Merge pull request #225 from maxdorninger/remove-unnecessary-logs

Remove unnecessary logs

Author: maxdorninger

media_manager/indexer/indexers/jackett.py

@@ -24,9 +24,7 @@ def __init__(self, **kwargs):
         self.api_key = config.api_key
         self.url = config.url
         self.indexers = config.indexers
-        log.debug("Registering Jacket as Indexer")
 
-    # NOTE: this could be done in parallel, but if there aren't more than a dozen indexers, it shouldn't matter
     def search(self, query: str, is_tv: bool) -> list[IndexerQueryResult]:
         log.debug("Searching for " + query)
 

media_manager/indexer/indexers/prowlarr.py

@@ -26,7 +26,6 @@ def __init__(self, **kwargs):
         self.api_key = config.api_key
         self.url = config.url
         self.reject_torrents_on_url_error = config.reject_torrents_on_url_error
-        log.debug("Registering Prowlarr as Indexer")
 
     def search(self, query: str, is_tv: bool) -> list[IndexerQueryResult]:
         log.debug("Searching for " + query)
@@ -44,7 +43,6 @@ def search(self, query: str, is_tv: bool) -> list[IndexerQueryResult]:
             session.mount("https://", adapter)
 
             response = session.get(url, params=params)
-            log.debug(f"Prowlarr response time for query '{query}': {response.elapsed}")
 
             if response.status_code != 200:
                 log.error(f"Prowlarr Error: {response.status_code}")
@@ -86,15 +84,10 @@ def process_result(
         # process torrent search result
         initial_url = None
         if "downloadUrl" in result:
-            log.info(f"Using download URL: {result['downloadUrl']}")
             initial_url = result["downloadUrl"]
         elif "magnetUrl" in result:
-            log.info(
-                f"Using magnet URL as fallback for download URL: {result['magnetUrl']}"
-            )
             initial_url = result["magnetUrl"]
         elif "guid" in result:
-            log.warning(f"Using guid as fallback for download URL: {result['guid']}")
             initial_url = result["guid"]
         else:
             log.error(f"No valid download URL found for result: {result}")
@@ -107,7 +100,7 @@ def process_result(
                     session=session,
                 )
             except RuntimeError as e:
-                log.debug(
+                log.warning(
                     f"Failed to follow redirects for {initial_url}, falling back to the initial url as download url, error: {e}"
                 )
                 if self.reject_torrents_on_url_error:

media_manager/indexer/repository.py

@@ -21,8 +21,6 @@ def get_result(self, result_id: IndexerQueryResultId) -> IndexerQueryResultSchem
         )
 
     def save_result(self, result: IndexerQueryResultSchema) -> IndexerQueryResultSchema:
-        log.debug("Saving indexer query result: %s", result)
-
         result_data = result.model_dump()
         result_data["download_url"] = str(
             result.download_url

media_manager/indexer/service.py

@@ -68,5 +68,4 @@ def search(self, query: str, is_tv: bool) -> list[IndexerQueryResult]:
         for result in results:
             self.repository.save_result(result=result)
 
-        log.debug(f"Found torrents: {results}")
         return results

media_manager/metadataProvider/tmdb.py

@@ -246,7 +246,7 @@ def search_show(
                     )
                 )
             except Exception as e:
-                log.warning(f"Error processing search result {result}: {e}")
+                log.warning(f"Error processing search result: {e}")
         return formatted_results
 
     def get_movie_metadata(self, id: int = None) -> Movie:
@@ -315,7 +315,7 @@ def search_movie(
                     )
                 )
             except Exception as e:
-                log.warning(f"Error processing search result {result}: {e}")
+                log.warning(f"Error processing search result: {e}")
         return formatted_results
 
     def download_movie_poster_image(self, movie: Movie) -> bool:

media_manager/metadataProvider/tvdb.py

@@ -52,7 +52,7 @@ def download_show_poster_image(self, show: Show) -> bool:
                 poster_url=show_metadata["image"],
                 id=show.id,
             )
-            log.info("Successfully downloaded poster image for show " + show.name)
+            log.debug("Successfully downloaded poster image for show " + show.name)
             return True
         else:
             log.warning(f"image for show {show.name} could not be downloaded")
@@ -143,7 +143,7 @@ def search_show(
                             )
                         )
                 except Exception as e:
-                    log.warning(f"Error processing search result {result}: {e}")
+                    log.warning(f"Error processing search result: {e}")
             return formatted_results
         else:
             results = self.__get_trending_tv()
@@ -169,7 +169,7 @@ def search_show(
                             )
                         )
                 except Exception as e:
-                    log.warning(f"Error processing search result {result}: {e}")
+                    log.warning(f"Error processing search result: {e}")
             return formatted_results
 
     def search_movie(
@@ -178,7 +178,7 @@ def search_movie(
         if query is None:
             results = self.__get_trending_movies()
             results = results[0:20]
-            log.info(f"got {len(results)} results from TVDB search")
+            log.debug(f"got {len(results)} results from TVDB search")
             formatted_results = []
             for result in results:
                 result = self.__get_movie(result["id"])
@@ -201,12 +201,12 @@ def search_movie(
                         )
                     )
                 except Exception as e:
-                    log.warning(f"Error processing search result {result}: {e}")
+                    log.warning(f"Error processing search result: {e}")
             return formatted_results
         else:
             results = self.__search_movie(query=query)
             results = results[0:20]
-            log.info(f"got {len(results)} results from TVDB search")
+            log.debug(f"got {len(results)} results from TVDB search")
             formatted_results = []
             for result in results:
                 if result["type"] != "movie":
@@ -233,7 +233,7 @@ def search_movie(
                         )
                     )
                 except Exception as e:
-                    log.warning(f"Error processing search result {result}: {e}")
+                    log.warning(f"Error processing search result: {e}")
             return formatted_results
 
     def download_movie_poster_image(self, movie: Movie) -> bool:

media_manager/movies/repository.py

@@ -41,14 +41,11 @@ def get_movie_by_id(self, movie_id: MovieId) -> MovieSchema:
         :raises NotFoundError: If the movie with the given ID is not found.
         :raises SQLAlchemyError: If a database error occurs.
         """
-        log.debug(f"Attempting to retrieve movie with id: {movie_id}")
         try:
             stmt = select(Movie).where(Movie.id == movie_id)
             result = self.db.execute(stmt).unique().scalar_one_or_none()
             if not result:
-                log.warning(f"Movie with id {movie_id} not found.")
                 raise NotFoundError(f"Movie with id {movie_id} not found.")
-            log.info(f"Successfully retrieved movie with id: {movie_id}")
             return MovieSchema.model_validate(result)
         except SQLAlchemyError as e:
             log.error(f"Database error while retrieving movie {movie_id}: {e}")
@@ -66,9 +63,6 @@ def get_movie_by_external_id(
         :raises NotFoundError: If the movie with the given external ID and provider is not found.
         :raises SQLAlchemyError: If a database error occurs.
         """
-        log.debug(
-            f"Attempting to retrieve movie with external_id: {external_id} and provider: {metadata_provider}"
-        )
         try:
             stmt = (
                 select(Movie)
@@ -77,15 +71,9 @@ def get_movie_by_external_id(
             )
             result = self.db.execute(stmt).unique().scalar_one_or_none()
             if not result:
-                log.warning(
-                    f"Movie with external_id {external_id} and provider {metadata_provider} not found."
-                )
                 raise NotFoundError(
                     f"Movie with external_id {external_id} and provider {metadata_provider} not found."
                 )
-            log.info(
-                f"Successfully retrieved movie with external_id: {external_id} and provider: {metadata_provider}"
-            )
             return MovieSchema.model_validate(result)
         except SQLAlchemyError as e:
             log.error(
@@ -100,11 +88,9 @@ def get_movies(self) -> list[MovieSchema]:
         :return: A list of Movie objects.
         :raises SQLAlchemyError: If a database error occurs.
         """
-        log.debug("Attempting to retrieve all movies.")
         try:
             stmt = select(Movie)
             results = self.db.execute(stmt).scalars().unique().all()
-            log.info(f"Successfully retrieved {len(results)} movies.")
             return [MovieSchema.model_validate(movie) for movie in results]
         except SQLAlchemyError as e:
             log.error(f"Database error while retrieving all movies: {e}")
@@ -221,15 +207,12 @@ def set_movie_library(self, movie_id: MovieId, library: str) -> None:
         :raises NotFoundError: If the movie with the given ID is not found.
         :raises SQLAlchemyError: If a database error occurs.
         """
-        log.debug(f"Setting library for movie_id {movie_id} to {library}")
         try:
             movie = self.db.get(Movie, movie_id)
             if not movie:
-                log.warning(f"movie with id {movie_id} not found.")
                 raise NotFoundError(f"movie with id {movie_id} not found.")
             movie.library = library
             self.db.commit()
-            log.info(f"Successfully set library for movie_id {movie_id} to {library}")
         except SQLAlchemyError as e:
             self.db.rollback()
             log.error(f"Database error setting library for movie {movie_id}: {e}")
@@ -243,16 +226,14 @@ def delete_movie_request(self, movie_request_id: MovieRequestId) -> None:
         :raises NotFoundError: If the movie request is not found.
         :raises SQLAlchemyError: If a database error occurs.
         """
-        log.debug(f"Attempting to delete movie request with id: {movie_request_id}")
         try:
             stmt = delete(MovieRequest).where(MovieRequest.id == movie_request_id)
             result = self.db.execute(stmt)
             if result.rowcount == 0:
-                log.warning(
-                    f"Movie request with id {movie_request_id} not found during delete execution (rowcount 0)."
-                )
+                self.db.rollback()
+                raise NotFoundError(f"movie request with id {movie_request_id} not found.")
             self.db.commit()
-            log.info(f"Successfully deleted movie request with id: {movie_request_id}")
+            # Successfully deleted movie request with id: {movie_request_id}
         except SQLAlchemyError as e:
             self.db.rollback()
             log.error(
@@ -267,15 +248,13 @@ def get_movie_requests(self) -> list[RichMovieRequestSchema]:
         :return: A list of RichMovieRequest objects.
         :raises SQLAlchemyError: If a database error occurs.
         """
-        log.debug("Attempting to retrieve all movie requests.")
         try:
             stmt = select(MovieRequest).options(
                 joinedload(MovieRequest.requested_by),
                 joinedload(MovieRequest.authorized_by),
                 joinedload(MovieRequest.movie),
             )
             results = self.db.execute(stmt).scalars().unique().all()
-            log.info(f"Successfully retrieved {len(results)} movie requests.")
             return [RichMovieRequestSchema.model_validate(x) for x in results]
         except SQLAlchemyError as e:
             log.error(f"Database error while retrieving movie requests: {e}")
@@ -290,15 +269,11 @@ def add_movie_file(self, movie_file: MovieFileSchema) -> MovieFileSchema:
         :raises IntegrityError: If the record violates constraints.
         :raises SQLAlchemyError: If a database error occurs.
         """
-        log.debug(f"Adding movie file: {movie_file.model_dump_json()}")
         db_model = MovieFile(**movie_file.model_dump())
         try:
             self.db.add(db_model)
             self.db.commit()
             self.db.refresh(db_model)
-            log.info(
-                f"Successfully added movie file. Torrent ID: {db_model.torrent_id}, Path: {db_model.file_path_suffix}"
-            )
             return MovieFileSchema.model_validate(db_model)
         except IntegrityError as e:
             self.db.rollback()
@@ -317,15 +292,11 @@ def remove_movie_files_by_torrent_id(self, torrent_id: TorrentId) -> int:
         :return: The number of movie files removed.
         :raises SQLAlchemyError: If a database error occurs.
         """
-        log.debug(f"Attempting to remove movie files for torrent_id: {torrent_id}")
         try:
             stmt = delete(MovieFile).where(MovieFile.torrent_id == torrent_id)
             result = self.db.execute(stmt)
             self.db.commit()
             deleted_count = result.rowcount
-            log.info(
-                f"Successfully removed {deleted_count} movie files for torrent_id: {torrent_id}"
-            )
             return deleted_count
         except SQLAlchemyError as e:
             self.db.rollback()
@@ -342,13 +313,9 @@ def get_movie_files_by_movie_id(self, movie_id: MovieId) -> list[MovieFileSchema
         :return: A list of MovieFile objects.
         :raises SQLAlchemyError: If a database error occurs.
         """
-        log.debug(f"Attempting to retrieve movie files for movie_id: {movie_id}")
         try:
             stmt = select(MovieFile).where(MovieFile.movie_id == movie_id)
             results = self.db.execute(stmt).scalars().all()
-            log.info(
-                f"Successfully retrieved {len(results)} movie files for movie_id: {movie_id}"
-            )
             return [MovieFileSchema.model_validate(sf) for sf in results]
         except SQLAlchemyError as e:
             log.error(
@@ -364,7 +331,6 @@ def get_torrents_by_movie_id(self, movie_id: MovieId) -> list[MovieTorrentSchema
         :return: A list of Torrent objects.
         :raises SQLAlchemyError: If a database error occurs.
         """
-        log.debug(f"Attempting to retrieve torrents for movie_id: {movie_id}")
         try:
             stmt = (
                 select(Torrent, MovieFile.file_path_suffix)
@@ -373,9 +339,6 @@ def get_torrents_by_movie_id(self, movie_id: MovieId) -> list[MovieTorrentSchema
                 .where(MovieFile.movie_id == movie_id)
             )
             results = self.db.execute(stmt).all()
-            log.info(
-                f"Successfully retrieved {len(results)} torrents for movie_id: {movie_id}"
-            )
             formatted_results = []
             for torrent, file_path_suffix in results:
                 movie_torrent = MovieTorrentSchema(
@@ -402,7 +365,6 @@ def get_all_movies_with_torrents(self) -> list[MovieSchema]:
         :return: A list of Movie objects.
         :raises SQLAlchemyError: If a database error occurs.
         """
-        log.debug("Attempting to retrieve all movies with torrents.")
         try:
             stmt = (
                 select(Movie)
@@ -412,7 +374,6 @@ def get_all_movies_with_torrents(self) -> list[MovieSchema]:
                 .order_by(Movie.name)
             )
             results = self.db.execute(stmt).scalars().unique().all()
-            log.info(f"Successfully retrieved {len(results)} movies with torrents.")
             return [MovieSchema.model_validate(movie) for movie in results]
         except SQLAlchemyError as e:
             log.error(f"Database error retrieving all movies with torrents: {e}")
@@ -427,17 +388,12 @@ def get_movie_request(self, movie_request_id: MovieRequestId) -> MovieRequestSch
         :raises NotFoundError: If the movie request is not found.
         :raises SQLAlchemyError: If a database error occurs.
         """
-        log.debug(f"Attempting to retrieve movie request with id: {movie_request_id}")
         try:
             request = self.db.get(MovieRequest, movie_request_id)
             if not request:
-                log.warning(f"Movie request with id {movie_request_id} not found.")
                 raise NotFoundError(
                     f"Movie request with id {movie_request_id} not found."
                 )
-            log.info(
-                f"Successfully retrieved movie request with id: {movie_request_id}"
-            )
             return MovieRequestSchema.model_validate(request)
         except SQLAlchemyError as e:
             log.error(
@@ -454,7 +410,6 @@ def get_movie_by_torrent_id(self, torrent_id: TorrentId) -> MovieSchema:
         :raises NotFoundError: If the movie for the given torrent ID is not found.
         :raises SQLAlchemyError: If a database error occurs.
         """
-        log.debug(f"Attempting to retrieve movie by torrent_id: {torrent_id}")
         try:
             stmt = (
                 select(Movie)
@@ -463,9 +418,7 @@ def get_movie_by_torrent_id(self, torrent_id: TorrentId) -> MovieSchema:
             )
             result = self.db.execute(stmt).unique().scalar_one_or_none()
             if not result:
-                log.warning(f"Movie for torrent_id {torrent_id} not found.")
                 raise NotFoundError(f"Movie for torrent_id {torrent_id} not found.")
-            log.info(f"Successfully retrieved movie for torrent_id: {torrent_id}")
             return MovieSchema.model_validate(result)
         except SQLAlchemyError as e:
             log.error(
@@ -489,10 +442,8 @@ def update_movie_attributes(
         :param year: The new year for the movie.
         :return: The updated MovieSchema object.
         """
-        log.debug(f"Attempting to update attributes for movie ID: {movie_id}")
         db_movie = self.db.get(Movie, movie_id)
         if not db_movie:
-            log.warning(f"Movie with id {movie_id} not found for attribute update.")
             raise NotFoundError(f"Movie with id {movie_id} not found.")
 
         updated = False
@@ -509,7 +460,4 @@ def update_movie_attributes(
         if updated:
             self.db.commit()
             self.db.refresh(db_movie)
-            log.info(f"Successfully updated attributes for movie ID: {movie_id}")
-        else:
-            log.info(f"No attribute changes needed for movie ID: {movie_id}")
         return MovieSchema.model_validate(db_movie)

media_manager/movies/router.py

@@ -194,7 +194,6 @@ def create_movie_request(
     )
     movie_request = MovieRequest.model_validate(movie_request)
     movie_request.requested_by = user
-    log.info("SERVASasdasd")
     if user.is_superuser:
         movie_request.authorized = True
         movie_request.authorized_by = user