Module booru.client.konachan

Classes

class Konachan

Expand source code

class Konachan(object):
    """Konachan Client

    Methods
    -------
    search : function
        Search and gets images from konachan.

    search_image : function
        Search and gets images from konachan, but only returns image.

    find_tags : function
        Get the proper tags from konachan.

    """

    @staticmethod
    def append_object(raw_object: dict):
        """Extends new object to the raw dict

        Parameters
        ----------
        raw_object : dict
            The raw object returned by konachan.

        Returns
        -------
        str
            The new value of the raw object
        """
        for i in range(len(raw_object)):
            if "id" in raw_object[i]:
                raw_object[i][
                    "post_url"
                ] = f"{get_hostname(Booru.konachan)}/post/show/{raw_object[i]['id']}"

        return raw_object

    def __init__(self):
        self.specs = {}

    async def search(
        self,
        query: str,
        block: str = "",
        limit: int = 100,
        page: int = 1,
        random: bool = True,
        gacha: bool = False,
    ) -> Union[list, str, None]:

        """Search method

        Parameters
        ----------
        query : str
            The query to search for.
        block : str
            The tags you want to block, separated by space.
        limit : int
            Expected number which is from pages
        page : int
            Expected number of page.
        random : bool
            Shuffle the whole dict, default is True.
        gacha : bool
            Get random single object, limit property will be ignored.

        Returns
        -------
        dict
            The json object (as string, you may need booru.resolve())
        """
        if limit > 1000:
            raise ValueError(Booru.error_handling_limit)

        elif block and re.findall(block, query):
            raise ValueError(Booru.error_handling_sameval)

        self.query = query
        self.specs["tags"] = self.query
        self.specs["limit"] = limit
        self.specs["page"] = page

        raw_data = await request(site=Booru.konachan, params_x=self.specs, block=block)
        self.appended = Konachan.append_object(raw_data)

        try:
            if gacha:
                return better_object(roll(self.appended))
            elif random:
                shuffle(self.appended)
                return better_object(self.appended)
            else:
                return better_object(Konachan.append_object(self.appended))
        except Exception as e:
            raise Exception(f"Failed to get data: {e}")

    async def search_image(
        self, query: str, block: str = "", limit: int = 100, page: int = 1
    ) -> Union[list, str, None]:

        """Parses image only

        Parameters
        ----------
        query : str
            The query to search for.
        block : str
            The tags you want to block, separated by space.
        limit : int
            Expected number which is from pages
        page : int
            Expected number of page.

        Returns
        -------
        dict
            The json object (as string, you may need booru.resolve())

        """
        if limit > 1000:
            raise ValueError(Booru.error_handling_limit)

        elif block and re.findall(block, query):
            raise ValueError(Booru.error_handling_sameval)

        self.query = query
        self.specs["tags"] = self.query
        self.specs["limit"] = limit
        self.specs["page"] = page

        raw_data = await request(site=Booru.konachan, params_x=self.specs, block=block)
        self.appended = Konachan.append_object(raw_data)

        try:
            return better_object(parse_image(self.appended))
        except Exception as e:
            raise Exception(f"Failed to get data: {e}")

    async def find_tags(self, query: str) -> Union[list, str, None]:
        """Find tags like a wildcard

        Parameters
        ----------
        query : str
            The tag to search for.

        Returns
        -------
        list
            The list of tags.
        """
        try:
            data = await request_wildcard(site=Booru.konachan_wildcard, query=query)
            return better_object(data)

        except Exception as e:
            raise Exception(f"Failed to get data: {e}")

Konachan Client

Methods

search : function Search and gets images from konachan.

search_image : function Search and gets images from konachan, but only returns image.

find_tags : function Get the proper tags from konachan.

Static methods

def append_object(raw_object: dict)

Expand source code

@staticmethod
def append_object(raw_object: dict):
    """Extends new object to the raw dict

    Parameters
    ----------
    raw_object : dict
        The raw object returned by konachan.

    Returns
    -------
    str
        The new value of the raw object
    """
    for i in range(len(raw_object)):
        if "id" in raw_object[i]:
            raw_object[i][
                "post_url"
            ] = f"{get_hostname(Booru.konachan)}/post/show/{raw_object[i]['id']}"

    return raw_object

Extends new object to the raw dict

Parameters

raw_object : dict

The raw object returned by konachan.

Returns

str

The new value of the raw object

Methods

async def find_tags(self, query: str) ‑> list | str | None

Expand source code

async def find_tags(self, query: str) -> Union[list, str, None]:
    """Find tags like a wildcard

    Parameters
    ----------
    query : str
        The tag to search for.

    Returns
    -------
    list
        The list of tags.
    """
    try:
        data = await request_wildcard(site=Booru.konachan_wildcard, query=query)
        return better_object(data)

    except Exception as e:
        raise Exception(f"Failed to get data: {e}")

Find tags like a wildcard

Parameters

query : str

The tag to search for.

Returns

list

The list of tags.

async def search(self,
query: str,
block: str = '',
limit: int = 100,
page: int = 1,
random: bool = True,
gacha: bool = False) ‑> list | str | None

Expand source code

async def search(
    self,
    query: str,
    block: str = "",
    limit: int = 100,
    page: int = 1,
    random: bool = True,
    gacha: bool = False,
) -> Union[list, str, None]:

    """Search method

    Parameters
    ----------
    query : str
        The query to search for.
    block : str
        The tags you want to block, separated by space.
    limit : int
        Expected number which is from pages
    page : int
        Expected number of page.
    random : bool
        Shuffle the whole dict, default is True.
    gacha : bool
        Get random single object, limit property will be ignored.

    Returns
    -------
    dict
        The json object (as string, you may need booru.resolve())
    """
    if limit > 1000:
        raise ValueError(Booru.error_handling_limit)

    elif block and re.findall(block, query):
        raise ValueError(Booru.error_handling_sameval)

    self.query = query
    self.specs["tags"] = self.query
    self.specs["limit"] = limit
    self.specs["page"] = page

    raw_data = await request(site=Booru.konachan, params_x=self.specs, block=block)
    self.appended = Konachan.append_object(raw_data)

    try:
        if gacha:
            return better_object(roll(self.appended))
        elif random:
            shuffle(self.appended)
            return better_object(self.appended)
        else:
            return better_object(Konachan.append_object(self.appended))
    except Exception as e:
        raise Exception(f"Failed to get data: {e}")

Search method

Parameters

query : str

The query to search for.

block : str

The tags you want to block, separated by space.

limit : int

Expected number which is from pages

page : int

Expected number of page.

random : bool

Shuffle the whole dict, default is True.

gacha : bool

Get random single object, limit property will be ignored.

Returns

dict

The json object (as string, you may need booru.resolve())

async def search_image(self, query: str, block: str = '', limit: int = 100, page: int = 1) ‑> list | str | None

Expand source code

async def search_image(
    self, query: str, block: str = "", limit: int = 100, page: int = 1
) -> Union[list, str, None]:

    """Parses image only

    Parameters
    ----------
    query : str
        The query to search for.
    block : str
        The tags you want to block, separated by space.
    limit : int
        Expected number which is from pages
    page : int
        Expected number of page.

    Returns
    -------
    dict
        The json object (as string, you may need booru.resolve())

    """
    if limit > 1000:
        raise ValueError(Booru.error_handling_limit)

    elif block and re.findall(block, query):
        raise ValueError(Booru.error_handling_sameval)

    self.query = query
    self.specs["tags"] = self.query
    self.specs["limit"] = limit
    self.specs["page"] = page

    raw_data = await request(site=Booru.konachan, params_x=self.specs, block=block)
    self.appended = Konachan.append_object(raw_data)

    try:
        return better_object(parse_image(self.appended))
    except Exception as e:
        raise Exception(f"Failed to get data: {e}")

Parses image only

Parameters

query : str

The query to search for.

block : str

The tags you want to block, separated by space.

limit : int

Expected number which is from pages

page : int

Expected number of page.

Returns

dict

The json object (as string, you may need booru.resolve())