anipy-cli 2.7.17__py3-none-any.whl → 3.8.2__py3-none-any.whl

anipy_cli/misc.py

@@ -1,227 +0,0 @@
-import os
-import requests
-import sys
-import json
-import time
-from pypresence import Presence
-from pypresence.exceptions import DiscordNotFound
-from bs4 import BeautifulSoup
-from dataclasses import dataclass
-from typing import Union
-
-from anipy_cli.config import Config
-from anipy_cli.colors import colors, color, cprint
-
-
-@dataclass
-class Entry:
-    """
-    This is the class that saves
-    metadata about a show.
-    """
-
-    show_name: str = ""
-    category_url: str = ""
-    ep_url: str = ""
-    embed_url: str = ""
-    stream_url: str = ""
-    ep: Union[int, float] = 0
-    latest_ep: Union[int, float] = 0
-    quality: str = ""
-
-
-def clear_console():
-    os.system("cls" if os.name == "nt" else "clear")
-
-
-def error(error: str) -> None:
-    """
-    Error function for better error handling,
-    that takes an error and prints it to stderr.
-    """
-    sys.stderr.write(color(colors.ERROR, "anipy-cli: error: " + error) + "\n")
-
-
-def response_err(req, link) -> None:
-    """
-    Function that checks if a request
-    was succesfull.
-    """
-    if req.ok:
-        pass
-    else:
-        error(
-            f"requested url not available/blocked: {link}: response-code: {req.status_code}"
-        )
-        sys.exit()
-
-
-def loc_err(soup, link: str, element: str) -> None:
-    """
-    Function that checks if beautifulsoup
-    could locate an element.
-    """
-    if soup == None:
-        error(f"could not locate {element}: {link}")
-        sys.exit()
-
-
-def keyboard_inter() -> None:
-    cprint(colors.ERROR, "\nanipy-cli: error: interrupted")
-    sys.exit()
-
-
-def parsenum(n: str):
-    """
-    Parse String to either
-    int or float.
-    """
-
-    try:
-        return int(n)
-    except ValueError:
-        return float(n)
-
-
-def read_json(path):
-    """
-    Read a json file, if
-    it doesn't exist create it,
-    along with user_files folder.
-    """
-    while True:
-        try:
-            with open(path, "r") as data:
-                json_data = json.load(data)
-            break
-
-        except FileNotFoundError:
-            try:
-                Config().user_files_path.mkdir(exist_ok=True, parents=True)
-                path.touch(exist_ok=True)
-                # avoids error on empty json file
-                with path.open("a") as f:
-                    f.write("{}")
-                continue
-
-            except PermissionError:
-                error(f"Unable to create {path} due to permissions.")
-                sys.exit()
-
-    return json_data
-
-
-def print_names(names):
-    """
-    Cli function that takes a
-    list of names and prints
-    them to the terminal.
-    """
-    for number, value in enumerate(names, 1):
-        value_color = colors.END
-        if number % 2 == 0:
-            value_color = colors.YELLOW
-
-        cprint(colors.GREEN, f"[{number}] ", value_color, value)
-
-
-def get_anime_info(category_url: str) -> dict:
-    """
-    Get metadata about an anime.
-    """
-    r = requests.get(category_url)
-    soup = BeautifulSoup(r.text, "html.parser")
-    info_body = soup.find("div", {"class": "anime_info_body_bg"})
-    image_url = info_body.find("img")["src"]
-    other_info = info_body.find_all("p", {"class": "type"})
-    info_dict = {
-        "image_url": image_url,
-        "type": other_info[0].text.replace("\n", "").replace("Type: ", ""),
-        "synopsis": other_info[1].text.replace("\n", ""),
-        "genres": [
-            x["title"]
-            for x in BeautifulSoup(str(other_info[2]), "html.parser").find_all("a")
-        ],
-        "release_year": other_info[3].text.replace("Released: ", ""),
-        "status": other_info[4].text.replace("\n", "").replace("Status: ", ""),
-    }
-
-    return info_dict
-
-
-def search_in_season_on_gogo(s_year, s_name):
-    page = 1
-    content = True
-    gogo_anime_season_list = []
-    while content:
-        r = requests.get(
-            f"{Config().gogoanime_url}/sub-category/{s_name}-{s_year}-anime",
-            params={"page": page},
-        )
-        soup = BeautifulSoup(r.content, "html.parser")
-        wrapper_div = soup.find("div", attrs={"class": "last_episodes"})
-        try:
-            anime_items = wrapper_div.findAll("li")
-            for link in anime_items:
-                link_a = link.find("p", attrs={"class": "name"}).find("a")
-                name = link_a.get("title")
-                gogo_anime_season_list.append(
-                    {
-                        "name": name,
-                        "category_url": "{}{}".format(
-                            Config().gogoanime_url, link_a.get("href")
-                        ),
-                    }
-                )
-
-        except AttributeError:
-            content = False
-
-        page += 1
-    filtered_list = filter_anime_list_dub_sub(gogo_anime_season_list)
-
-    return filtered_list
-
-
-def filter_anime_list_dub_sub(gogo_anime_season_list):
-    if "sub" not in Config().anime_types and "dub" in Config().anime_types:
-        filtered_list = [
-            x for x in gogo_anime_season_list if "(dub)" in x["name"].lower()
-        ]
-
-    elif "dub" not in Config().anime_types and "sub" in Config().anime_types:
-        filtered_list = [
-            x for x in gogo_anime_season_list if "(dub)" not in x["name"].lower()
-        ]
-
-    else:
-        filtered_list = gogo_anime_season_list
-    return filtered_list
-
-
-def dc_presence_connect():
-    CLIENT_ID = 966365883691855942
-    rpc_client = None
-    try:
-        rpc_client = Presence(CLIENT_ID)
-        rpc_client.connect()
-        cprint(colors.GREEN, "Initialized Discord Presence Client")
-    except DiscordNotFound:
-        rpc_client = None
-        cprint(colors.RED, "Discord is not opened, can't initialize Discord Presence")
-    except ConnectionError:
-        rpc_client = None
-        cprint(colors.RED, "Can't Connect to discord.")
-
-    return rpc_client
-
-
-def dc_presence(media_title, category_url, rpc_client):
-    info = get_anime_info(category_url)
-    rpc_client.update(
-        details="Watching anime via anipy-cli",
-        state=media_title,
-        large_image=info["image_url"],
-        small_image="https://github.com/Dankni95/ulauncher-anime/raw/master/images/icon.png",
-        start=int(time.time()),
-    )

anipy_cli/player/__init__.py

@@ -1 +0,0 @@
-from anipy_cli.player.player import get_player, PlayerBaseType

anipy_cli/player/player.py

@@ -1,33 +0,0 @@
-import sys
-from typing import TypeVar
-
-from anipy_cli.config import Config
-from anipy_cli.misc import error
-from anipy_cli.player.players import Mpv, Vlc, Syncplay
-from anipy_cli.player.players.base import PlayerBase
-
-PlayerBaseType = TypeVar("PlayerBaseType", bound=PlayerBase)
-
-
-def get_player(rpc_client=None, player_override=None) -> PlayerBaseType:
-    cfg = Config()
-
-    player = player_override
-
-    if not player_override:
-        player = cfg.player_path
-
-    if player == "mpv" and cfg.reuse_mpv_window:
-        from anipy_cli.player.players.mpv_contrl import MpvControllable
-
-        return MpvControllable(rpc_client=rpc_client)
-
-    if player in ("mpv", "mpvnet"):
-        return Mpv(rpc_client=rpc_client, mpv_exec_name=player)
-    elif player == "vlc":
-        return Vlc(rpc_client=rpc_client)
-    elif player == "syncplay":
-        return Syncplay(rpc_client=rpc_client)
-    else:
-        error(f"Specified player `{player}` is unknown")
-        sys.exit()

anipy_cli/player/players/__init__.py

@@ -1,3 +0,0 @@
-from anipy_cli.player.players.mpv import Mpv
-from anipy_cli.player.players.vlc import Vlc
-from anipy_cli.player.players.syncplay import Syncplay

anipy_cli/player/players/base.py

@@ -1,106 +0,0 @@
-import os
-import subprocess as sp
-import sys
-from typing import List
-from abc import ABC, abstractmethod
-
-from anipy_cli.colors import cprint, colors
-from anipy_cli.history import history
-from anipy_cli.misc import dc_presence, Entry
-
-
-class PlayerBase(ABC):
-    @property
-    @abstractmethod
-    def rpc_client(self):
-        pass
-
-    @abstractmethod
-    def play_title(self, entry: Entry):
-        pass
-
-    @abstractmethod
-    def play_file(self, path: str):
-        pass
-
-    @abstractmethod
-    def wait(self):
-        pass
-
-    @abstractmethod
-    def kill_player(self):
-        pass
-
-    def _start_dc_presence(self, entry: Entry):
-        if self.rpc_client:
-            dc_media_title = f"{entry.show_name} | {entry.ep}/{entry.latest_ep}"
-            dc_presence(dc_media_title, entry.category_url, self.rpc_client)
-
-    @staticmethod
-    def _write_hist(entry: Entry):
-        history(entry).write_hist()
-
-    @staticmethod
-    def _get_media_title(entry: Entry):
-        return (
-            entry.show_name
-            + " - Episode: "
-            + str(entry.ep)
-            + " - "
-            + str(entry.quality)
-        )
-
-
-class SubProcessPlayerBase(PlayerBase):
-    def __init__(
-        self, player_args_template: List[str], player_exec: str, rpc_client=None
-    ):
-        self._rpc_client = rpc_client
-        self._sub_proc = None
-        self._player_args_template = player_args_template
-        self._player_exec = player_exec
-
-    @property
-    def rpc_client(self):
-        return self._rpc_client
-
-    def play_title(self, entry):
-        player_cmd = [
-            i.format(media_title=self._get_media_title(entry), **vars(entry))
-            for i in self._player_args_template
-        ]
-        player_cmd.insert(0, self._player_exec)
-
-        if isinstance(self._sub_proc, sp.Popen):
-            self.kill_player()
-
-        self._sub_proc = self._open_sproc(player_cmd)
-
-        self._write_hist(entry)
-        self._start_dc_presence(entry)
-
-    def play_file(self, path):
-        if isinstance(self._sub_proc, sp.Popen):
-            self.kill_player()
-
-        player_cmd = [self._player_exec, path]
-        self._sub_proc = self._open_sproc(player_cmd)
-
-    def wait(self):
-        self._sub_proc.wait()
-
-    def kill_player(self):
-        self._sub_proc.kill()
-
-    @staticmethod
-    def _open_sproc(player_command: List[str]) -> sp.Popen:
-        try:
-            if os.name in ("nt", "dos"):
-                sub_proc = sp.Popen(player_command)
-            else:
-                sub_proc = sp.Popen(player_command, stdout=sp.PIPE, stderr=sp.DEVNULL)
-        except FileNotFoundError as e:
-            cprint(colors.RED, "Error:" + str(e))
-            sys.exit()
-
-        return sub_proc

anipy_cli/player/players/mpv.py

@@ -1,19 +0,0 @@
-from anipy_cli.player.players.base import SubProcessPlayerBase
-from anipy_cli.config import Config
-
-
-class Mpv(SubProcessPlayerBase):
-    def __init__(self, rpc_client=None, mpv_exec_name: str = "mpv"):
-        player_args_template = [
-            "{stream_url}",
-            "--force-media-title={media_title}",
-            "--referrer={embed_url}",
-            "--force-window=immediate",
-            *Config().mpv_commandline_options,
-        ]
-
-        super().__init__(
-            player_args_template=player_args_template,
-            rpc_client=rpc_client,
-            player_exec=mpv_exec_name,
-        )

anipy_cli/player/players/mpv_contrl.py

@@ -1,37 +0,0 @@
-import mpv
-
-from anipy_cli.player.players.base import PlayerBase
-
-
-class MpvControllable(mpv.MPV, PlayerBase):
-    def __init__(self, rpc_client=None):
-        super().__init__(
-            input_default_bindings=True,
-            input_vo_keyboard=True,
-            force_window="immediate",
-            title="MPV - Receiving Links from anipy-cli",
-            osc=True,
-        )
-        self._rpc_client = rpc_client
-
-    @property
-    def rpc_client(self):
-        return self._rpc_client
-
-    def play_title(self, entry):
-        self.force_media_title = self._get_media_title(entry)
-
-        self.referrer = entry.embed_url
-        self.play(entry.stream_url)
-
-        self._write_hist(entry)
-        self._start_dc_presence(entry)
-
-    def play_file(self, path: str):
-        self.play(path)
-
-    def wait(self):
-        self.wait_for_playback()
-
-    def kill_player(self):
-        self.terminate()

anipy_cli/player/players/syncplay.py

@@ -1,19 +0,0 @@
-from anipy_cli.player.players.base import SubProcessPlayerBase
-from anipy_cli.config import Config
-
-
-class Syncplay(SubProcessPlayerBase):
-    def __init__(self, rpc_client=None):
-        self.player_exec = "syncplay"
-        player_args_template = [
-            "--" "--http-referrer='{embed_url}'",
-            "--meta-title='{media_title}'",
-            "{stream_url}",
-            *Config().mpv_commandline_options,
-        ]
-
-        super().__init__(
-            rpc_client=rpc_client,
-            player_exec=self.player_exec,
-            player_args_template=player_args_template,
-        )

anipy_cli/player/players/vlc.py

@@ -1,18 +0,0 @@
-from anipy_cli.player.players.base import SubProcessPlayerBase
-from anipy_cli.config import Config
-
-
-class Vlc(SubProcessPlayerBase):
-    def __init__(self, rpc_client=None):
-        player_args_template = [
-            "--http-referrer='{embed_url}'",
-            "--meta-title='{media_title}'",
-            "{stream_url}",
-            *Config().vlc_commandline_options,
-        ]
-
-        super().__init__(
-            rpc_client=rpc_client,
-            player_args_template=player_args_template,
-            player_exec="vlc",
-        )

anipy_cli/query.py

@@ -1,92 +0,0 @@
-import requests
-import re
-from bs4 import BeautifulSoup
-
-from anipy_cli.misc import loc_err, response_err, error, print_names
-from anipy_cli.colors import colors, cinput
-from anipy_cli.config import Config
-
-base_url = Config().gogoanime_url
-
-
-class query:
-    """
-    Class to get query results
-    from a search parameter.
-    Takes an empty entry or one
-    with fields filled.
-    """
-
-    def __init__(self, search_param, entry) -> None:
-        self.entry = entry
-        self.search_url = base_url + f"/search.html?keyword={search_param}"
-        r = requests.get(self.search_url)
-        response_err(r, self.search_url)
-        self.soup = BeautifulSoup(r.content, "html.parser")
-
-    def get_pages(self):
-        """Get count of result pages of query"""
-        pages = self.soup.find_all(
-            "a", attrs={"data-page": re.compile(r"^ *\d[\d ]*$")}
-        )
-        loc_err(pages, self.search_url, "page-count")
-        pages = [x.get("data-page") for x in pages]
-        try:
-            self.pages = int(pages[-1])
-        except:
-            self.pages = 1
-
-    def get_links(self):
-        """
-        Get all category links and names of a query
-        and returns them.
-        """
-        self.get_pages()
-        self.links = []
-        self.names = []
-        for i in range(self.pages):
-            req_link = self.search_url + f"&page={i + 1}"
-            r = requests.get(req_link)
-            response_err(r, req_link)
-            self.soup = BeautifulSoup(r.content, "html.parser")
-
-            for link in self.soup.find_all("p", attrs={"class": "name"}):
-                name_lower = link.text.lower()
-                if len(Config().anime_types) == 1:
-                    if "sub" in Config().anime_types and "(dub)" in name_lower:
-                        continue
-                    elif "dub" in Config().anime_types and "(dub)" not in name_lower:
-                        continue
-
-                loc_err(link, req_link, "query results")
-                self.names.append(link.text.replace("\n", ""))
-                a_tag = link.findChildren("a", recursive=False)
-                self.links.append(a_tag[0].get("href"))
-
-        if not self.links:
-            return 0
-        else:
-            return self.links, self.names
-
-    def pick_show(self, cancelable=False):
-        """
-        Cli Function that
-        Lets you pick a show from
-        yout query, filles the category_url
-        field from the entry and returns it.
-        """
-        print_names(self.names)
-        if cancelable:
-            print(f"{colors.GREEN}[C] {colors.YELLOW} Cancel.")
-        while True:
-            inp = cinput("Enter Number: ", colors.CYAN)
-            try:
-                self.entry.category_url = base_url + self.links[int(inp) - 1]
-                self.entry.show_name = self.names[int(inp) - 1]
-                break
-            except:
-                if cancelable and inp.lower() == "c":
-                    return False
-                error("Invalid Input")
-
-        return self.entry

anipy_cli/run_anipy_cli.py

@@ -1,14 +0,0 @@
-#!/bin/python
-from anipy_cli import cli
-from anipy_cli.misc import keyboard_inter
-
-
-def main():
-    try:
-        cli.run_cli()
-    except KeyboardInterrupt:
-        keyboard_inter()
-
-
-if __name__ == "__main__":
-    main()

anipy_cli/seasonal.py

@@ -1,106 +0,0 @@
-import json
-import sys
-
-from anipy_cli.config import Config
-from anipy_cli.url_handler import epHandler
-from anipy_cli.misc import Entry, error, read_json
-
-
-class Seasonal:
-    def __init__(self):
-        self.entry = Entry()
-
-    def latest_eps(self):
-        """
-        returns a dict like so:
-            {"name": {
-                "ep_list": [[ep, ep-link], [], ...],
-                "category_url": "https://"
-                },
-             "another anime": {
-                 ...
-                },
-            }
-        """
-
-        self.read_save_data()
-        names = [i for i in self.json]
-        categ_urls = []
-        user_eps = []
-        for i in names:
-            categ_urls.append(self.json[i]["category_url"])
-            user_eps.append(self.json[i]["ep"])
-
-        latest_urls = {}
-        for i, e, n in zip(categ_urls, user_eps, names):
-            self.entry.category_url = i
-            ep_class = epHandler(self.entry)
-            latest = ep_class.get_latest()
-            eps_range = list(range(e + 1, latest + 1))
-            ep_urls = []
-            for j in eps_range:
-                self.entry.ep = j
-                ep_class = epHandler(self.entry)
-                entry = ep_class.gen_eplink()
-                ep_urls.append([j, entry.ep_url])
-
-            latest_urls.update({n: {"ep_list": ep_urls, "category_url": i}})
-
-        return latest_urls
-
-    def read_save_data(self):
-        self.json = read_json(Config().seasonal_file_path)
-
-    def write_seasonals(self):
-        try:
-            with Config().seasonal_file_path.open("w") as f:
-                json.dump(self.json, f, indent=4)
-
-        except PermissionError:
-            error("Unable to write to history file due permissions.")
-            sys.exit()
-
-    def update_show(self, name, categ_url, ep=None):
-        self.read_save_data()
-
-        if name not in [x for x in self.json]:
-            return 0
-
-        self.entry.category_url = categ_url
-        if ep is not None:
-            self.json[name]["ep"] = ep
-
-        else:
-            self.json[name]["ep"] = epHandler(self.entry).get_latest()
-        self.write_seasonals()
-
-    def add_show(self, name, categ_url, start_ep):
-        self.read_save_data()
-
-        if name in [x for x in self.json]:
-            return 0
-
-        dic = {name: {"ep": start_ep, "category_url": categ_url}}
-
-        self.json.update(dic)
-        self.write_seasonals()
-
-    def del_show(self, name):
-        self.read_save_data()
-
-        if name not in [x for x in self.json]:
-            return 0
-
-        self.json.pop(name)
-        self.write_seasonals()
-
-    def list_seasonals(self):
-        self.read_save_data()
-
-        return [[i, self.json[i]["ep"]] for i in self.json]
-
-    def export_seasonals(self):
-        self.read_save_data()
-        return [
-            [i, self.json[i]["category_url"], self.json[i]["ep"]] for i in self.json
-        ]