src/program/apis/__init__.py (1)

10-10: LGTM! Consider documenting the error handling pattern.

The import follows the established pattern of other API modules. While TVMazeAPIError is currently unused in this file, it maintains consistency and might be needed for error handling in dependent modules.

Consider adding a module-level docstring explaining the error handling pattern across API modules.

🧰 Tools

🪛 Ruff (0.8.0)

10-10: .tvmaze_api.TVMazeAPIError imported but unused; consider removing, adding to __all__, or using a redundant alias

(F401)

src/program/media/item.py (1)

177-188: Consider using UTC for consistent timezone handling

While the current implementation handles timezone-aware datetime comparison correctly, it could be more robust by explicitly using UTC throughout the application.

Consider this alternative implementation:

     @property
     def is_released(self) -> bool:
         """Check if an item has been released."""
         if not self.aired_at:
             return False
             
-        # Ensure both datetimes are timezone-aware for comparison
-        now = datetime.now().astimezone()
-        aired_at = self.aired_at
-        
-        # Make aired_at timezone-aware if it isn't already
-        if aired_at.tzinfo is None:
-            aired_at = aired_at.replace(tzinfo=now.tzinfo)
         # Convert to UTC for consistent comparison
         now = datetime.now().astimezone().astimezone(timezone.utc)
         aired_at = self.aired_at.astimezone(timezone.utc) if self.aired_at.tzinfo else self.aired_at.replace(tzinfo=timezone.utc)
             
         return aired_at <= now

This approach:

1. Explicitly uses UTC for all comparisons
2. Handles timezone conversion in a single line
3. Aligns with the PR's goal of simplifying timezone detection

src/program/services/indexers/trakt.py (1)

4-5: Remove unused imports time and Optional

The modules time and Optional are imported but not used in the code. Removing unused imports helps keep the code clean and improves readability.

Apply this diff to remove the unused imports:

-import time
-from typing import Generator, Optional, Union
 from typing import Generator, Union

🧰 Tools

🪛 Ruff (0.8.0)

4-4: time imported but unused

Remove unused import: time

(F401)

---

5-5: typing.Optional imported but unused

Remove unused import: typing.Optional

(F401)

src/program/apis/tvmaze_api.py (5)

66-67: Add Logging for Failed API Call in get_show_by_imdb_id

When the API call to /lookup/shows fails (not response.is_ok), the method returns None without logging the error. Adding a warning log will aid in debugging and monitoring API failures.

Apply this diff to add logging:

             if not response.is_ok:
                 logger.warning(f"Failed to get show by IMDb ID: {imdb_id}")
                 return None

---

88-89: Add Logging for Failed API Call in get_episode_by_number

When the API call fails or returns no data (not response.is_ok or not response.data), the method returns None without logging the error. Adding a warning log will assist with debugging.

Apply this diff to add logging:

             if not response.is_ok or not response.data:
                 logger.warning(f"Failed to get episode by number: show_id={show_id}, season={season}, episode={episode}")
                 return None

---

93-129: Simplify and Improve Date Parsing Logic

The _parse_air_date method contains complex logic to handle different date formats, which may be error-prone and difficult to maintain. Consider utilizing the dateutil library's parser.parse, which can handle ISO 8601 date strings with varying formats and timezones. This can simplify the code and improve reliability.

If adding an external dependency is not preferred, ensure that all possible date formats from the TVMaze API are properly handled, and consider adding unit tests for date parsing to cover edge cases.

---

145-146: Adjust Logging Level for Failed Show Retrieval

When the show is not retrieved successfully (not show or not hasattr(show, "id")), there is a debug log message. Consider upgrading this to a warning to highlight potential issues in data retrieval.

Apply this diff to adjust the logging level:

             if not show or not hasattr(show, "id"):
-                logger.debug(f"Failed to get TVMaze show for IMDb ID: {item.parent.parent.imdb_id}")
                 logger.warning(f"Failed to get TVMaze show for IMDb ID: {item.parent.parent.imdb_id}")
                 return None

---

158-173: Optimize API Calls for Streaming Schedule

The current implementation makes 30 separate API calls, one for each day in the next 30 days, which could be inefficient and may hit API rate limits. Consider modifying the approach to minimize the number of API calls. For example, the TVMaze API provides an endpoint /schedule/web, which can be queried without a date parameter to retrieve upcoming episodes. Fetching a broader schedule in fewer API calls or implementing caching mechanisms can improve performance.

src/program/apis/trakt_api.py (1)

3-4: Remove unused imports to clean up the codebase.

The imports time and ZoneInfo are not used and can be safely removed to tidy up the code.

Apply this diff to remove the unused imports:

-import time
-from zoneinfo import ZoneInfo

🧰 Tools

🪛 Ruff (0.8.0)

3-3: time imported but unused

Remove unused import: time

(F401)

---

4-4: zoneinfo.ZoneInfo imported but unused

Remove unused import: zoneinfo.ZoneInfo

(F401)

Configuration used: CodeRabbit UI
Review profile: CHILL

#!/bin/bash
# Description: Look for SQL queries that might be affected by case-sensitive identifiers

# Search for raw SQL queries
rg -t python "text\([\"'].*SELECT|text\([\"'].*UPDATE|text\([\"'].*INSERT|text\([\"'].*DELETE" -A 3

# Search for SQLAlchemy model definitions to check table/column names
ast-grep --pattern 'class $_(db.Model):'

#!/bin/bash
# Search for raw SQL queries with different patterns
rg "text\(" -t py -A 3

# Search for SQLAlchemy model definitions
rg "class.*\(.*Model\)" -t py -A 3

# Search for table names and column definitions
rg "Table\(|Column\(" -t py -A 3

# Look for any database-related configuration
rg "SQLALCHEMY_|DB_|DATABASE" -t py

src/program/apis/tvmaze_api.py (3)

3-3: Remove unused import

The timezone import from datetime is not used in the code as timezone handling is done using datetime.now().astimezone().tzinfo.

-from datetime import datetime, timedelta, timezone
 from datetime import datetime, timedelta

🧰 Tools

🪛 Ruff (0.8.0)

3-3: datetime.timezone imported but unused

Remove unused import: datetime.timezone

(F401)

---

26-27: Add error handling documentation

Consider adding docstring to the execute method to document the possible exceptions that could be raised and their conditions.

     def execute(self, method: HttpMethod, endpoint: str, **kwargs):
         """Execute a request to the TVMaze API
         
         Args:
             method: HTTP method to use
             endpoint: API endpoint to call
             **kwargs: Additional arguments to pass to the request
             
         Raises:
             TVMazeAPIError: When the API request fails
         """
         return super()._request(method, endpoint, **kwargs)

---

120-196: Refactor get_episode_release_time for better maintainability

The method is quite long and handles multiple responsibilities. Consider breaking it down into smaller, focused methods:

1. Validation logic (lines 122-132)
2. Regular schedule check (lines 139-143)
3. Streaming schedule check (lines 144-191)

     def _validate_episode(self, item: MediaItem) -> bool:
         """Validate if the item is a valid episode for release time lookup"""
         if not isinstance(item, Episode):
             logger.debug(f"Skipping release time lookup - not an episode: {item.log_string if item else None}")
             return False
             
         if not item.parent or not item.parent.parent:
             logger.debug(f"Skipping release time lookup - missing parent/show: {item.log_string}")
             return False
             
         if not item.parent.parent.imdb_id:
             logger.debug(f"Skipping release time lookup - no IMDb ID: {item.log_string}")
             return False
         
         return True
 
     def _check_streaming_schedule(self, show_id: int, item: Episode, start_date: datetime) -> Optional[datetime]:
         """Check streaming schedule for the next 30 days"""
         for i in range(30):
             check_date = start_date   timedelta(days=i)
             releases = self._get_streaming_releases(check_date)
             if not releases:
                 continue
                 
             for release in releases:
                 if self._is_matching_release(release, item, show_id):
                     streaming_date = self._parse_air_date(release)
                     if streaming_date:
                         logger.debug(f"Found streaming release for {item.log_string}: {streaming_date}")
                         return streaming_date
         return None
 
     def get_episode_release_time(self, item: MediaItem) -> Optional[datetime]:
         """Get episode release time for a media item"""
-        if not isinstance(item, Episode):
-            logger.debug(f"Skipping release time lookup - not an episode: {item.log_string if item else None}")
-            return None
-            
-        if not item.parent or not item.parent.parent:
-            logger.debug(f"Skipping release time lookup - missing parent/show: {item.log_string}")
-            return None
-            
-        if not item.parent.parent.imdb_id:
-            logger.debug(f"Skipping release time lookup - no IMDb ID: {item.log_string}")
         if not self._validate_episode(item):
             return None
 
         show = self.get_show_by_imdb_id(item.parent.parent.imdb_id)
         if not show or not hasattr(show, "id"):
             logger.debug(f"Failed to get TVMaze show for IMDb ID: {item.parent.parent.imdb_id}")
             return None
 
         # Get episode air date from regular schedule
         air_date = self.get_episode_by_number(show.id, item.parent.number, item.number)
         if air_date:
             logger.debug(f"Found regular schedule time for {item.log_string}: {air_date}")
 
         # Check streaming releases for next 30 days
         today = datetime.now(self.local_tz).replace(hour=0, minute=0, second=0, microsecond=0)
         logger.debug(f"Checking streaming schedule for {item.log_string} (Show ID: {show.id})")
         
-        for i in range(30):
-            check_date = today   timedelta(days=i)
-            url = f"{self.BASE_URL}/schedule/web"
-            response = self.request_handler.execute(
-                HttpMethod.GET, 
-                url, 
-                params={
-                    "date": check_date.strftime("%Y-%m-%d"),
-                    "country": None
-                }
-            )
-            
-            if not response.is_ok:
-                logger.debug(f"Failed to get streaming schedule for {check_date.strftime('%Y-%m-%d')}")
-                continue
-                
-            for release in response.data:
-                if not release:
-                    continue
-                    
-                show_data = getattr(release, "show", None)
-                if not show_data:
-                    continue
-                    
-                # Get externals safely
-                externals = getattr(show_data, "externals", {}) or {}
-                show_imdb = externals.get("imdb")
-                show_id = getattr(show_data, "id", None)
-                
-                # Check both IMDb ID and TVMaze show ID
-                is_match = (
-                    (show_imdb == item.parent.parent.imdb_id or show_id == show.id) and
-                    getattr(release, "season", 0) == item.parent.number and
-                    getattr(release, "number", 0) == item.number
-                )
-                
-                if is_match:
-                    streaming_date = self._parse_air_date(release)
-                    if streaming_date:
-                        logger.debug(f"Found streaming release for {item.log_string}: {streaming_date}")
-                        if not air_date or streaming_date < air_date:
-                            air_date = streaming_date
-                            logger.debug(f"Using earlier streaming release time for {item.log_string}: {streaming_date}")
         streaming_date = self._check_streaming_schedule(show.id, item, today)
         if streaming_date and (not air_date or streaming_date < air_date):
             air_date = streaming_date
             logger.debug(f"Using earlier streaming release time for {item.log_string}: {streaming_date}")
 
         if air_date:
             logger.debug(f"Final release time for {item.log_string}: {air_date}")

Configuration used: CodeRabbit UI
Review profile: CHILL

     def get_show_by_imdb_id(self, imdb_id: str) -> Optional[dict]:
         """Get show information by IMDb ID"""
         if not imdb_id:
             return None
         
         url = f"{self.BASE_URL}/lookup/shows"
         response = self.request_handler.execute(
             HttpMethod.GET, 
             url,
             params={"imdb": imdb_id}
         )
         if not response.is_ok:
             return None
 
-        show_url = f"{self.BASE_URL}/shows/{response.data.id}"
-        show_response = self.request_handler.execute(HttpMethod.GET, show_url)
-        return show_response.data if show_response.is_ok else None
         return response.data

src/program/apis/tvmaze_api.py (2)

78-98: Consider adding type hints to the _parse_air_date method parameters.

The method lacks type hints which could improve code maintainability and IDE support.

-    def _parse_air_date(self, episode_data) -> Optional[datetime]:
     def _parse_air_date(self, episode_data: SimpleNamespace) -> Optional[datetime]:

---

115-192: Consider breaking down the get_episode_release_time method.

The method is quite long (77 lines) and handles multiple responsibilities. Consider extracting the streaming schedule check into a separate method for better maintainability.

     def _check_streaming_schedule(self, show_data: SimpleNamespace, episode_item: Episode, today: datetime) -> Optional[datetime]:
         """Check streaming releases for the next 30 days."""
         for i in range(30):
             check_date = today   timedelta(days=i)
             response = self.request_handler.execute(
                 HttpMethod.GET,
                 f"{self.BASE_URL}/schedule/web",
                 params={
                     "date": check_date.strftime("%Y-%m-%d"),
                     "country": None
                 }
             )
             
             if not response.is_ok:
                 logger.debug(f"Failed to get streaming schedule for {check_date.strftime('%Y-%m-%d')}")
                 continue
                 
             for release in response.data:
                 if self._is_matching_episode(release, show_data, episode_item):
                     streaming_date = self._parse_air_date(release)
                     if streaming_date:
                         logger.debug(f"Found streaming release: {streaming_date}")
                         return streaming_date
         return None

     def _is_matching_episode(self, release: SimpleNamespace, show_data: SimpleNamespace, episode_item: Episode) -> bool:
         """Check if the release matches the episode."""
         if not release:
             return False
             
         show_data = getattr(release, "show", None)
         if not show_data:
             return False
             
         externals = getattr(show_data, "externals", {}) or {}
         show_imdb = externals.get("imdb")
         show_id = getattr(show_data, "id", None)
         
         return (
             (show_imdb == show.imdb_id or show_id == show_data.id) and
             getattr(release, "season", 0) == episode_item.parent.number and
             getattr(release, "number", 0) == episode_item.number
         )

src/program/services/indexers/trakt.py (1)

127-133: Consider using UTC for internal storage of dates.

While setting the timezone is necessary, it's generally better to store dates in UTC internally and only convert to local timezone when displaying to users.

src/program/apis/trakt_api.py (1)

2-5: Remove unused imports.

Several imports are not used in the code:

• datetime.timedelta
• time
• zoneinfo.ZoneInfo

-from datetime import datetime, timedelta, timezone
-import time
-from zoneinfo import ZoneInfo
 from datetime import datetime, timezone

🧰 Tools

🪛 Ruff (0.8.0)

2-2: datetime.timedelta imported but unused

Remove unused import: datetime.timedelta

(F401)

---

3-3: time imported but unused

Remove unused import: time

(F401)

---

4-4: zoneinfo.ZoneInfo imported but unused

Remove unused import: zoneinfo.ZoneInfo

(F401)

src/program/media/item.py (1)

177-188: Consider handling additional timezone edge cases.

The timezone handling is improved, but consider these edge cases:

1. Invalid timezone information in aired_at
2. Cases where the local timezone might not be appropriate (e.g., international content)

 def is_released(self) -> bool:
     """Check if an item has been released."""
     if not self.aired_at:
         return False
         
     # Ensure both datetimes are timezone-aware for comparison
     now = datetime.now().astimezone()
     aired_at = self.aired_at
     
     # Make aired_at timezone-aware if it isn't already
     if aired_at.tzinfo is None:
         try:
             aired_at = aired_at.replace(tzinfo=now.tzinfo)
         except (ValueError, OSError) as e:
             logger.warning(f"Invalid timezone for {self.log_string}: {e}")
             # Fallback to UTC
             aired_at = aired_at.replace(tzinfo=timezone.utc)
         
     return aired_at <= now

Configuration used: CodeRabbit UI
Review profile: CHILL

src/program/services/indexers/trakt.py (2)

4-4: Remove unused import time

The time module is imported but not used in this file. Removing it cleans up the code and eliminates unnecessary imports.

Apply this diff:

-import time

🧰 Tools

🪛 Ruff (0.8.0)

4-4: time imported but unused

Remove unused import: time

(F401)

---

5-5: Remove unused import Optional from typing module

The Optional type is imported but not used in this file. Removing it cleans up the code and eliminates unnecessary imports.

Apply this diff:

-from typing import Generator, Optional, Union
 from typing import Generator, Union

🧰 Tools

🪛 Ruff (0.8.0)

5-5: typing.Optional imported but unused

Remove unused import: typing.Optional

(F401)

Configuration used: CodeRabbit UI
Review profile: CHILL

-if season_item.aired_at and season_item.aired_at.tzinfo is None:
-    season_item.aired_at = season_item.aired_at.replace(tzinfo=self.local_tz)
 if season_item.aired_at and season_item.aired_at.tzinfo is None:
     season_item.aired_at = season_item.aired_at.replace(tzinfo=timezone.utc).astimezone(self.local_tz)

-if episode_item.aired_at and episode_item.aired_at.tzinfo is None:
-    episode_item.aired_at = episode_item.aired_at.replace(tzinfo=self.local_tz)
 if episode_item.aired_at and episode_item.aired_at.tzinfo is None:
     episode_item.aired_at = episode_item.aired_at.replace(tzinfo=timezone.utc).astimezone(self.local_tz)

-if trakt_time and trakt_time.tzinfo is None:
-    trakt_time = trakt_time.replace(tzinfo=datetime.now().astimezone().tzinfo)
-    episode.aired_at = trakt_time
 if trakt_time and trakt_time.tzinfo is None:
     trakt_time = trakt_time.replace(tzinfo=timezone.utc).astimezone(self.local_tz)
     episode.aired_at = trakt_time

-if tvmaze_time.tzinfo is None:
-    tvmaze_time = tvmaze_time.replace(tzinfo=datetime.now().astimezone().tzinfo)
 if tvmaze_time.tzinfo is None:
     tvmaze_time = tvmaze_time.replace(tzinfo=timezone.utc).astimezone(self.local_tz)

src/program/apis/tvmaze_api.py (3)

3-17: Clean up unused imports

Remove the following unused imports to improve code maintainability:

• datetime.timedelta
• datetime.timezone
• program.media.item.MediaItem

-from datetime import datetime, timedelta, timezone
 from datetime import datetime
 from typing import Optional
 
 from loguru import logger
 from requests import Session
 
-from program.media.item import Episode, MediaItem
 from program.media.item import Episode

🧰 Tools

🪛 Ruff (0.8.0)

3-3: datetime.timedelta imported but unused

Remove unused import

(F401)

---

3-3: datetime.timezone imported but unused

Remove unused import

(F401)

---

9-9: program.media.item.MediaItem imported but unused

Remove unused import: program.media.item.MediaItem

(F401)

---

88-123: Enhance error logging for timestamp parsing

The error logging could be more detailed to help diagnose parsing issues.

-            logger.debug(f"Failed to parse TVMaze airstamp: {airstamp} - {e}")
             logger.debug(f"Failed to parse TVMaze airstamp '{airstamp}' - Error: {e}. Format should be ISO 8601.")

---

127-128: Simplify parent relationship validation

Replace nested attribute checks with a more robust validation method.

-if not episode or not episode.parent or not episode.parent.parent:
 if not isinstance(episode, Episode) or not hasattr(episode, 'parent') or not isinstance(episode.parent, Season) or not hasattr(episode.parent, 'parent') or not isinstance(episode.parent.parent, Show):
     return None

src/program/services/indexers/trakt.py (2)

3-5: Remove unused imports

The following imports are not used:

• time
• typing.Optional

-from datetime import datetime, timedelta, timezone
-import time
-from typing import Generator, Optional, Union
 from datetime import datetime, timedelta, timezone
 from typing import Generator, Union

🧰 Tools

🪛 Ruff (0.8.0)

4-4: time imported but unused

Remove unused import: time

(F401)

---

5-5: typing.Optional imported but unused

Remove unused import: typing.Optional

(F401)

---

148-211: Consider breaking down the complex release time comparison logic

The method handles multiple responsibilities and could be split into smaller, focused methods:

• Release time comparison logic
• Skip condition evaluation
• Time difference calculation

Example refactor:

def _compare_release_times(self, episode, trakt_time, tvmaze_time) -> datetime:
    """Compare and return the earlier release time."""
    if not trakt_time:
        return tvmaze_time
    if not tvmaze_time:
        return trakt_time
    return min(trakt_time, tvmaze_time)

def _should_skip_remaining(self, episode) -> bool:
    """Determine if remaining episodes should be skipped."""
    if not episode.aired_at:
        return True
    now = datetime.now(episode.aired_at.tzinfo)
    time_until_release = episode.aired_at - now
    return time_until_release.days > 7

Configuration used: CodeRabbit UI
Review profile: CHILL

 trakt_time = episode.aired_at
 if trakt_time and trakt_time.tzinfo is None:
-    trakt_time = trakt_time.replace(tzinfo=datetime.now().astimezone().tzinfo)
     trakt_time = trakt_time.replace(tzinfo=self.local_tz)
     episode.aired_at = trakt_time

 # Get release time from TVMaze and use it if it's earlier or if Trakt has no time
 tvmaze_time = self.tvmaze_api.get_episode_release_time(episode)
 if tvmaze_time:
     # Ensure TVMaze time is timezone-aware
     if tvmaze_time.tzinfo is None:
-        tvmaze_time = tvmaze_time.replace(tzinfo=datetime.now().astimezone().tzinfo)
         tvmaze_time = tvmaze_time.replace(tzinfo=self.local_tz)

src/program/apis/tvmaze_api.py (3)

3-17: Clean up unused imports

The following imports are not used in the code:

• timedelta and timezone from datetime
• MediaItem from program.media.item

-from datetime import datetime, timedelta, timezone
 from datetime import datetime
-from program.media.item import Episode, MediaItem
 from program.media.item import Episode

🧰 Tools

🪛 Ruff (0.8.0)

3-3: datetime.timedelta imported but unused

Remove unused import

(F401)

---

3-3: datetime.timezone imported but unused

Remove unused import

(F401)

---

9-9: program.media.item.MediaItem imported but unused

Remove unused import: program.media.item.MediaItem

(F401)

---

22-28: Consider simplifying TVMazeRequestHandler

The execute method is just a pass-through to the parent's _request method. Consider removing it and using _request directly, or document why this wrapper is necessary.

---

92-128: Simplify timestamp parsing logic

The timestamp parsing logic could be simplified by using a single try-except block and standardizing the input format first.

 def _parse_air_date(self, episode_data) -> Optional[datetime]:
     """Parse episode air date from TVMaze response"""
-    if airstamp := getattr(episode_data, "airstamp", None):
-        try:
-            # Handle both 'Z' suffix and explicit timezone
-            timestamp = airstamp.replace('Z', ' 00:00')
-            if '.' in timestamp:
-                # Strip milliseconds but preserve timezone
-                parts = timestamp.split('.')
-                base = parts[0]
-                tz = parts[1][parts[1].find(' '):]
-                timestamp = base   tz if ' ' in parts[1] else base   ' 00:00'
-            elif not (' ' in timestamp or '-' in timestamp):
-                # Add UTC timezone if none specified
-                timestamp = timestamp   ' 00:00'
-            # Convert to user's timezone
-            utc_dt = datetime.fromisoformat(timestamp)
-            return utc_dt.astimezone(self.local_tz)
-        except (ValueError, AttributeError) as e:
-            logger.debug(f"Failed to parse TVMaze airstamp: {airstamp} - {e}")
     try:
         # Try parsing airstamp first
         if airstamp := getattr(episode_data, "airstamp", None):
             # Standardize timestamp format
             timestamp = airstamp.replace('Z', ' 00:00')
             if '.' in timestamp:
                 timestamp = timestamp.split('.')[0]   ' 00:00'
             elif not (' ' in timestamp or '-' in timestamp):
                 timestamp = timestamp   ' 00:00'
             return datetime.fromisoformat(timestamp).astimezone(self.local_tz)
 
-    try:
-        if airdate := getattr(episode_data, "airdate", None):
-            if airtime := getattr(episode_data, "airtime", None):
-                # Combine date and time with UTC timezone first
-                dt_str = f"{airdate}T{airtime} 00:00"
-                utc_dt = datetime.fromisoformat(dt_str)
-                # Convert to user's timezone
-                return utc_dt.astimezone(self.local_tz)
-            # If we only have a date, set time to midnight in user's timezone
-            local_midnight = datetime.fromisoformat(f"{airdate}T00:00:00").replace(tzinfo=self.local_tz)
-            return local_midnight
-    except (ValueError, AttributeError) as e:
-        logger.error(f"Failed to parse TVMaze air date/time: {airdate}/{getattr(episode_data, 'airtime', None)} - {e}")
-    
-    return None
         # Fallback to separate date/time fields
         if airdate := getattr(episode_data, "airdate", None):
             time_str = getattr(episode_data, "airtime", "00:00:00")
             dt_str = f"{airdate}T{time_str} 00:00"
             return datetime.fromisoformat(dt_str).astimezone(self.local_tz)
             
         return None
     except (ValueError, AttributeError) as e:
         logger.debug(f"Failed to parse TVMaze air date: {e}")
         return None

Configuration used: CodeRabbit UI
Review profile: CHILL

-        if not episode or not episode.parent or not episode.parent.parent:
         if not isinstance(episode, Episode):
             return None

src/program/apis/tvmaze_api.py (2)

3-3: Remove unused imports timedelta and timezone

The imports timedelta and timezone from datetime are not used in the code.

Apply this diff to remove the unused imports:

- from datetime import datetime, timedelta, timezone
  from datetime import datetime

🧰 Tools

🪛 Ruff (0.8.0)

3-3: datetime.timedelta imported but unused

Remove unused import

(F401)

---

3-3: datetime.timezone imported but unused

Remove unused import

(F401)

---

9-9: Remove unused import MediaItem

The MediaItem class is imported but not used in the code.

Apply this diff to remove the unused import:

- from program.media.item import Episode, MediaItem
  from program.media.item import Episode

🧰 Tools

🪛 Ruff (0.8.0)

9-9: program.media.item.MediaItem imported but unused

Remove unused import: program.media.item.MediaItem

(F401)

src/program/services/indexers/trakt.py (3)

4-4: Remove unused import time

The time module is imported but not used in the code.

Apply this diff to remove the unused import:

- import time

🧰 Tools

🪛 Ruff (0.8.0)

4-4: time imported but unused

Remove unused import: time

(F401)

---

5-5: Remove unused import Optional

The Optional type is imported but not used in the code.

Apply this diff to remove the unused import:

- from typing import Generator, Optional, Union
  from typing import Generator, Union

🧰 Tools

🪛 Ruff (0.8.0)

5-5: typing.Optional imported but unused

Remove unused import: typing.Optional

(F401)

---

199-199: Remove unnecessary f-string prefix in log message

The log message is an f-string without any placeholders. Removing the f prefix enhances code clarity.

Apply this diff:

-    logger.debug(f"Using TVMaze time (no Trakt time available)")
     logger.debug("Using TVMaze time (no Trakt time available)")

🧰 Tools

🪛 Ruff (0.8.0)

199-199: f-string without any placeholders

Remove extraneous f prefix

(F541)

Configuration used: CodeRabbit UI
Review profile: CHILL

-    if season_item.aired_at and season_item.aired_at.tzinfo is None:
-        season_item.aired_at = season_item.aired_at.replace(tzinfo=self.local_tz)
     if season_item.aired_at and season_item.aired_at.tzinfo is None:
         season_item.aired_at = season_item.aired_at.replace(tzinfo=timezone.utc).astimezone(self.local_tz)

-    if episode_item.aired_at and episode_item.aired_at.tzinfo is None:
-        episode_item.aired_at = episode_item.aired_at.replace(tzinfo=self.local_tz)
     if episode_item.aired_at and episode_item.aired_at.tzinfo is None:
         episode_item.aired_at = episode_item.aired_at.replace(tzinfo=timezone.utc).astimezone(self.local_tz)

-    if trakt_time and trakt_time.tzinfo is None:
-        trakt_time = trakt_time.replace(tzinfo=datetime.now().astimezone().tzinfo)
     if trakt_time and trakt_time.tzinfo is None:
         trakt_time = trakt_time.replace(tzinfo=timezone.utc).astimezone(self.local_tz)

-        show = item if item.type == "show" else (
-            item.parent.parent if item.type == "episode" else item.parent
-        )
         if item.type == "show":
             show = item
         elif item.type == "episode" and item.parent and item.parent.parent:
             show = item.parent.parent
         elif item.type == "season" and item.parent:
             show = item.parent
         else:
             logger.error(f"Cannot determine show for item {item.log_string} due to missing parent information.")
             continue