renamed app to anixstream

anixstream/Controller/__init__.py

@@ -0,0 +1,7 @@
+from .home_screen import HomeScreenController
+from .search_screen import SearchScreenController
+from .my_list_screen import MyListScreenController
+from .anime_screen import AnimeScreenController
+from .downloads_screen import DownloadsScreenController
+from .help_screen import HelpScreenController
+from .crashlog_screen import CrashLogScreenController

anixstream/Controller/anime_screen.py

@@ -0,0 +1,43 @@
+from kivy.clock import Clock
+from kivy.logger import Logger
+from kivy.cache import Cache
+
+from Model import AnimeScreenModel
+from View import AnimeScreenView
+
+Cache.register("data.anime", limit=20, timeout=600)
+
+
+class AnimeScreenController:
+    """The controller for the anime screen
+    """
+    def __init__(self, model: AnimeScreenModel):
+        self.model = model
+        self.view = AnimeScreenView(controller=self, model=self.model)
+
+    def get_view(self) -> AnimeScreenView:
+        return self.view
+
+    def update_anime_view(self, id: int, caller_screen_name: str):
+        """method called to update the anime screen when a new 
+
+        Args:
+            id (int): the anilst id of the anime
+            caller_screen_name (str): the screen thats calling this method; used internally to switch back to this screen
+        """
+        if self.model.anime_id != id:
+            if cached_anime_data := Cache.get("data.anime", f"{id}"):
+                data = cached_anime_data
+            else:
+                data = self.model.get_anime_data(id)
+
+            if data[0]:
+
+                self.model.anime_id = id
+                Clock.schedule_once(
+                    lambda _: self.view.update_layout(
+                        data[1]["data"]["Page"]["media"][0], caller_screen_name
+                    )
+                )
+                Logger.info(f"Anime Screen:Success in opening anime of id: {id}")
+                Cache.append("data.anime", f"{id}", data)

anixstream/Controller/crashlog_screen.py

@@ -0,0 +1,16 @@
+
+from View import CrashLogScreenView
+from Model import CrashLogScreenModel
+
+
+
+class CrashLogScreenController:
+    """The crash log screen controller
+    """
+    def __init__(self, model:CrashLogScreenModel):
+        self.model = model
+        self.view = CrashLogScreenView(controller=self, model=self.model)
+        # self.update_anime_view()
+
+    def get_view(self) -> CrashLogScreenView:
+        return self.view

anixstream/Controller/downloads_screen.py

@@ -0,0 +1,15 @@
+
+from View import DownloadsScreenView
+from Model import DownloadsScreenModel
+
+
+class DownloadsScreenController:
+    """The controller for the download screen
+    """
+    def __init__(self, model:DownloadsScreenModel):
+        self.model = model
+        self.view = DownloadsScreenView(controller=self, model=self.model)
+
+    def get_view(self) -> DownloadsScreenView:
+        return self.view
+            

anixstream/Controller/help_screen.py

@@ -0,0 +1,14 @@
+
+from View import HelpScreenView
+from Model import HelpScreenModel
+
+
+class HelpScreenController:
+    """The help screen controller
+    """
+    def __init__(self, model:HelpScreenModel):
+        self.model = model
+        self.view = HelpScreenView(controller=self, model=self.model)
+
+    def get_view(self) -> HelpScreenView:
+        return self.view

anixstream/Controller/home_screen.py

@@ -0,0 +1,121 @@
+
+from inspect import isgenerator
+
+from kivy.clock import Clock
+from kivy.logger import Logger
+
+from View import HomeScreenView
+from Model import HomeScreenModel
+from View.components import MediaCardsContainer
+from Utility import show_notification
+
+
+# TODO:Move the update home screen to homescreen.py
+class HomeScreenController:
+    """
+    The `HomeScreenController` class represents a controller implementation.
+    Coordinates work of the view with the model.
+    The controller implements the strategy pattern. The controller connects to
+    the view to control its actions.
+    """
+    populate_errors = []
+
+    def __init__(self, model:HomeScreenModel):
+        self.model = model  # Model.main_screen.MainScreenModel
+        self.view = HomeScreenView(controller=self, model=self.model)
+        # if self.view.app.config.get("Preferences","is_startup_anime_enable")=="1": # type: ignore
+        #     Clock.schedule_once(lambda _:self.populate_home_screen())
+
+    def get_view(self) -> HomeScreenView:
+        return self.view
+
+    def popular_anime(self):
+        most_popular_cards_container = MediaCardsContainer()
+        most_popular_cards_container.list_name = "Most Popular"
+        most_popular_cards_generator = self.model.get_most_popular_anime()
+        if isgenerator(most_popular_cards_generator):
+            for card in most_popular_cards_generator:
+                card.screen = self.view
+                most_popular_cards_container.container.add_widget(card)
+            self.view.main_container.add_widget(most_popular_cards_container)
+        else:
+            Logger.error("Home Screen:Failed to load most popular anime")
+            self.populate_errors.append("Most Popular Anime")
+
+    def favourite_anime(self):
+        most_favourite_cards_container = MediaCardsContainer()
+        most_favourite_cards_container.list_name = "Most Favourites"
+        most_favourite_cards_generator = self.model.get_most_favourite_anime()
+        if isgenerator(most_favourite_cards_generator):
+            for card in most_favourite_cards_generator:
+                card.screen = self.view
+                most_favourite_cards_container.container.add_widget(card)
+            self.view.main_container.add_widget(most_favourite_cards_container)
+        else:
+            Logger.error("Home Screen:Failed to load most favourite anime")
+            self.populate_errors.append("Most favourite Anime")
+
+    def trending_anime(self):
+        trending_cards_container = MediaCardsContainer()
+        trending_cards_container.list_name = "Trending"
+        trending_cards_generator = self.model.get_trending_anime()
+        if isgenerator(trending_cards_generator):
+            for card in trending_cards_generator:
+                card.screen = self.view
+                trending_cards_container.container.add_widget(card)
+            self.view.main_container.add_widget(trending_cards_container)
+        else:
+            Logger.error("Home Screen:Failed to load trending anime")
+            self.populate_errors.append("trending Anime")
+
+    def highest_scored_anime(self):        
+        most_scored_cards_container = MediaCardsContainer()
+        most_scored_cards_container.list_name = "Most Scored"
+        most_scored_cards_generator = self.model.get_most_scored_anime()
+        if isgenerator(most_scored_cards_generator):
+            for card in most_scored_cards_generator:
+                card.screen = self.view
+                most_scored_cards_container.container.add_widget(card)
+            self.view.main_container.add_widget(most_scored_cards_container)
+        else:
+            Logger.error("Home Screen:Failed to load highest scored anime")
+            self.populate_errors.append("Most scored Anime")
+
+    def recently_updated_anime(self):
+        most_recently_updated_cards_container = MediaCardsContainer()
+        most_recently_updated_cards_container.list_name = "Most Recently Updated"
+        most_recently_updated_cards_generator = self.model.get_most_recently_updated_anime()
+        if isgenerator(most_recently_updated_cards_generator):
+            for card in most_recently_updated_cards_generator:
+                card.screen = self.view
+                most_recently_updated_cards_container.container.add_widget(card)
+            self.view.main_container.add_widget(most_recently_updated_cards_container)
+        else:
+            Logger.error("Home Screen:Failed to load recently updated anime")
+            self.populate_errors.append("Most recently updated Anime")
+
+    def upcoming_anime(self):        
+        upcoming_cards_container = MediaCardsContainer()
+        upcoming_cards_container.list_name = "Upcoming Anime"
+        upcoming_cards_generator = self.model.get_upcoming_anime()
+        if isgenerator(upcoming_cards_generator):
+            for card in upcoming_cards_generator:
+                card.screen = self.view
+                upcoming_cards_container.container.add_widget(card)
+            self.view.main_container.add_widget(upcoming_cards_container)
+        else:
+            Logger.error("Home Screen:Failed to load upcoming anime")
+            self.populate_errors.append("upcoming Anime")
+
+    def populate_home_screen(self):
+        self.populate_errors = []
+        Clock.schedule_once(lambda _:self.trending_anime(),1)
+        Clock.schedule_once(lambda _:self.highest_scored_anime(),2)
+        Clock.schedule_once(lambda _:self.popular_anime(),3)
+        Clock.schedule_once(lambda _: self.favourite_anime(),4)
+        Clock.schedule_once(lambda _:self.recently_updated_anime(),5)
+        Clock.schedule_once(lambda _:self.upcoming_anime(),6)
+
+        if self.populate_errors:
+            show_notification(f"Failed to fetch all home screen data",f"Theres probably a problem with your internet connection or anilist servers are down.\nFailed include:{', '.join(self.populate_errors)}")
+

anixstream/Controller/my_list_screen.py

@@ -0,0 +1,53 @@
+from inspect import isgenerator
+
+from kivy.logger import Logger
+# from kivy.clock import Clock
+from kivy.utils import difference
+
+from View import MyListScreenView
+from Model import MyListScreenModel
+from Utility import user_data_helper
+
+class MyListScreenController:
+    """
+    The `MyListScreenController` class represents a controller implementation.
+    Coordinates work of the view with the model.
+    The controller implements the strategy pattern. The controller connects to
+    the view to control its actions.
+    """
+
+    def __init__(self, model:MyListScreenModel):
+        self.model = model  
+        self.view = MyListScreenView(controller=self, model=self.model)
+        if len(self.requested_update_my_list_screen())>30:
+            self.requested_update_my_list_screen(2)
+
+    def get_view(self) -> MyListScreenView:
+        return self.view
+
+    def requested_update_my_list_screen(self,page=None):
+        user_anime_list = user_data_helper.get_user_anime_list()
+        if animes_to_add:=difference(user_anime_list,self.model.already_in_user_anime_list):
+            Logger.info("My List Screen:User anime list change;updating screen")
+            # if thirty:=len(animes_to_add)>30:            
+            #     self.model.already_in_user_anime_list = user_anime_list[:30]
+            # else:
+            
+            anime_cards = self.model.update_my_anime_list_view(animes_to_add,page)
+            self.model.already_in_user_anime_list = user_anime_list
+
+            if isgenerator(anime_cards):
+                for result_card in anime_cards:
+                    result_card.screen = self.view
+                    self.view.update_layout(result_card)
+            return animes_to_add
+        elif page:
+            anime_cards = self.model.update_my_anime_list_view(self.model.already_in_user_anime_list,page)
+            # self.model.already_in_user_anime_list = user_anime_list
+            if isgenerator(anime_cards):
+                for result_card in anime_cards:
+                    result_card.screen = self.view
+                    self.view.update_layout(result_card)
+            return []
+        else:
+            return []

anixstream/Controller/search_screen.py

@@ -0,0 +1,47 @@
+from inspect import isgenerator
+
+from kivy.clock import Clock
+from kivy.logger import Logger
+
+from View import SearchScreenView
+from Model import SearchScreenModel
+
+
+class SearchScreenController:
+    """The search screen controller
+    """
+
+    def __init__(self, model: SearchScreenModel):
+        self.model = model
+        self.view = SearchScreenView(controller=self, model=self.model)
+
+    def get_view(self) -> SearchScreenView:
+        return self.view
+
+    def update_trending_anime(self):
+        """Gets and adds the trending anime to the search screen
+        """
+        trending_cards_generator = self.model.get_trending_anime()
+        if isgenerator(trending_cards_generator):
+            self.view.trending_anime_sidebar.clear_widgets()
+            for card in trending_cards_generator:
+                card.screen = self.view
+                card.pos_hint = {"center_x": 0.5}
+                self.view.update_trending_sidebar(card)
+        else:
+            Logger.error("Home Screen:Failed to load trending anime")
+
+    def requested_search_for_anime(self, anime_title, **kwargs):
+        self.view.is_searching = True
+        search_Results = self.model.search_for_anime(anime_title, **kwargs)
+        if isgenerator(search_Results):
+            for result_card in search_Results:
+                result_card.screen = self.view
+                self.view.update_layout(result_card)
+            Clock.schedule_once(
+                lambda _: self.view.update_pagination(self.model.pagination_info)
+            )
+            self.update_trending_anime()
+        else:
+            Logger.error(f"Home Screen:Failed to search for {anime_title}")
+        self.view.is_searching = False