Sort search results

README.md

@@ -89,6 +89,7 @@ termux-setup-storage
 - [x] Browsing
   - [x] Descriptions
 - [x] Watching
+  - [ ] Trailer
   - [x] Automatically start next episode
   - [x] Discord Presence **Very WIP**
   - [MPV] only
@@ -241,6 +242,10 @@ Place your custom CSS in `user_config_path("gucken").joinpath("custom.css")` and
 - [ ] More CLI args
 - [ ] reverse proxy
 - [ ] Chapters for VLC
+- [ ] DoH support
+- [ ] More threads and asyncio.gather to make everything faster
+- [ ] Watchlist
+- [ ] Notifications
 
 [Anime4k]: https://github.com/bloc97/Anime4K
 [MPV]: https://mpv.io/

src/gucken/__init__.py

@@ -1 +1 @@
-__version__ = "0.1.10"
+__version__ = "0.1.11"

src/gucken/gucken.py

@@ -14,6 +14,7 @@
 from time import sleep, time
 from typing import ClassVar, List, Union
 
+from fuzzywuzzy import fuzz
 from platformdirs import user_config_path, user_log_path
 from pypresence import AioPresence, DiscordNotFound
 from rich.markup import escape
@@ -479,19 +480,21 @@ async def lookup_anime(self, keyword: str) -> None:
                 for e in l:
                     final_results.append(e)
 
-        # TODO: Sort final_results with fuzzy-sort
-        # from fuzzywuzzy import process process.extract()
+        def fuzzy_sort_key(result):
+            return fuzz.ratio(keyword, result.name)
+
+        final_results = sorted(final_results, key=fuzzy_sort_key, reverse=True)
         if len(final_results) > 0:
             self.current = final_results
+            items = []
             for series in final_results:
-                # TODO: show provider
-                await results_list_view.append(
-                    ClickableListItem(
+                items.append(ClickableListItem(
                         Markdown(
-                            f"##### {series.name} {series.production_year}\n{series.description}"
+                            f"##### {series.name} {series.production_year} [{series.provider_name}]"
+                            f"\n{series.description}"
                         )
-                    )
-                )
+                    ))
+            await results_list_view.extend(items)
         results_list_view.loading = False
         if len(final_results) > 0:
 
@@ -598,7 +601,7 @@ async def update_check(self):
     async def play(
             self, series_search_result: SearchResult, episodes: list[Episode], index: int
     ) -> None:
-        p = self.query_one("#player", Select).value
+        p = gucken_settings_manager.settings["settings"]["player"]["player"]
         if p == Select.BLANK:
             _player = self.detected_player
         else:
@@ -637,9 +640,8 @@ async def play(
         direct_link = await get_working_direct_link(sorted_hoster)
 
         # TODO: check for header support
-        # TODO: pass ani_skip as script
-        syncplay = self.query_one("#syncplay", RadioButton).value
-        fullscreen = self.query_one("#fullscreen", RadioButton).value
+        syncplay = gucken_settings_manager.settings["settings"]["syncplay"]
+        fullscreen = gucken_settings_manager.settings["settings"]["fullscreen"]
 
         title = f"{series_search_result.name} S{episode.season}E{episode.episode_number} - {episode.title}"
         args = _player.play(direct_link.url, title, fullscreen, direct_link.headers)
@@ -675,9 +677,9 @@ async def update():
         # TODO: Support based on mpv
         # TODO: recover start --start=00:56
         if isinstance(_player, MPVPlayer) or isinstance(_player, VLCPlayer):
-            ani_skip_opening = self.query_one("#ani_skip_opening", RadioButton).value
-            ani_skip_ending = self.query_one("#ani_skip_ending", RadioButton).value
-            ani_skip_chapters = self.query_one("#ani_skip_chapters", RadioButton).value
+            ani_skip_opening = gucken_settings_manager.settings["settings"]["ani_skip"]["skip_opening"]
+            ani_skip_ending = gucken_settings_manager.settings["settings"]["ani_skip"]["skip_ending"]
+            ani_skip_chapters = gucken_settings_manager.settings["settings"]["ani_skip"]["chapters"]
 
             if ani_skip_opening or ani_skip_ending or ani_skip_chapters:
                 timings = await get_timings_from_search(
@@ -821,7 +823,7 @@ async def play_next(should_next):
                         callback=play_next,
                     )
 
-                autoplay = self.query_one("#autoplay", RadioButton).value
+                autoplay = gucken_settings_manager.settings["settings"]["autoplay"]["enabled"]
                 if not len(episodes) <= index + 1:
                     if autoplay is True:
                         self.app.call_later(push_next_screen)

src/gucken/provider/aniworld.py

@@ -95,14 +95,18 @@ class AniWorldSeries(Series):
     tags: set[str]
 
     def to_markdown(self) -> str:
-        return (
-            f"# {self.name} {self.production_year}\n{self.full_description}\n\n"
-            f"**Regisseure**: {', '.join(self.regisseure)}\\\n"
-            f"**Schauspieler**: {', '.join(self.schauspieler)}\\\n"
-            f"**Produzent**: {', '.join(self.produzent)}\\\n"
-            f"**Land**: {', '.join(self.land)}\\\n"
-            f"**Tags**: {', '.join(self.tags)}"
-        )
+        string_builder = [f"# {self.name} {self.production_year}\n{self.full_description}\n\n"]
+        if len(self.regisseure) > 0:
+            string_builder.append(f"**Regisseure**: {', '.join(self.regisseure)}\\\n")
+        if len(self.schauspieler) > 0:
+            string_builder.append(f"**Schauspieler**: {', '.join(self.schauspieler)}\\\n")
+        if len(self.produzent) > 0:
+            string_builder.append(f"**Produzent**: {', '.join(self.produzent)}\\\n")
+        if len(self.land) > 0:
+            string_builder.append(f"**Land**: {', '.join(self.land)}\\\n")
+        if len(self.tags) > 0:
+            string_builder.append(f"**Tags**: {', '.join(self.tags)}")
+        return "".join(string_builder)
 
 
 @dataclass
@@ -136,6 +140,7 @@ async def search(keyword: str) -> Union[list[AniWorldSearchResult], None]:
             for series in results:
                 search_results.append(
                     AniWorldSearchResult(
+                        provider_name="aniworld.to",
                         name=unescape(series.get("name")).strip(),
                         link=series.get("link"),
                         description=unescape(series.get("description")),

src/gucken/provider/common.py

@@ -53,6 +53,7 @@ class SearchResult:
     name: str
     description: str = None
     cover: str = None
+    provider_name: str = None
 
     @abstractmethod
     async def get_series(self) -> Series:

src/gucken/provider/serienstream.py

@@ -96,14 +96,18 @@ class SerienStreamSeries(Series):
     tags: set[str]
 
     def to_markdown(self) -> str:
-        return (
-            f"# {self.name} {self.production_year}\n{self.full_description}\n\n"
-            f"**Regisseure**: {', '.join(self.regisseure)}\\\n"
-            f"**Schauspieler**: {', '.join(self.schauspieler)}\\\n"
-            f"**Produzent**: {', '.join(self.produzent)}\\\n"
-            f"**Land**: {', '.join(self.land)}\\\n"
-            f"**Tags**: {', '.join(self.tags)}"
-        )
+        string_builder = [f"# {self.name} {self.production_year}\n{self.full_description}\n\n"]
+        if len(self.regisseure) > 0:
+            string_builder.append(f"**Regisseure**: {', '.join(self.regisseure)}\\\n")
+        if len(self.schauspieler) > 0:
+            string_builder.append(f"**Schauspieler**: {', '.join(self.schauspieler)}\\\n")
+        if len(self.produzent) > 0:
+            string_builder.append(f"**Produzent**: {', '.join(self.produzent)}\\\n")
+        if len(self.land) > 0:
+            string_builder.append(f"**Land**: {', '.join(self.land)}\\\n")
+        if len(self.tags) > 0:
+            string_builder.append(f"**Tags**: {', '.join(self.tags)}")
+        return "".join(string_builder)
 
 
 @dataclass
@@ -137,6 +141,7 @@ async def search(keyword: str) -> Union[list[SerienStreamSearchResult], None]:
             for series in results:
                 search_results.append(
                     SerienStreamSearchResult(
+                        provider_name="serienstream.to",
                         name=unescape(series.get("name")).strip(),
                         link=series.get("link"),
                         description=unescape(series.get("description")),