4 |
5 | ### What's new:
6 |
7 | - `get_episode_link` is now seperated into `get_episode_link_basic` and `get_episode_link_advanced`. If gogoanime enables the captcha for the links, use `get_episode_link_advanced` else use `get_episode_link_basic` method.
8 |
9 | > Note: You still need to initialize the `AniKimi` class to get stuffs.
10 |
11 | ### Enhancements:
12 |
13 | - Reduced the CPU usage as compared to previous releases.
14 |
15 | ### Bug Fixes:
16 | - Fixed some wrong regex patterns.
17 |
18 | > Note: You should rewrite the API part of your app to function properly. I'm really sorry becoz you must rewrite your code to make your app support the latest release.
19 |
20 |
21 | ## v0.1.3-beta (01.08.2021)
22 |
23 | ### Enhancements:
24 |
25 | - Little touch-up for the code.
26 |
27 | ### Bug Fixes:
28 | - Removed an unwanted dependency "validtors".
29 |
30 |
31 | ## v0.1.1-beta (30.07.2021)
32 |
33 | ### What's new:
34 |
35 | - Initial Release of the API Wrapper.
36 | - Advanced Captcha Bypass is supported.
--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
1 | GNU GENERAL PUBLIC LICENSE
2 | Version 3, 29 June 2007
3 |
4 | Copyright (C) 2007 Free Software Foundation, Inc. AniKimi API v0.1.4
2 |A Simple, LightWeight, Statically-Typed Python3 API wrapper for GogoAnime
3 | The v2 of gogoanimeapi (depreciated)
4 | Made with JavaScript and Python3
5 |
6 | ###
7 |
8 |
9 | 
10 | 
11 | 
12 | 
13 | 
14 | 
15 | 
16 |
17 |
18 | ###
19 |
20 | ### Features of AniKimi
21 | * Custom url changing option.
22 | * Statically-Typed, No more annoying JSON responses.
23 | * Autocomplete supported by most IDE's.
24 | * Complete solution.
25 | * Faster response.
26 | * Less CPU consumption.
27 |
28 | ### Installing
29 | Using Pypi
30 |
31 | ```$ pip3 install anikimiapi```
32 |
33 | ### Getting Started
34 | #### Pre-Requisites
35 | * #### Getting Required Tokens
36 | * Visit the GogoAnime Website.
37 | * Login or SignUp using ur email or google.
38 | * Add an extension to your browser named [Get cookies.txt](https://chrome.google.com/webstore/detail/get-cookiestxt/bgaddhkoddajcdgocldbbfleckgcbcid?hl=en).
39 | * Now in the GogoAnime Website, right click and select "Get cookies.txt". [Refer Image](https://github.com/BaraniARR/anikimiapi/blob/main/assets/1.jpg).
40 | * A `.txt` file will be downloaded.
41 | * In the `.txt` file, find the name "gogoanime" and "auth". [Refer Image](https://github.com/BaraniARR/anikimiapi/blob/main/assets/2.jpg).
42 | * Copy the respective tokens on the right side of the above names.
43 | * Keep it safely, since its your private credentials.
44 |
45 | ### Diving into the API
46 | ###
47 | #### Authorize the API
48 | To Authorize the API, use AniKimi class. You can also import it from other files. It also supports cross imports. But all API request should be made using this class only.
49 | ```python3
50 | from anikimiapi import AniKimi
51 |
52 | # Initialize AniKimi class
53 | anime = AniKimi(
54 | gogoanime_token="the saved gogoanime token",
55 | auth_token="the saved auth token",
56 | host="https://gogoanime.pe/"
57 | )
58 | ```
59 | ###
60 | >**Note:** If GogoAnime changes their domain, use the 'host' parameter. Otherwise, leave it blank. This parameter was optional and defaults to https://gogoanime.pe/
61 | ###
62 | #### Getting Anime search results
63 | You can search anime by using `search_anime` method, It returns the search results as `ResultObject` which contains two arguments, the `title` and `animeid`.
64 | ```python3
65 | from anikimiapi import AniKimi
66 |
67 | anime = AniKimi(
68 | gogoanime_token="the saved gogoanime token",
69 | auth_token="the saved auth token"
70 | )
71 |
72 | # Search Anime
73 | results = anime.search_anime(query="tokikaku kawaii")
74 |
75 | for i in results:
76 | print(i.title) # (or)
77 | print(i.animeid)
78 | ```
79 |
80 | ###
81 | >**Note:** If no search results found, the API will raise `NoSearchResultsError` error. Make sure to handle it.
82 | ###
83 | #### Getting details of a specific Anime
84 | You can the basic information about a specific anime with `animeid` using `get_details` method. It will return anime details as `MediaInfoObject`.
85 |
86 | The `MediaInfoObject` contains the following arguments,
87 | * title
88 | * other_names
89 | * season
90 | * year
91 | * status
92 | * genres
93 | * episodes
94 | * image_url
95 | * summary
96 | ```python
97 | from anikimiapi import AniKimi
98 |
99 | anime = AniKimi(
100 | gogoanime_token="the saved gogoanime token",
101 | auth_token="the saved auth token"
102 | )
103 |
104 | # Get anime Details
105 | details = anime.get_details(animeid="clannad-dub")
106 | print(details.title)
107 | print(details.genres) # And many more...
108 | ```
109 |
110 | ###
111 | >**Note:** If an Invalid `animeid` is given, the API will raise `InvalidAnimeIdError`. Make sure to handle it.
112 | ###
113 | #### Getting the Anime Links
114 | You can simply get the streamable and downloadable links of a specific episode of an Anime by its `animeid` and `episode_num` using `get_episode_link` method. It will return anime links in `MediaLinksObject`.
115 |
116 | The `MediaLinksObject` returns the links, if available. Otherwise, it will return `None`. The `MediaLinksObject` has the following arguments,
117 | * link_hdp
118 | * link_sdp
119 | * link_360p
120 | * link_480p
121 | * link_720p
122 | * link_1080p
123 | * link_streamsb
124 | * link_xstreamcdn
125 | * link_streamtape
126 | * link_mixdrop
127 | * link_mp4upload
128 | * link_doodstream
129 | ```python3
130 | from anikimiapi import AniKimi
131 |
132 | anime = AniKimi(
133 | gogoanime_token="the saved gogoanime token",
134 | auth_token="the saved auth token"
135 | )
136 |
137 | # Getting Anime Links basic method
138 | anime_link = anime.get_episode_link_basic(animeid="clannad-dub", episode_num=3)
139 |
140 | print(anime_link.link_hdp)
141 | print(anime_link.link_720p)
142 | print(anime_link.link_streamsb) # And many more...
143 |
144 | # Getting Anime Links advanced method
145 | anime_link = anime.get_episode_link_advanced(animeid="clannad-dub", episode_num=3)
146 |
147 | print(anime_link.link_hdp)
148 | print(anime_link.link_720p)
149 | print(anime_link.link_streamsb) # And many more...
150 | ```
151 | ###
152 | >**Note:** If invalid `animeid` or `episode_num` is passed, the API will return `InvalidAnimeIdError`. Make sure to handle it.
153 | >
154 | > If the given `gogoanime_token` and `auth_token` are invalid, the API will raise `InvalidTokenError`. So, be careful of that.
155 | ###
156 | #### Getting a List of anime by Genre
157 | You can also get the List of anime by their genres using `get_by_genres` method. This method will return results as a List of `ResultObject`.
158 |
159 | Currently, the following genres are supported,
160 | * action
161 | * adventure
162 | * cars
163 | * comedy
164 | * dementia
165 | * demons
166 | * drama
167 | * dub
168 | * ecchi
169 | * fantasy
170 | * game
171 | * harem
172 | * hentai - Temporarily Unavailable
173 | * historical
174 | * horror
175 | * josei
176 | * kids
177 | * magic
178 | * martial-arts
179 | * mecha
180 | * military
181 | * music
182 | * mystery
183 | * parody
184 | * police
185 | * psychological
186 | * romance
187 | * samurai
188 | * school
189 | * sci-fi
190 | * seinen
191 | * shoujo
192 | * shoujo-ai
193 | * shounen-ai
194 | * shounen
195 | * slice-of-life
196 | * space
197 | * sports
198 | * super-power
199 | * supernatural
200 | * thriller
201 | * vampire
202 | * yaoi
203 | * yuri
204 | ```python
205 | from anikimiapi import AniKimi
206 |
207 | anime = AniKimi(
208 | gogoanime_token="the saved gogoanime token",
209 | auth_token="the saved auth token"
210 | )
211 |
212 | # Getting anime list by genres
213 | gen = anime.get_by_genres(genre_name="romance", page=1)
214 |
215 | for result in gen:
216 | print(result.title)
217 | print(result.animeid)
218 | ```
219 | ###
220 | >**Note:** If invalid `genre_name` or `page` is passed, the API will raise `InvalidGenreNameError`. Make sure to handle it.
221 | ###
222 | #### Getting List of Airing Anime (v2 API New Feature)
223 | You can get a List of currently Airing Anime using `get_airing_anime` method. This method will return results as a List of `ResultObject`.
224 | ```python
225 | from anikimiapi import AniKimi
226 |
227 | anime = AniKimi(
228 | gogoanime_token="the saved gogoanime token",
229 | auth_token="the saved auth token"
230 | )
231 |
232 | # Getting Airing Anime List
233 | airing = anime.get_airing_anime(count=15)
234 | for i in airing:
235 | print(i.title)
236 | print(i.animeid)
237 | ```
238 | ###
239 | >**Note:** If the value of count exceeds 20, The API will raise `AiringIndexError`. So, pass a value less than or equal to 20.
240 |
241 | # Copyrights ©2021 BaraniARR;
242 | ### Licensed under GNU GPLv3 Licnense;
243 |
--------------------------------------------------------------------------------
/README_PYPI.md:
--------------------------------------------------------------------------------
1 |
10 |
11 |
12 |
13 |
14 |
15 |
16 | AniKimi API
2 |A Simple, LightWeight, Statically-Typed Python3 API wrapper for GogoAnime
3 | The v2 of gogoanimeapi (depreciated)
4 | Made with JavaScript and Python3
5 |
6 |
7 | ###
8 |
9 |
10 | 
11 | 
12 | 
13 | 
14 | 
15 |
16 |
17 | ###
18 | ```
19 | from anikimiapi import AniKimi
20 |
21 | anime = AniKimi(
22 | gogoanime_token="dbakbihihrkqnk3",
23 | auth_token="EKWBIH4NJTO309U4HKTHI39U9TJ5OJ0UU5J9"
24 | )
25 |
26 | # Getting Anime Links
27 | anime_link = anime.get_episode_link(animeid="clannad-dub", episode_num=3)
28 |
29 | print(anime_link.link_hdp)
30 | print(anime_link.link_720p)
31 | print(anime_link.link_streamsb) # And many more...
32 | ```
33 |
34 | ### Features of AniKimi
35 | * Custom url changing option.
36 | * Statically-Typed, No more annoying JSON responses.
37 | * Autocomplete supported by most IDE's.
38 | * Complete solution.
39 | * Faster response.
40 | * Less CPU consumption.
41 |
42 | ###
43 | #### For full usage instructions, Head over to the [GitHub Page](https://github.com/BaraniARR/anikimiapi).
--------------------------------------------------------------------------------
/anikimiapi/__init__.py:
--------------------------------------------------------------------------------
1 | from anikimiapi.anikimi import AniKimi
--------------------------------------------------------------------------------
/anikimiapi/anikimi.py:
--------------------------------------------------------------------------------
1 | from requests_html import HTMLSession
2 | from bs4 import BeautifulSoup
3 | import requests
4 | from anikimiapi.data_classes import *
5 | from anikimiapi.error_handlers import *
6 | import re
7 |
8 |
9 | class AniKimi:
10 | """The `AniKimi` class which authorizes the gogoanime client.
11 |
12 | Parameters:
13 | gogoanime_token (``str``):
14 | To get this token, please refer to readme.md in the repository.
15 | auth_token (``str``):
16 | To get this token, please refer to readme.md in the repository.
17 | host (``str``):
18 | Change the base url, If gogoanime changes the domain, replace the url
19 | with the new domain. Defaults to https://gogoanime.pe/ .
20 |
21 | Example:
22 | .. code-block:: python
23 | :emphasize-lines: 1,4-7
24 |
25 | from anikimiapi import AniKimi
26 |
27 | # Authorize the api to GogoAnime
28 | anime = AniKimi(
29 | gogoanime_token="baikdk32hk1nrek3hw9",
30 | auth_token="NCONW9H48HNFONW9Y94NJT49YTHO45TU4Y8YT93HOGFNRKBI"
31 | )
32 |
33 |
34 |
35 | """
36 | def __init__(
37 | self,
38 | gogoanime_token: str,
39 | auth_token: str,
40 | host: str = "https://gogoanime.pe/"
41 | ):
42 | self.gogoanime_token = gogoanime_token
43 | self.auth_token = auth_token
44 | self.host = host
45 |
46 | def __str__(self) -> str:
47 | return "Anikimi API - Copyrights (c) 2020-2021 BaraniARR."
48 |
49 |
50 | def search_anime(self, query: str) -> list:
51 | """The method used to search anime when a query string is passed
52 |
53 | Parameters:
54 | query(``str``):
55 | The query String which was to be searched in the API.
56 |
57 | Returns:
58 | List of :obj:`-anikimiapi.data_classes.ResultObject`: On Success, the list of search results is returned.
59 |
60 | Example:
61 | .. code-block:: python
62 | :emphasize-lines: 1,4-7,10-13
63 |
64 | from anikimiapi import AniKimi
65 |
66 | # Authorize the api to GogoAnime
67 | anime = AniKimi(
68 | gogoanime_token="baikdk32hk1nrek3hw9",
69 | auth_token="NCONW9H48HNFONW9Y94NJT49YTHO45TU4Y8YT93HOGFNRKBI"
70 | )
71 |
72 | # Get search Results
73 | search_results = anime.search_anime(query="clannad")
74 | for results in search_results:
75 | print(results.title)
76 | print(results.animeid)
77 |
78 | """
79 | try:
80 | url1 = f"{self.host}/search.html?keyword={query}"
81 | session = HTMLSession()
82 | response = session.get(url1)
83 | response_html = response.text
84 | soup = BeautifulSoup(response_html, 'html.parser')
85 | animes = soup.find("ul", {"class": "items"}).find_all("li")
86 | res_list_search = []
87 | for anime in animes: # For every anime found
88 | tit = anime.a["title"]
89 | urll = anime.a["href"]
90 | r = urll.split('/')
91 | res_list_search.append(ResultObject(title=f"{tit}", animeid=f"{r[2]}"))
92 | if not res_list_search:
93 | raise NoSearchResultsError("No Search Results found for the query")
94 | else:
95 | return res_list_search
96 | except requests.exceptions.ConnectionError:
97 | raise NetworkError("Unable to connect to the Server, Check your connection")
98 |
99 | def get_details(self, animeid: str) -> MediaInfoObject:
100 | """Get the basic details of anime using an animeid parameter.
101 |
102 | Parameters:
103 | animeid(``str``):
104 | The animeid of the anime which you want to get the details.
105 |
106 | Returns:
107 | :obj:`-anikimiapi.data_classes.MediaInfoObject`: On success, the details of anime is returned as ``MediaInfoObject`` object.
108 |
109 | Example:
110 | .. code-block:: python
111 | :emphasize-lines: 1,4-7,10-12
112 |
113 | from anikimiapi import AniKimi
114 |
115 | # Authorize the api to GogoAnime
116 | anime = AniKimi(
117 | gogoanime_token="baikdk32hk1nrek3hw9",
118 | auth_token="NCONW9H48HNFONW9Y94NJT49YTHO45TU4Y8YT93HOGFNRKBI"
119 | )
120 |
121 | # Get anime Details
122 | details = anime.get_details(animeid="clannad-dub")
123 | print(details.image_url) # gives the url of the cover image
124 | print(details.status) # gives the status whether airing or completed
125 |
126 | # And many more...
127 | """
128 | try:
129 | animelink = f'{self.host}category/{animeid}'
130 | response = requests.get(animelink)
131 | plainText = response.text
132 | soup = BeautifulSoup(plainText, "lxml")
133 | source_url = soup.find("div", {"class": "anime_info_body_bg"}).img
134 | imgg = source_url.get('src')
135 | tit_url = soup.find("div", {"class": "anime_info_body_bg"}).h1.string
136 | lis = soup.find_all('p', {"class": "type"})
137 | plot_sum = lis[1]
138 | pl = plot_sum.get_text().split(':')
139 | pl.remove(pl[0])
140 | sum = ""
141 | plot_summary = sum.join(pl)
142 | type_of_show = lis[0].a['title']
143 | ai = lis[2].find_all('a') # .find_all('title')
144 | genres = []
145 | for link in ai:
146 | genres.append(link.get('title'))
147 | year1 = lis[3].get_text()
148 | year2 = year1.split(" ")
149 | year = year2[1]
150 | status = lis[4].a.get_text()
151 | oth_names = lis[5].get_text()
152 | lnk = soup.find(id="episode_page")
153 | ep_str = str(lnk.contents[-2])
154 | a_tag = ep_str.split("\n")[-2]
155 | a_tag_sliced = a_tag[:-4].split(">")
156 | last_ep_range = a_tag_sliced[-1]
157 | y = last_ep_range.split("-")
158 | ep_num = y[-1]
159 | res_detail_search = MediaInfoObject(
160 | title=f"{tit_url}",
161 | year=int(year),
162 | other_names=f"{oth_names}",
163 | season=f"{type_of_show}",
164 | status=f"{status}",
165 | genres=genres,
166 | episodes=int(ep_num),
167 | image_url=f"{imgg}",
168 | summary=f"{plot_summary}"
169 | )
170 | return res_detail_search
171 | except AttributeError:
172 | raise InvalidAnimeIdError("Invalid animeid given")
173 | except requests.exceptions.ConnectionError:
174 | raise NetworkError("Unable to connect to the Server, Check your connection")
175 |
176 | def get_episode_link_advanced(self, animeid: str, episode_num: int) -> MediaLinksObject:
177 | """Get streamable and downloadable links for a given animeid and episode number.
178 | If the link is not found, then this method will return ``None`` .
179 |
180 | Parameters:
181 | animeid(``str``):
182 | The animeid of the anime you want to download.
183 |
184 | episode_num(``int``):
185 | The episode number of the anime you want to download.
186 |
187 | Returns:
188 | :obj:`-anikimiapi.data_classes.MediaLinksObject`: On success, the links of the anime is returned.
189 |
190 | Example:
191 | .. code-block:: python
192 | :emphasize-lines: 1,4-7,10-13
193 |
194 | from anikimiapi import AniKimi
195 |
196 | # Authorize the api to GogoAnime
197 | anime = AniKimi(
198 | gogoanime_token="baikdk32hk1nrek3hw9",
199 | auth_token="NCONW9H48HNFONW9Y94NJT49YTHO45TU4Y8YT93HOGFNRKBI"
200 | )
201 |
202 | # Get anime Link
203 | link = anime.get_episode_link(animeid="clannad-dub", episode_num=3)
204 | print(link.link_hdp)
205 | print(link.link_360p)
206 | print(link.link_streamtape)
207 |
208 | # and many more...
209 | """
210 | try:
211 | ep_num_link_get = episode_num
212 | str_qry_final = animeid
213 | animelink = f'{self.host}category/{str_qry_final}'
214 | response = requests.get(animelink)
215 | plainText = response.text
216 | soup = BeautifulSoup(plainText, "lxml")
217 | lnk = soup.find(id="episode_page")
218 | source_url = lnk.find("li").a
219 | anime_title = soup.find("div", {"class": "anime_info_body_bg"}).h1.string
220 | ep_num_tot = source_url.get("ep_end")
221 | last_ep = int(ep_num_tot)
222 | episode_url = '{}{}-episode-{}'
223 | url = episode_url.format(self.host, str_qry_final, ep_num_link_get)
224 | master_keyboard_list = []
225 | cookies = {
226 | 'gogoanime': self.gogoanime_token,
227 | 'auth': self.auth_token
228 | }
229 | response = requests.get(url=url, cookies=cookies)
230 | plaintext = response.text
231 | soup = BeautifulSoup(plaintext, "lxml")
232 | download_div = soup.find("div", {'class': 'cf-download'}).findAll('a')
233 | links_final = MediaLinksObject()
234 | for links in download_div:
235 | download_links = links['href']
236 | q_name_raw = links.text.strip()
237 | q_name_raw_list = q_name_raw.split('x')
238 | quality_name = q_name_raw_list[1] # 360, 720, 1080p links .just append to keyb lists with name and href
239 | if quality_name == "360":
240 | links_final.link_360p = download_links
241 | elif quality_name == "480":
242 | links_final.link_480p = download_links
243 | elif quality_name == "720":
244 | links_final.link_720p = download_links
245 | elif quality_name == "1080":
246 | links_final.link_1080p = download_links
247 | anime_multi_link_initial = soup.find('div', {'class': 'anime_muti_link'}).findAll('li')
248 | anime_multi_link_initial.remove(anime_multi_link_initial[0])
249 | chumma_list = []
250 | for l in anime_multi_link_initial:
251 | get_a = l.find('a')
252 | video_links = get_a['data-video']
253 | valid = video_links[0:4]
254 | if valid == "http":
255 | pass
256 | else:
257 | video_links = f"https:{video_links}"
258 | chumma_list.append(video_links)
259 | anime_multi_link_initial.remove(anime_multi_link_initial[0])
260 | for other_links in anime_multi_link_initial:
261 | get_a_other = other_links.find('a')
262 | downlink = get_a_other['data-video'] # video links other websites
263 | quality_name = other_links.text.strip().split('C')[0] # other links name quality
264 | if quality_name == "Streamsb":
265 | links_final.link_streamsb = downlink
266 | elif quality_name == "Xstreamcdn":
267 | links_final.link_xstreamcdn = downlink
268 | elif quality_name == "Streamtape":
269 | links_final.link_streamtape = downlink
270 | elif quality_name == "Mixdrop":
271 | links_final.link_mixdrop = downlink
272 | elif quality_name == "Mp4Upload":
273 | links_final.link_mp4upload = downlink
274 | elif quality_name == "Doodstream":
275 | links_final.link_doodstream = downlink
276 | res = requests.get(chumma_list[0])
277 | plain = res.text
278 | s = BeautifulSoup(plain, "lxml")
279 | t = s.findAll('script')
280 | hdp_js = t[2].string
281 | hdp_link_initial = re.search("(?P
11 |
12 |
13 |
14 |
15 |