simple-rule34 0.1.5.4__tar.gz → 0.1.6__tar.gz

{simple_rule34-0.1.5.4 → simple_rule34-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: simple_rule34
-Version: 0.1.5.4
+Version: 0.1.6
 Summary: Simple api wrapper of rule34.xxx for python with asynchronous support
 Author-email: StarMan12 <author@example.com>
 Project-URL: Homepage, https://github.com/SyperAlexKomp/simple-rule34-api
@@ -50,6 +50,8 @@ Requires-Dist: urllib3==2.0.3
 Requires-Dist: yarg==0.1.9
 Requires-Dist: yarl==1.9.2
 Requires-Dist: zipp==3.16.2
+Requires-Dist: aiofiles~=23.2.1
+Requires-Dist: pydantic~=2.7.1
 
 # rule34-simple-api
 Simple api wrapper of rule34.xxx for python with asynchronous support

{simple_rule34-0.1.5.4 → simple_rule34-0.1.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "simple_rule34"
-version = "0.1.5.4"
+version = "0.1.6"
 authors = [
   { name="StarMan12", email="author@example.com" },
 ]
@@ -16,7 +16,8 @@ classifiers = [
     "License :: OSI Approved :: MIT License",
     "Operating System :: OS Independent",
 ]
-dependencies = ['aiohttp==3.8.4',
+dependencies = [
+    'aiohttp==3.8.4',
     'aiosignal==1.3.1',
     'alabaster==0.7.13',
     'async-timeout==4.0.2',
@@ -54,7 +55,10 @@ dependencies = ['aiohttp==3.8.4',
     'urllib3==2.0.3',
     'yarg==0.1.9',
     'yarl==1.9.2',
-    'zipp==3.16.2']
+    'zipp==3.16.2',
+    'aiofiles~=23.2.1',
+    'pydantic~=2.7.1'
+]
 
 [project.urls]
 "Homepage" = "https://github.com/SyperAlexKomp/simple-rule34-api"

simple_rule34-0.1.6/src/SimpleRule34/Rule34.py

@@ -0,0 +1,149 @@
+import random
+import time
+
+import aiohttp
+import datetime
+import logging
+import xml.etree.ElementTree as ET
+
+from .exceptions import *
+from .types import *
+
+
+class Rule34Api:
+    def __init__(self):
+        self.header = {'User-Agent': 'rule34-simple-api 0.1.5.6 (Request)'}
+    async def get_post_count(self, tags: str = '') -> int:
+        async with aiohttp.ClientSession(headers=self.header) as session:
+            async with session.get(f'https://api.rule34.xxx/index.php?'
+                                   f'page=dapi&s=post&q=index&tags={tags}') as response:
+                xml_data = await response.text()
+
+        xml_root = ET.fromstring(xml_data)
+
+        return int(xml_root.get('count'))
+
+    async def get_post(self, id: int) -> Post:
+        st = time.time()
+
+        async with aiohttp.ClientSession(headers=self.header) as session:
+            async with session.get(f'https://api.rule34.xxx/index.php?'
+                                   f'json=1&page=dapi&s=post&q=index&id={id}') as response:
+                if response.status != 200:
+                    raise ApiException(f"Api returned status code {response.status} with message"
+                                       f" {await response.text()}")
+
+                j = await response.json()
+                data = j[0]
+
+        data["main"] = {
+            "url": data['file_url']
+        }
+        data["preview"] = {
+            "url": data['preview_url']
+        }
+        data["tags"] = data["tags"].split(" ")
+
+        logging.debug(f"Post[{id}] where found in {time.time() - st}s")
+
+        return Post(**data)
+
+    async def get_random_post(self, tags: str = '', forbidden_tags: list[str] = []) -> Post:
+        start_time = time.time()
+
+        post_count = await self.get_post_count(tags)
+
+        page_count = post_count // 1000
+
+        if page_count > 0:
+            post_list = await self.get_post_list(page_id=random.randint(0, page_count if page_count <= 200 else 200),
+                                                 tags=tags, limit=1000)
+
+        else:
+            post_list = await self.get_post_list(tags=tags, limit=1000)
+
+        post_list_ = []
+
+        for post in post_list:
+            if any(tag in forbidden_tags for tag in post.main.tags):
+                pass
+            else:
+                post_list_.append(post)
+
+        logging.debug(f"Random posts where found in {time.time() - start_time}s")
+
+        return post_list_[random.randint(0, len(post_list_) - 1)] if len(post_list_) > 0 else None
+
+    async def get_random_posts(self, tags: str = '', count: int = 8, forbidden_tags: list[str] = []) -> list[Post]:
+        st = time.time()
+
+        request_count = 1
+        true_count = count*20
+
+        post_list = []
+
+        if true_count > 1000:
+            request_count = true_count // 1000
+
+        post_count = await self.get_post_count(tags)
+        page_id = int(random.randint(0, int(post_count / true_count)) / 8)  if post_count >= true_count else 0
+
+        for pid in range(request_count + 1):
+            post_list += await self.get_post_list(tags=tags, forbidden_tags=forbidden_tags,
+                                                  page_id=page_id, limit=true_count if true_count <= 1000 else 1000)
+
+        getted = []
+
+        for x in range(count):
+            if len(post_list) > 0:
+                getted.append(post_list[random.randint(0, len(post_list) - 1)])
+            else:
+                pass
+
+        logging.debug(f"{count} random posts where found in {time.time() - st}s")
+
+        return getted
+
+    async def get_post_list(self, limit: int = 1000, page_id: int = 0, tags: str = '', forbidden_tags: list[str] = [])\
+            -> list[Post]:
+        if limit > 1000:
+            raise ToBigRequestException(f"The max size of request is 1000 when you tried to request {limit}")
+
+        async with aiohttp.ClientSession(headers=self.header) as session:
+            start_time = time.time()
+
+            async with session.get(f'https://api.rule34.xxx/index.php?'
+                                   f'json=1&page=dapi&s=post&q=index&limit={limit}&pid={page_id}&tags={tags}') as response:
+                if response.status != 200:
+                    raise ApiException(f"Api returned status code {response.status} with message"
+                                       f" {await response.text()}")
+
+                data = await response.json()
+
+            logging.debug(f"Request with {limit} limit posts were done in {time.time() - start_time}s")
+
+            post_list = []
+            for post_data in data:
+                post_data["main"] = {
+                    "url": post_data['file_url']
+                }
+                post_data["preview"] = {
+                    "url": post_data['preview_url']
+                }
+                post_data["tags"] = post_data["tags"].split(" ")
+
+                post_list.append(Post(**post_data))
+
+            start_time = time.time()
+
+            post_list_ = []
+
+            for post in post_list:
+                if any(tag in forbidden_tags for tag in post.tags):
+                    pass
+                else:
+                    post_list_.append(post)
+
+            logging.debug(f"{len(post_list_)} posts where found in {time.time() - start_time}s")
+
+            return post_list_

{simple_rule34-0.1.5.4 → simple_rule34-0.1.6}/src/SimpleRule34/exceptions.py

@@ -1,5 +1,3 @@
-
-
 class ToBigRequestException(Exception):
     def __init__(self, msg):
         self.msg = msg
@@ -15,3 +13,11 @@ class RequestMoreThanAvailableException(Exception):
 
     def __str__(self):
         return self.msg
+
+
+class ApiException(Exception):
+    def __init__(self, msg):
+        self.msg = msg
+
+    def __str__(self):
+        return self.msg

simple_rule34-0.1.6/src/SimpleRule34/types.py

@@ -0,0 +1,62 @@
+import os
+import typing
+import aiofiles
+import aiohttp
+
+from aiofiles import os as aos
+from pydantic import BaseModel
+
+from .exceptions import ApiException
+from .utils import get_file_type
+
+
+class File(BaseModel):
+    url: str
+    type: str = None
+
+    def __init__(self, /, **data: typing.Any) -> None:
+        super().__init__(**data)
+
+        self.type = get_file_type(self.url)
+
+    async def download(self, path: str = r'./rule34_download') -> str:
+        try:
+            await aos.mkdir(path)
+        except:
+            pass
+
+        async with aiohttp.ClientSession() as session:
+            async with session.get(self.url) as response:
+                if response.status != 200:
+                    raise ApiException(f"Api returned status code {response.status} with message"
+                                       f" {await response.text()}")
+
+                file_name = os.path.basename(self.url)
+                save_path = os.path.join(path, file_name)
+
+                async with aiofiles.open(save_path, 'wb') as file:
+                    await file.write(await response.read())
+
+                return save_path
+
+
+class Post(BaseModel):
+    directory: int
+    hash: str
+    width: int
+    height: int
+    id: int
+    change: int
+    owner: str
+    parent_id: int
+    rating: str
+    sample: bool
+    score: int
+    tags: list
+    source: str
+    status: str
+    has_notes: bool
+    comment_count: int
+
+    main: File
+    preview: File

{simple_rule34-0.1.5.4 → simple_rule34-0.1.6}/src/simple_rule34.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: simple_rule34
-Version: 0.1.5.4
+Version: 0.1.6
 Summary: Simple api wrapper of rule34.xxx for python with asynchronous support
 Author-email: StarMan12 <author@example.com>
 Project-URL: Homepage, https://github.com/SyperAlexKomp/simple-rule34-api
@@ -50,6 +50,8 @@ Requires-Dist: urllib3==2.0.3
 Requires-Dist: yarg==0.1.9
 Requires-Dist: yarl==1.9.2
 Requires-Dist: zipp==3.16.2
+Requires-Dist: aiofiles~=23.2.1
+Requires-Dist: pydantic~=2.7.1
 
 # rule34-simple-api
 Simple api wrapper of rule34.xxx for python with asynchronous support

{simple_rule34-0.1.5.4 → simple_rule34-0.1.6}/src/simple_rule34.egg-info/SOURCES.txt

@@ -1,15 +1,12 @@
 LICENSE
 README.md
 pyproject.toml
+src/__init__.py
 src/SimpleRule34/Rule34.py
 src/SimpleRule34/__init__.py
 src/SimpleRule34/exceptions.py
-src/SimpleRule34/setup.py
 src/SimpleRule34/types.py
 src/SimpleRule34/utils.py
-src/SimpleRule34/aio/ARule34.py
-src/SimpleRule34/aio/types.py
-src/SimpleRule34/aio/utils.py
 src/simple_rule34.egg-info/PKG-INFO
 src/simple_rule34.egg-info/SOURCES.txt
 src/simple_rule34.egg-info/dependency_links.txt

{simple_rule34-0.1.5.4 → simple_rule34-0.1.6}/src/simple_rule34.egg-info/requires.txt

@@ -37,3 +37,5 @@ urllib3==2.0.3
 yarg==0.1.9
 yarl==1.9.2
 zipp==3.16.2
+aiofiles~=23.2.1
+pydantic~=2.7.1

{simple_rule34-0.1.5.4 → simple_rule34-0.1.6}/src/simple_rule34.egg-info/top_level.txt

@@ -1 +1,2 @@
 SimpleRule34
+__init__

simple_rule34-0.1.6/tests/test.py

@@ -0,0 +1,40 @@
+from SimpleRule34.src.SimpleRule34.Rule34 import Rule34Api
+from SimpleRule34.src.SimpleRule34 import Rule34Api
+import asyncio
+
+
+async def main1():
+
+    r = Rule34Api()
+    print("=====ALL 10=====")
+    lis = await r.get_post_list(tags='', limit=10)
+
+    for x in lis:
+        print(x)
+
+    print("=====FIRST 5=====")
+    lis = await r.get_post_list(tags='brawl_stars', limit=5)
+
+    for x in lis:
+        print(x)
+
+    print("=====SECOND 5=====")
+    lis = await r.get_post_list(tags='brawl_stars', limit=5, page_id=1)
+
+    for x in lis:
+        print(x)
+
+    print("=====EDITED=====")
+    post_list_ = await r.get_post_list(tags='brawl_stars', limit=100, page_id=0,
+                                            forbidden_tags=['male'])
+
+    return
+
+
+async def main():
+    r = Rule34Api()
+    p = await r.get_post_list(limit=10)
+    print(p)
+
+if __name__ == '__main__':
+    asyncio.run(main())

simple_rule34-0.1.5.4/src/SimpleRule34/Rule34.py

@@ -1,213 +0,0 @@
-import random
-import time
-import typing
-
-import requests
-import datetime
-import logging
-import xml.etree.ElementTree as ET
-
-from .exceptions import *
-from .types import Rule34MainPost, Rule34PostData, Rule34SamplePost, Rule34PreviewPost
-
-
-def parse_result(post_element):
-
-
-    id = int(post_element.get('id'))
-    height = int(post_element.get('height'))
-    width = int(post_element.get('width'))
-    url = post_element.get('file_url')
-
-    sample_height = int(post_element.get('sample_height'))
-    sample_width = int(post_element.get('sample_width'))
-    sample_url = post_element.get('sample_url')
-
-    sample_post = Rule34SamplePost(sample_height, sample_width, sample_url, id)
-
-    preview_height = int(post_element.get('preview_height'))
-    preview_width = int(post_element.get('preview_width'))
-    preview_url = post_element.get('preview_url')
-
-    preview_post = Rule34PreviewPost(preview_height, preview_width, preview_url, id)
-
-    score = int(post_element.get('score'))
-    rating = post_element.get('rating')
-    creator_id = int(post_element.get('creator_id'))
-    tags = post_element.get('tags')
-    has_children = post_element.get('has_children') == 'true'
-    created_date = datetime.datetime.strptime(post_element.get('created_at'), "%a %b %d %H:%M:%S %z %Y")
-    status = post_element.get('status')
-    source = post_element.get('source')
-    has_notes = post_element.get('has_notes') == 'true'
-    has_comments = post_element.get('has_comments') == 'true'
-
-    main_post = Rule34MainPost(score, rating, creator_id, tags, has_children, created_date, status,
-                               source, has_notes, has_comments, height, width, url, id)
-
-    return main_post, sample_post, preview_post
-
-
-class Rule34Api:
-    """
-    Sync main api class
-
-    """
-
-    def __init__(self):
-        self.s = requests.Session()
-
-    def get_post_count(self, tags: str = '') -> int:
-        """
-        This function will search amount of posts with your tags from rule34.xxx
-
-        :param tags: Tags in format 'tag1 tag2 ...'. Base ''
-        :type tags: str
-
-        :return: Amount of posts with current tags
-        :rtype: int
-        """
-
-
-        r = self.s.get(f'https://api.rule34.xxx/index.php?'
-                       f'page=dapi&s=post&q=index&tags={tags}')
-
-        xml_root = ET.fromstring(r.text)
-
-        return int(xml_root.get('count'))
-
-    def get_post(self, id: int) -> typing.Optional[Rule34PostData]:
-        """
-        This function will search post with your id from rule34.xxx
-
-        :param id: id of post
-        :type id: int
-
-        :return: On success, returns Rule34PostData object
-        :rtype: :obj: 'typing.Optional[Rule34PostData]'
-        """
-
-        r = self.s.get(f'https://api.rule34.xxx/index.php?'
-                       f'page=dapi&s=post&q=index&id={id}')
-
-        try:
-            xml_root = ET.fromstring(r.text)
-        except:
-            return None
-        post_element = xml_root.find('post')
-
-        parsed = parse_result(post_element)
-
-        if parsed is None:
-            return None
-        else:
-            main_post, sample_post, preview_post = parsed
-
-        return Rule34PostData(id, main_post, sample_post, preview_post)
-
-    def get_random_post(self, tags: str = '') -> typing.Optional[Rule34PostData]:
-        """
-        This function will search 1 random post with your tags from rule34.xxx
-
-        :param tags: Tags in format 'tag1 tag2 ...' with which post will be searching. Base ''
-        :type tags: str
-
-        :return: On success, returns Rule34PostData object
-        :rtype: :obj: 'typing.Optional[Rule34PostData]'
-        """
-
-        post_count = self.get_post_count(tags)
-
-        page_count = post_count // 1000
-
-        if page_count > 0:
-            post_list = self.get_post_list(page_id=random.randint(0, page_count if page_count <= 200 else 200),
-                                           tags=tags, limit=1000)
-
-        else:
-            post_list = self.get_post_list(tags=tags, limit=1000)
-
-        return post_list[random.randint(0, len(post_list) - 1)] if len(post_list) > 0 else None
-
-    def get_random_posts(self, tags: str = '', count: int = 8) -> list[Rule34PostData]:
-        """
-        This function will search your amount of random posts with your tags from rule34.xxx
-
-        :param tags: Tags in format 'tag1 tag2 ...' with which post will be searching. Base ''
-        :type tags: str
-
-        :param count: Amount of posts that will need to be founded. Base 8
-        :type count: int
-
-        :return: List with founded posts
-        :rtype: :obj: 'list[Rule34PostData]'
-
-        """
-
-        st = time.time()
-
-        request_count = 1
-
-        post_list = []
-
-        if count > 1000:
-            request_count = count // 1000
-
-        for pid in range(request_count + 1):
-            post_list += self.get_post_list(tags=tags)
-
-        getted = [post_list[random.randint(0, len(post_list) - 1)] if len(post_list) > 0 else None for x in
-                  range(count)]
-
-        logging.debug(f"{count} random posts where founded in {time.time() - st}")
-
-        return getted
-
-    def get_post_list(self, limit: int = 1000, page_id: int = 0, tags: str = '',
-                      blocked_tags: typing.Optional[str] = None) -> list[Rule34PostData]:
-        """
-        This function will get list of posts with your tags on page
-
-        :param limit: limit of posts in list. Base value is 1000
-        :type limit: int
-
-        :param page_id: number of page with posts. Base value is 0
-        :type page_id: int
-
-        :param tags: Tags in format 'tag1 tag2 ...' with which post will be searching. Base values is ''
-        :type tags: str
-
-        :parameter blocked_tags: Tags that will be banned from search in format 'tag1 tag2 ...'. Base values is None.
-         Can slow search
-        :type blocked_tags: str or None
-
-        :return: :obj: 'list[Rule34PostData]'
-        """
-
-        if limit > 1000:
-            raise ToBigRequestException(f"The max size of request is 1000 when you tried to request {limit}")
-
-        start_time = time.time()
-
-        r = self.s.get(f'https://api.rule34.xxx/index.php?'
-                       f'page=dapi&s=post&q=index&limit={limit}&pid={page_id}&tags={tags}')
-
-        logging.debug(f"Request with {limit}limit posts where done in {time.time() - start_time}s")
-
-        xml_root = ET.fromstring(r.text)
-        posts = xml_root.findall('post')
-        post_list = []
-
-        start_time = time.time()
-        for post_element in posts:
-            parsed = parse_result(post_element)
-
-            if parsed is None:
-                continue
-            else:
-                main_post, sample_post, preview_post = parsed
-
-            post_list.append(Rule34PostData(main_post.id, main_post, sample_post, preview_post))
-        logging.debug(f"Creating {len(posts)} objects where done in {time.time() - start_time}s")
-
-        return post_list

simple_rule34-0.1.5.4/src/SimpleRule34/aio/ARule34.py

@@ -1,186 +0,0 @@
-import random
-import time
-
-import aiohttp
-import datetime
-import logging
-import xml.etree.ElementTree as ET
-
-from ..exceptions import *
-from .types import *
-
-
-async def parse_result(post_element):
-
-
-    id = int(post_element.get('id'))
-    height = int(post_element.get('height'))
-    width = int(post_element.get('width'))
-    url = post_element.get('file_url')
-
-    sample_height = int(post_element.get('sample_height'))
-    sample_width = int(post_element.get('sample_width'))
-    sample_url = post_element.get('sample_url')
-
-    sample_post = Rule34SamplePost(sample_height, sample_width, sample_url, id)
-
-    preview_height = int(post_element.get('preview_height'))
-    preview_width = int(post_element.get('preview_width'))
-    preview_url = post_element.get('preview_url')
-
-    preview_post = Rule34PreviewPost(preview_height, preview_width, preview_url, id)
-
-    score = int(post_element.get('score'))
-    rating = post_element.get('rating')
-    creator_id = int(post_element.get('creator_id'))
-    tags = post_element.get('tags')
-    has_children = post_element.get('has_children') == 'true'
-    created_date = datetime.datetime.strptime(post_element.get('created_at'), "%a %b %d %H:%M:%S %z %Y")
-    status = post_element.get('status')
-    source = post_element.get('source')
-    has_notes = post_element.get('has_notes') == 'true'
-    has_comments = post_element.get('has_comments') == 'true'
-
-    main_post = Rule34MainPost(score, rating, creator_id, tags, has_children, created_date, status,
-                               source, has_notes, has_comments, height, width, url, id)
-
-    return main_post, sample_post, preview_post
-
-class Rule34Api:
-    def __init__(self):
-        self.header = {'User-Agent': 'rule34-simple-api 0.1.5.3 (Request)'}
-    async def get_post_count(self, tags: str = '') -> int:
-        async with aiohttp.ClientSession(headers=self.header) as session:
-            async with session.get(f'https://api.rule34.xxx/index.php?'
-                                   f'page=dapi&s=post&q=index&tags={tags}') as response:
-                xml_data = await response.text()
-
-        xml_root = ET.fromstring(xml_data)
-
-        return int(xml_root.get('count'))
-
-    async def get_post(self, id: int):
-        st = time.time()
-
-        async with aiohttp.ClientSession(headers=self.header) as session:
-            async with session.get(f'https://api.rule34.xxx/index.php?'
-                                   f'page=dapi&s=post&q=index&id={id}') as response:
-                xml_data = await response.text()
-
-        try:
-            xml_root = ET.fromstring(xml_data)
-        except:
-            return None
-
-        post_element = xml_root.find('post')
-
-        parsed = await parse_result(post_element)
-
-        if parsed is None:
-            return None
-        else:
-            main_post, sample_post, preview_post = parsed
-
-        logging.info(f"Post where found in {time.time() - st}s")
-
-        return Rule34PostData(id, main_post, sample_post, preview_post)
-
-    async def get_random_post(self, tags: str = '', forbidden_tags: list[str] = []):
-        start_time = time.time()
-
-        post_count = await self.get_post_count(tags)
-
-        page_count = post_count // 1000
-
-        if page_count > 0:
-            post_list = await self.get_post_list(page_id=random.randint(0, page_count if page_count <= 200 else 200),
-                                                 tags=tags, limit=1000)
-
-        else:
-            post_list = await self.get_post_list(tags=tags, limit=1000)
-
-        post_list_ = []
-
-        for post in post_list:
-            if any(tag in forbidden_tags for tag in post.main.tags):
-                pass
-            else:
-                post_list_.append(post)
-
-        logging.info(f"Random post where found in {time.time() - start_time}s")
-
-        return post_list_[random.randint(0, len(post_list_) - 1)] if len(post_list_) > 0 else None
-
-    async def get_random_posts(self, tags: str = '', count: int = 8, forbidden_tags: list[str] = []) -> list[Rule34PostData]:
-        st = time.time()
-
-        request_count = 1
-        true_count = count*20
-
-        post_list = []
-
-        if true_count > 1000:
-            request_count = true_count // 1000
-
-        post_count = await self.get_post_count(tags)
-        page_id = int(random.randint(0, int(post_count / true_count)) / 8)  if post_count >= true_count else 0
-
-        for pid in range(request_count + 1):
-            post_list += await self.get_post_list(tags=tags, forbidden_tags=forbidden_tags,
-                                                  page_id=page_id, limit=true_count if true_count <= 1000 else 1000)
-
-        getted = []
-
-        for x in range(count):
-            if len(post_list) > 0:
-                getted.append(post_list[random.randint(0, len(post_list) - 1)])
-            else:
-                pass
-
-        logging.info(f"{count} random posts where found in {time.time() - st}s")
-
-        return getted
-
-    async def get_post_list(self, limit: int = 1000, page_id: int = 0, tags: str = '', forbidden_tags: list[str] = [])\
-            -> list[Rule34PostData]:
-        async with aiohttp.ClientSession(headers=self.header) as session:
-            if limit > 1000:
-                raise ToBigRequestException(f"The max size of request is 1000 when you tried to request {limit}")
-
-            start_time = time.time()
-
-            async with session.get(f'https://api.rule34.xxx/index.php?'
-                                   f'page=dapi&s=post&q=index&limit={limit}&pid={page_id}&tags={tags}') as response:
-                xml_data = await response.text()
-
-            logging.debug(f"Request with {limit} limit posts were done in {time.time() - start_time}s")
-
-            xml_root = ET.fromstring(xml_data)
-            posts = xml_root.findall('post')
-            post_list = []
-
-            start_time = time.time()
-
-            for post_element in posts:
-                parsed = await parse_result(post_element)
-
-                if parsed is None:
-                    return []
-                else:
-                    main_post, sample_post, preview_post = parsed
-
-                post_list.append(Rule34PostData(main_post.id, main_post, sample_post, preview_post))
-
-            logging.debug(f"Creating {len(posts)} objects was done in {time.time() - start_time}s")
-
-            post_list_ = []
-
-            for post in post_list:
-                if any(tag in forbidden_tags for tag in post.main.tags):
-                    pass
-                else:
-                    post_list_.append(post)
-
-            logging.info(f"{len(post_list_)} posts where found in {time.time() - start_time}s")
-
-            return post_list_

simple_rule34-0.1.5.4/src/SimpleRule34/aio/types.py

@@ -1,98 +0,0 @@
-import typing
-
-import aiofiles
-import aiohttp
-import os
-import datetime
-
-from .utils import get_file_size, get_file_type
-
-
-class Rule34Post:
-    def __init__(self, height: int, width: int, url: str, id: int):
-        self.path = r'./rule34_download'
-        self.height = height
-        self.width = width
-        self.url = url
-        self.id = id
-        self.file_type = get_file_type(self.url)
-
-    def __str__(self):
-        return f"<Rule34Post(id={self.id}, height={self.height}, width={self.width}, url={self.url})>"
-
-    async def get_file_size(self) -> typing.Optional[int]:
-        async with aiohttp.ClientSession() as session:
-            file_size = await get_file_size(self.url, session)
-        return file_size
-
-    async def download(self, path=r'./rule34_download'):
-        async with aiohttp.ClientSession() as session:
-            async with session.get(self.url) as response:
-                if response.status == 200:
-                    try:
-                        os.mkdir(self.path)
-                    except:
-                        pass
-
-                    file_name = os.path.basename(self.url)
-                    save_path = os.path.join(path, file_name)
-                    with aiofiles.open(save_path, 'wb') as file:
-                        await file.write(await response.read())
-
-                    return save_path
-                else:
-                    pass
-
-    async def get_bytes(self):
-        async with aiohttp.ClientSession() as session:
-            async with session.get(self.url) as response:
-                return await response.read()
-
-
-class Rule34MainPost(Rule34Post):
-    def __init__(self, score: int, rating: str, creator_id: int, tags: str, has_children: bool,
-                 created_date: datetime.datetime, status: str, source: str, has_notes: bool, has_comments: bool,
-                 height: int, width: int, url: str, id: int):
-        super().__init__(height, width, url, id)
-        self.score = score
-        self.rating = rating
-        self.creator_id = creator_id
-        self.tags = tags.split(" ")
-        self.has_children = has_children
-        self.created_date = created_date
-        self.status = status
-        self.source = source
-        self.has_notes = has_notes
-        self.has_comments = has_comments
-
-    def __str__(self):
-        return f"<Rule34MainPost(id={self.id}, height={self.height}, width={self.width}, url={self.url}," \
-               f" score={self.score}, rating={self.rating}, creator_id={self.creator_id}," \
-               f" has_children={self.has_children}, has_notes={self.has_notes}, has_comments={self.has_comments}" \
-               f" created_date={self.created_date}, status={self.status}, tags={self.tags})>"
-
-    def format_tags(self, format: str = "#"):
-        str_tags = (format + ' ').join(self.tags)
-        return str_tags.split(" ")
-
-
-class Rule34SamplePost(Rule34Post):
-    def __str__(self):
-        return f"<Rule34SamplePost(id={self.id}, height={self.height}, width={self.width}, url={self.url})>"
-
-
-class Rule34PreviewPost(Rule34Post):
-    def __str__(self):
-        return f"<Rule34PreviewPost(id={self.id}, height={self.height}, width={self.width}, url={self.url})>"
-
-
-class Rule34PostData:
-    def __init__(self, id: int, main: Rule34MainPost, sample: Rule34SamplePost, preview: Rule34PreviewPost):
-        self.id = id
-        self.main = main
-        self.sample = sample
-        self.preview = preview
-
-    def __str__(self):
-        return f"<Rule34PostData(id={self.id}, main={str(self.main)}, sample={str(self.sample)}," \
-               f" preview={str(self.preview)})>"

simple_rule34-0.1.5.4/src/SimpleRule34/setup.py

@@ -1,26 +0,0 @@
-from setuptools import setup, find_packages
-
-setup(
-    name='SimpleRule34',
-    version='0.1',
-    description='Simple api wrapper of rule34.xxx for python with asynchronous support',
-    packages=find_packages(),
-    install_requires=[
-        'aiohttp==3.8.4',
-        'aiosignal==1.3.1',
-        'async-timeout==4.0.2',
-        'attrs==23.1.0',
-        'certifi==2023.5.7',
-        'charset-normalizer==3.2.0',
-        'docopt==0.6.2',
-        'frozenlist==1.4.0',
-        'idna==3.4',
-        'multidict==6.0.4',
-        'pipreqs==0.4.13',
-        'requests==2.31.0',
-        'urllib3==2.0.3',
-        'yarg==0.1.9',
-        'yarl==1.9.2',
-    ],
-    url='https://github.com/Loshok229/rule34-simple-api'
-)

simple_rule34-0.1.5.4/src/SimpleRule34/types.py

@@ -1,95 +0,0 @@
-import datetime
-import requests
-import os
-
-from .utils import get_file_type, get_file_size
-
-
-class Rule34Post:
-    def __init__(self, height: int, width: int, url: str, id: int):
-        self.path = r'./rule34_download'
-        self.s = requests.Session()
-
-        self.height = height
-        self.width = width
-        self.url = url
-        self.id = id
-
-        self.file_type = get_file_type(self.url)
-
-    def __str__(self):
-        return f"<Rule34Post(id={self.id}, height={self.height}, width={self.width}, url={self.url})>"
-
-    def get_file_size(self):
-        return get_file_size(self.url, self.s)
-
-    def download(self, path = r'./rule34_download'):
-        r = self.s.get(self.url)
-        if r.status_code == 200:
-            try:
-                os.mkdir(self.path)
-            except:
-                pass
-
-            file_name = os.path.basename(self.url)
-            save_path = os.path.join(path, file_name)
-            with open(save_path, 'wb') as file:
-                file.write(r.content)
-
-            return save_path
-        else:
-            pass
-
-    def get_bytes(self):
-        r = self.s.get(self.url)
-
-        return r.content
-
-
-class Rule34MainPost(Rule34Post):
-    def __init__(self, score: int, rating: str, creator_id: int, tags: str, has_children: bool,
-                 created_date: datetime.datetime, status: str, source: str, has_notes: bool, has_comments: bool,
-                 height: int, width: int, url: str, id: int):
-        super().__init__(height, width, url, id)
-        self.score = score
-        self.rating = rating
-        self.creator_id = creator_id
-        self.tags = tags.split(" ")
-        self.has_children = has_children
-        self.created_date = created_date
-        self.status = status
-        self.source = source
-        self.has_notes = has_notes
-        self.has_comments = has_comments
-
-    def __str__(self):
-        return f"<Rule34MainPost(id={self.id}, height={self.height}, width={self.width}, url={self.url}," \
-               f" score={self.score}, rating={self.rating}, creator_id={self.creator_id}," \
-               f" has_children={self.has_children}, has_notes={self.has_notes}, has_comments={self.has_comments}" \
-               f" created_date={self.created_date}, status={self.status}, tags={self.tags})>"
-
-    def format_tags(self, format: str = "#"):
-        str_tags = (format + ' ').join(self.tags)
-        return str_tags.split(" ")
-
-
-class Rule34SamplePost(Rule34Post):
-    def __str__(self):
-        return f"<Rule34SamplePost(id={self.id}, height={self.height}, width={self.width}, url={self.url})>"
-
-
-class Rule34PreviewPost(Rule34Post):
-    def __str__(self):
-        return f"<Rule34PreviewPost(id={self.id}, height={self.height}, width={self.width}, url={self.url})>"
-
-
-class Rule34PostData:
-    def __init__(self, id: int, main: Rule34MainPost, sample: Rule34SamplePost, preview: Rule34PreviewPost):
-        self.id = id
-        self.main = main
-        self.sample = sample
-        self.preview = preview
-
-    def __str__(self):
-        return f"<Rule34PostData(id={self.id}, main={str(self.main)}, sample={str(self.sample)}," \
-               f" preview={str(self.preview)})>"

simple_rule34-0.1.5.4/src/SimpleRule34/utils.py

@@ -1,35 +0,0 @@
-import requests
-
-
-def get_file_size(url, session: requests.Session):
-    response = session.head(url, allow_redirects=True)
-    if 'Content-Length' in response.headers:
-        size = int(response.headers['Content-Length'])
-        return size
-    else:
-        return None
-
-
-def get_file_type(url):
-    file_extension = url.split('.')[-1].lower()
-    if file_extension in ['jpg', 'jpeg', 'png']:
-        return 'photo'
-    elif file_extension in ['mp4', 'avi', 'mov']:
-        return 'video'
-    elif file_extension == '.gif':
-        return 'animation'
-    else:
-        return None
-
-
-def remove_blocked_tags_posts(post_list, blocked_tags):
-    post_list_ = []
-
-    for post in post_list:
-        if blocked_tags in post.main.tags:
-            pass
-        else:
-            post_list_.append(post)
-
-    return post
-

simple_rule34-0.1.5.4/tests/test.py

@@ -1,62 +0,0 @@
-from SimpleRule34.src.SimpleRule34.aio.ARule34 import Rule34Api
-from SimpleRule34.src.SimpleRule34 import Rule34Api
-import asyncio
-
-
-async def main1():
-
-    r = Rule34Api()
-    print("=====ALL 10=====")
-    lis = await r.get_post_list(tags='', limit=10)
-
-    for x in lis:
-        print(x)
-
-    print("=====FIRST 5=====")
-    lis = await r.get_post_list(tags='brawl_stars', limit=5)
-
-    for x in lis:
-        print(x)
-
-    print("=====SECOND 5=====")
-    lis = await r.get_post_list(tags='brawl_stars', limit=5, page_id=1)
-
-    for x in lis:
-        print(x)
-
-    print("=====EDITED=====")
-    post_list_ = await r.get_post_list(tags='brawl_stars', limit=100, page_id=0,
-                                            forbidden_tags=['male'])
-
-    chunk_size = 5
-    for i in range(0, len(post_list_), chunk_size):
-        chunk = post_list_[i:i + chunk_size]
-        print(f"=====CHUNK {i}=====")
-        for x in chunk:
-            print(x)
-    i = 4
-    chunk = post_list_[i:i + chunk_size]
-    print(f"=====CHUNK {i}=====")
-    for x in chunk:
-        print(x)
-
-
-    print("=====TEST=====")
-    original_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
-
-    chunk_size = 5
-    for i in range(0, len(original_list), chunk_size):
-        print(i)
-        chunk = original_list[i:i + chunk_size]
-        print(chunk)
-
-    return
-
-
-async def main():
-    r = Rule34Api()
-    p = r.get_post(213)
-    print(p)
-
-if __name__ == '__main__':
-    asyncio.run(main())