Пример #1
1
def download(tags, pages):
	try:
		randomint = randint(1000, 10000000)
		randompage = randint(1, int(pages))
		client = Danbooru('danbooru', username='******', api_key='your_api_key')
		if len(x) == 0: #Checks if the array is empty of links
			posts = client.post_list(tags=str(tags), page=str(randompage), limit=200)
			for post in posts:
				fileurl = 'http://danbooru.donmai.us' + post['file_url']
				x.append(fileurl)
		else:
			pass
		try:
			urllib.request.urlretrieve(x[1], "tmp/danbooru_" + str(randomint) + ".jpg")
			x.pop(0)
		except Exception as e:
			print(e)
	except:
		download(tags, pages)
Пример #2
1
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
from pybooru import Danbooru

client = Danbooru('danbooru')
tags = client.tag_list(order='date')

for tag in tags:
    print("Tag: {0} ----- {1}".format(tag['name'], tag['category']))
Пример #3
0
def download(tags, pages):
    try:
        client = Danbooru('danbooru',
                          username='******',
                          api_key='your_api_key')

        # Collect links
        while len(x) is not 200:  # Checks if the list is full
            randompage = randint(1, pages)
            posts = client.post_list(tags=tags, page=randompage, limit=200)
            for post in posts:
                try:
                    fileurl = 'https://danbooru.donmai.us' + post['file_url']
                except:
                    fileurl = 'https://danbooru.donmai.us' + post['source']
                x.append(fileurl)

        # Download images
        for url in x:
            try:
                randomint = randint(1000, 10000000)
                urllib.request.urlretrieve(
                    url, "tmp/danbooru_/{0}.jpg".format(randomint))
            except:
                continue
    except Exception as e:
        raise e
Пример #4
0
def collect(tags, pages):
    try:
        #authentication
        client = Danbooru('danbooru', username="******", api_key="12d62QBEC2XbxnEoEV6iRu1G")
        
        #Global variables to make the download function happy
        global fileurl
        global posts
        
        #getting max page, tags, and creating output.txt
        randompage = int(input("What are the maximum amount of pages? "))
        chosenpage = random.choice(range(0, randompage)) #chooses a random page between 1 and the specified max page, prevents empty files
        posts = client.post_list(tags=tags, page=chosenpage, limit=200) #seems to be a hardcoded limit of 200, documentation says 100?

        output = open("output.txt", "a+") #creates output.txt if it doesn't exist, appends to output.txt if it does exist
        output.write("From page " + str(chosenpage) + " with tag(s) " + tags + ": \n") #writes page number and tag(s) before links

        #getting links... i think?
        for post in posts:
            try:
                fileurl = post['file_url']
            except:
                fileurl = post['source']
            #writing links
            output.write(fileurl + "\n") #outputs URLs to output.txt
        print("Done! Written links to output.txt... hopefully")
    except Exception as err:
        print(err)
        raise err #doesn't really do shit honestly unless something goes catastrophically wrong
Пример #5
0
 def __init__(self, client):
     self.client = client
     self.dan_client = Danbooru('danbooru',
                                username='******',
                                api_key='PubbhbW6nutC3yiFrBCrZs7S')
     self.yan_client = Moebooru(site_url='https://yande.re',
                                username='******',
                                password='******')
     self.default_tags = ['yuri']
Пример #6
0
 def __init__(self, line, reddit, dvart, tw, youtube):
     self.client = Danbooru(site_url='https://safebooru.donmai.us/')
     self.limit = 3
     self.bpm = 660
     self.line_bot_api = line
     self.reddit = reddit
     self.da = dvart
     self.tw = tw
     self.yt = youtube
Пример #7
0
 async def dhentai(self, ctx, tags):
     dClient = Danbooru('danbooru')
     s = dClient.post_list(limit=1, tags=tags, random=True)
     embed = discord.Embed(title="Danbooru hentai!", color=0xff00f6)
     try:
         embed.set_image(url=s[0]['file_url'])
         embed.set_footer(text=s[0]['tag_string'])
         await ctx.send(embed=embed)
     except:
         await ctx.send('попробуй ещё раз')
Пример #8
0
 def __init__(self, bot):
     self.bot = bot
     configParser = configparser.RawConfigParser()   
     configfilepath = 'config.txt'
     configParser.read(configfilepath)
     self.danbooruUsername = configParser.get('danbooru', 'username')
     self.danbooruPassword = configParser.get('danbooru', 'password')
     self.imgurToken = configParser.get('imgur', 'token')
     self.fuccboiname = 'bonkery' 
     self.fuccboidate = date(2018, 12, 6)
     self.dbclient = Danbooru('danbooru', username=self.danbooruUsername, api_key=self.danbooruPassword)
def danbooru(danbooru_id):
    '''returns danbooru post using id'''
    if danbooru_id != 0:
        print('checking details on danbooru.donmai.us')
        try:
            client = Danbooru('danbooru')
            post = client.post_show(danbooru_id)
            logger.dump(post, 'last_danbooru_response.txt')  #debug
            return post
        except Exception as e:
            print(e)
            return ''
Пример #10
0
def get_from_danbooru_by_tag(tag):
    client = Danbooru('danbooru')
    tags = client.tag_list(name_matches=tag, hide_empty="yes", order="count")
    tag = ""
    for x in tags:
        if len(x) != 0:
            #making sure that the particular tag isn't empty. If it is, then a random image is displayed.
            tag = x["name"]
            break

    #got the tags. Now what? Images!

    posts = client.post_list(tags=tag, random=True, raw=True)
    return posts
Пример #11
0
    def init_client(self):
        if self.api:
            if not self.username:
                raise ValueError('Danbooru API Services need a Username when API key is given.')
            self.client = PyDanbooru(site_name=self.name, site_url=self.url, api_key=self.api, username=self.username)
        else:
            self.client = PyDanbooru(site_name=self.name, site_url=self.url)

        self.user_level = self.get_user_level()
        self.tag_limit = self.LEVEL_RESTRICTIONS['tag_limit'][self.user_level]
        self.censored_tags = self.LEVEL_RESTRICTIONS['censored_tags'][self.user_level]

        if not self.url:
            self.url = self.client.site_url.lstrip('/')
Пример #12
0
def danbooru(tags):
    for i in range(0,5):
        dan = Danbooru('danbooru', username=config.get('danbooru_username'), api_key=config.get('danbooru_key'))
        while True:
            try:
                posts = dan.post_list(tags=tags, limit=1, random="True")
                return posts[0]['file_url'], posts[0]['id'], posts[0]['created_at'], posts[0]['source']
            except KeyError:
                continue
            except IndexError:
                break
            except:
                continue            
            break
Пример #13
0
async def get_anime(ctx, *, tag: str = None):
    if tag is None:
        return await ctx.send('Enter a tag')

    client = Danbooru('danbooru')
    get_image = client.post_list(**{
        'limit': 1,
        'page': 1,
        'tags': tag,
        'random': True
    })
    for image in get_image:
        response = image['large_file_url']

    await ctx.send(response)
Пример #14
0
 def __init__(self, bot: Konoha):
     self.bot: Konoha = bot
     self.client = Danbooru("danbooru",
                            username=config.danbooru_name,
                            api_key=config.danbooru_key)
     # pylint: disable=no-member
     self.postloop.start()
Пример #15
0
    def __init__(self, config):
        self.config = config
        self.api = get_api(self.config)

        self.danbooru = Danbooru(site_url=DANBOORU_URL)
        self.image_list = []

        self.last_notification = -1
        if os.path.exists(self.config.state_file):
            with open(self.config.state_file) as f:
                try:
                    self.last_notification = int(f.read())
                    logging.debug(
                        'Recovering state, last notification id is %d',
                        self.last_notification)
                except ValueError:
                    logging.debug('No previous state found')
Пример #16
0
async def lewd(message, attempts=0):
    if attempts == 5:
        return

    try:
        query = message.content[message.content.index(' ') + 1:]

        bclient = Danbooru('danbooru')
        pic = bclient.post_list(tags=query, random=True)
        try:
            fileurl = pic[0]['file_url']
        except:
            fileurl = pic[0]['source']
    except:
        await lewd(message, attempts + 1)

    await core.reply(message.channel, fileurl)
Пример #17
0
 async def safebooru(self, ctx):
     """Same as danbooru, but looks for safe images."""
     client = Danbooru('danbooru', username='******', api_key=self.bot.settings.danboorutoken)
     image_found = False
     while not image_found:
         temp = self.fixDanbooruJSON(str(client.post_list(random=True, limit=1, tags="rating:s -status:deleted")))
         data = json.loads(temp)
         if 'file_url' in data:
             image_found = True
     url = data['file_url']
     if ctx.message.guild is not None:
         color = ctx.message.guild.me.color
     else:
         color = discord.Colour.blue()
     embed = discord.Embed(color=color, title="Image from Project Danbooru!", description="Here's your image, {}~".format(ctx.message.author.name))
     embed.set_image(url=url)
     embed.set_footer(text="Powered by Project Danbooru.")
     await ctx.send(embed=embed)
Пример #18
0
class Photos(commands.Cog):
    def __init__(self, bot):
        self.bot = bot
        self.danbooru_client = Danbooru(site_name='danbooru')

    def _get_url_list_danbooru(self, tag, request_number):
        posts = self.danbooru_client.post_list(limit=request_number,
                                               tags=tag,
                                               random=True)
        pictures = []

        for post in posts:
            pictures += [post['file_url']]

        return pictures

    @commands.command()
    async def unleash_load_danbooru(self, ctx, arg1):

        urls = self._get_url_list_danbooru(arg1, 5)

        # Check if at least 1 image is found
        if urls == []:
            await ctx.send('no images found')
            return

        fmt = ""

        for url in urls:
            fmt += url + "\n"

        await ctx.send(fmt)

    @commands.command()
    async def danbooru(self, ctx, arg1):

        urls = self._get_url_list_danbooru(arg1, 1)

        # construct embedded image
        discord_embed = discord.Embed(colour=0x4286f4)
        discord_embed.set_author(name=arg1)
        discord_embed.set_footer(text=ctx.message.author)

        # check if danbooru tag returns url
        if urls == []:
            discord_embed.title = 'No image found'
        else:
            discord_embed.set_image(url=urls[0])

        try:
            await ctx.send(embed=discord_embed)
        except discord.HTTPException:
            print('sending the message failed')
        finally:
            print(discord_embed.to_dict())
Пример #19
0
async def danbooru(ctx, *, search: str):
    from pybooru import Danbooru, exceptions

    client = Danbooru('danbooru')
    try:
        posts = client.post_list(tags=search, random=True, limit=1)
    except exceptions.PybooruHTTPError:
        await ctx.send('Danbooru only allows you to search with 2 tags. Consider donating $20 if you want to search with more tags')
    url = 'https://danbooru.donmai.us/posts/'

    for post in posts:
        id = str(post['id'])
        dblink = url + id
        if str(post['file_url']).startswith('/data/'):
            file = 'https://donmai.us{}'.format(post['file_url'])
        else:
            file = post['file_url']
            if post['rating'] == "s":
                rating = 'Safe'
            elif post['rating'] == 'q':
                rating = 'Questionable'
            elif post['rating'] == 'e':
                rating = 'Explicit'
        score = post['score']
        source = post['source']

        emb = discord.Embed(
            title='Click here to view in your browser',
            url=dblink,
            colour=0xEC40DF,
            description='__Post ID: {}__'.format(id)
        )
        emb.set_image(url=file)
        emb.set_author(name='Danbooru', url='http://danbooru.donmai.us',
                       icon_url='https://qt-anime-grils.is-serious.business/555270.png')
        emb.add_field(name='Rating: ', value=rating, inline=True)
        emb.add_field(name='Score: ', value=score, inline=True)
        emb.add_field(name='Source: ', value='[Click Here]({})'.format(source), inline=False)

        await ctx.send(embed=emb)
Пример #20
0
 async def danbooru(self, ctx):
     """Posts an image directly from Project Danbooru."""
     client = Danbooru('danbooru', username='******', api_key=self.bot.settings.danboorutoken)
     if ctx.message.channel.is_nsfw():
         image_found = False
         while not image_found:
             temp = self.fixDanbooruJSON(str(client.post_list(random=True, limit=1, tags="rating:e -status:deleted")))
             data = json.loads(temp)
             if 'file_url' in data:
                 image_found = True
         url = data['file_url']
     else:
         await ctx.send("Sorry, but I can't load anything from Project Danbooru unless you're in a NSFW channel.")
         return
     if ctx.message.guild is not None:
         color = ctx.message.guild.me.color
     else:
         color = discord.Colour.blue()
     embed = discord.Embed(color=color, title="Image from Project Danbooru!", description="Here's your image, {}~".format(ctx.message.author.name))
     embed.set_image(url=url)
     embed.set_footer(text="Powered by Project Danbooru.")
     await ctx.send(embed=embed)
Пример #21
0
class anime(commands.Cog):
    def __init__(self, bot):
        self.client=Danbooru('danbooru', api_key=dbexec('danbooruKey', log=True))
        self.bot = bot

    @commands.command(aliases=['dnb'])
    async def danbooru(self, ctx, *, tags1: str):
        """Gets an image from Danbooru, tags must be valid tags on the website"""
        #replacement_table = {
        #    r' ': '_',
        #    r',': ' '
        #}
        #for regex, replace_with in replacement_table.items():
        #    tags1 = re.sub(regex, replace_with, tags1)

        try:
            #Create post object
            class post:
                def __init__(self, data):
                    self.id = data[0]['id']
                    self.score = data[0]['score']
                    self.rating = data[0]['rating']
                    self.img = data[0]['file_url']
                    self.uploadername = data[0]['uploader_name']
            try:
                while True:
                    counter=1
                    print("Attempt {}".format(counter))
                    data = self.client.post_list(limit=1,tags=tags1, random=True)
                    if (not data):
                        await ctx.send("Invalid tag*(s)*")
                        return

                    bnd = post(data)
                    if(bnd.rating =='s'):
                        break

            except(Exception) as e:
                print(e)
                await ctx.send('An error occured')
                return
            
            em = discord.Embed(title="Search result", url=bnd.img)
            em.add_field(name='Uploaded by', value=bnd.uploadername, inline=True)
            em.add_field(name="Score", value=bnd.score, inline=True)
            em.set_image(url=bnd.img)
            print("img={}".format(bnd.img))
            await ctx.send(embed=em)

        except(Exception) as e:
            print(e)
Пример #22
0
def pic(update: Update, context: CallbackContext, ind: int, uind: int,
        is_group: bool, lang: str):
    message = update.effective_message
    ab = message.text.split(' ')

    if (len(ab) == 1):
        sendtext = other.proc(other.getl(lang).error_pic_noTag)
        context.bot.send_message(message.chat.id, sendtext, parse_mode='HTML')
        return
    client = Danbooru('danbooru')
    temp = None
    if (ab[1] == 'hentai'):
        temp = client.post_list(tags='rating:e',
                                page=random.randint(1, 200),
                                limit=1)[0]
    elif (ab[1] == 'anime'):
        temp = client.post_list(tags='rating:s',
                                page=random.randint(1, 200),
                                limit=1)[0]
    elif (ab[1] == 'ecchi'):
        temp = client.post_list(tags='rating:q',
                                page=random.randint(1, 200),
                                limit=1)[0]
    elif (ab[1] == 'yuri'):
        temp = client.post_list(tags='yuri',
                                page=random.randint(1, 200),
                                limit=1)[0]
    elif (ab[1] == 'uncensored'):
        temp = client.post_list(tags='uncensored',
                                page=random.randint(1, 200),
                                limit=1)[0]
    elif (ab[1] == 'neko'):
        temp = client.post_list(tags='cat_ears',
                                page=random.randint(1, 200),
                                limit=1)[0]
    elif (ab[1] == 'wallpaper'):
        temp = client.post_list(tags='wallpaper',
                                page=random.randint(1, 200),
                                limit=1)[0]
    context.bot.send_photo(message.chat.id,
                           temp['file_url'],
                           caption='Tags: ' + temp['tag_string'])
    print('done')
Пример #23
0
def send_found_photos(message):
    msg_args = message.text.split(' ')

    POST_PER_REQUEST = 200

    bot.send_message(message.chat.id, 'Начинаю...')

    tag_names = msg_args[1]
    client = Danbooru('danbooru')
    total_posts = client.tag_list(name=tag_names)[0]['post_count']

    pages_found = (total_posts // POST_PER_REQUEST) + 1
    params = {'limit': total_posts, 'tags': tag_names, 'page': None}
    for page in range(1, pages_found + 1):
        params['page'] = page
        founded_posts = client.post_list(**params)
        for post in founded_posts:
            if not 'file_url' in post.keys():
                continue
            file_url = post['file_url']
            response = requests.get(file_url)
            file_content = response.content
            bot.send_photo(message.chat.id, file_content)
Пример #24
0
 def login(self):
     logger.info("login into mastodon bot...")
     self.mastodon_api = Mastodon(client_id=self.settings.client_id,
                                  client_secret=self.settings.client_secret,
                                  access_token=self.settings.access_token,
                                  api_base_url=self.settings.domain)
     try:
         logger.info("login into twitter account...")
         auth = tweepy.OAuthHandler(
             self.settings.accounts.twitter.consumer_key,
             self.settings.accounts.twitter.consumer_secret)
         auth.set_access_token(
             self.settings.accounts.twitter.access_token,
             self.settings.accounts.twitter.access_token_secret)
         self.tweet_api = tweepy.API(auth)
     except AttributeError:
         logger.debug("twitter credentials not definied")
         self.tweet_api = False
     try:
         logger.info("login into danbooru account...")
         self.danbooru_api = Danbooru(
             'danbooru',
             username=self.settings.accounts.danbooru.username,
             api_key=self.settings.accounts.danbooru.token)
     except AttributeError:
         logger.debug("danbooru credentials not definied")
         self.danbooru_api = False
     try:
         logger.info("login into pixiv account...")
         self.pixiv_api = AppPixivAPI()
         self.pixiv_api.login(self.settings.accounts.pixiv.username,
                              self.settings.accounts.pixiv.password)
     except AttributeError:
         logger.debug("pixiv credentials not definied")
         # self.pixiv_api = AppPixivAPI()
         self.pixiv_api = False
Пример #25
0
def getEroPic() -> str:
    reqTags = 'rating:s -male_focus'
    pages = 100
    client = Danbooru('danbooru')

    randompage = randint(1, pages)
    posts = client.post_list(tags=reqTags, page=randompage, limit=1)
    post = posts[0]
    try:
        picUrl = post['file_url']
    except:
        picUrl = post['source']
        
    picUrl = re.sub('^https', 'http', picUrl, count=1)
	#改为返回图片的url
    # picDat = requests.get(picUrl).content
    
    # picFormat = re.findall('.[a-zA-Z]+$', picUrl)
    # picName = randint(1000, 10000000)
    # picAddr = './plugins/eroPic/{0}'.format(picName)+picFormat[0]
    # with open(picAddr, 'wb') as handle:
        # handle.write(picDat)
    
    return picUrl
Пример #26
0
def download(tags, pages):
    try:
        client = Danbooru('danbooru', username='******', api_key='your_api_key')

        # Collect links
        while len(x) is not 200:  # Checks if the list is full
            randompage = randint(1, pages)
            posts = client.post_list(tags=tags, page=randompage, limit=200)
            for post in posts:
                try:
                    fileurl = post['file_url']
                except:
                    fileurl = 'https://danbooru.donmai.us' + post['source']
                x.append(fileurl)

        # Download images
        for url in x:
            try:
                randomint = randint(1000, 10000000)
                urllib.request.urlretrieve(url, "tmp/danbooru_/{0}.jpg".format(randomint))
            except:
                continue
    except Exception as e:
        raise e
Пример #27
0
 def __init__(self,
              duname: str,
              dapi: str,
              rid: str,
              rsec: str,
              rname: str,
              runame: str,
              rpass: str,
              nsfw_allowed=False):
     if (duname and dapi and rid and rsec and rname and runame and rpass):
         self.danbooru = Danbooru(site_url="https://danbooru.donmai.us/",
                                  username=duname,
                                  api_key=dapi)
         self.reddit = praw.Reddit(client_id=rid,
                                   client_secret=rsec,
                                   user_agent=rname,
                                   username=runame,
                                   password=rpass)
         self.nsfw_allowed = nsfw_allowed
Пример #28
0
def get_from_danbooru(char_name, anime_name):
    full_tag = char_name + " (" + anime_name + ")"
    #print(full_tag)
    client = Danbooru('danbooru')
    #getting full tag AKA Character_Nme(Anime Name) format
    tags = client.tag_list(name_matches=full_tag,
                           hide_empty="yes",
                           order="count")
    print(tags)
    tag = ""
    #Checking if there were no search results, and then getting tags with merely the character name
    if (len(tags) == 0):
        tags = client.tag_list(name_matches=char_name,
                               hide_empty="yes",
                               order="count")

    if (len(tags) == 0):
        #searching for last name, first name format, if the other doesn't work
        reverse_name = ""
        name = char_name.split(' ')
        n = len(name) - 1
        while (n >= 0):
            reverse_name = reverse_name + " " + name[n]
            n -= 1

        print(reverse_name)

        tags = client.tag_list(name_matches=reverse_name,
                               hide_empty="yes",
                               order="count")

    for x in tags:
        if len(x) != 0:
            tag = x["name"]
            break
    print(tag)

    #get posts for tag.
    posts = client.post_list(tags=tag, random=True, raw=True)
    #print(posts[0]['large_file_url'])
    return posts
Пример #29
0
class DanbooruService(BaseService):
    FREE_LEVEL = 20
    GOLD_LEVEL = 30
    PLATINUM_LEVEL = 31
    BUILDER = 32
    JANITOR = 35
    MODERATOR = 40
    ADMIN = 50

    LEVEL_RESTRICTIONS = {
        'tag_limit': {
            FREE_LEVEL: 2,
            GOLD_LEVEL: 6,
            PLATINUM_LEVEL: 12,
            BUILDER: 32,
            JANITOR: 35,
            MODERATOR: 40,
            ADMIN: 50,
        },
        'censored_tags': {
            FREE_LEVEL: True,
            GOLD_LEVEL: False,
            PLATINUM_LEVEL: False,
            BUILDER: False,
            JANITOR: False,
            MODERATOR: False,
            ADMIN: False,
        }
    }

    type = 'danbooru'

    def __init__(self, name: str, url: str, api: str = None, username: str = None, password: str = None) -> None:
        super(DanbooruService, self).__init__(name=name, url=url, api=api, username=username, password=password)
        self.user_level = None

        self.init_client()
        # self.init_session()

    def init_client(self):
        if self.api:
            if not self.username:
                raise ValueError('Danbooru API Services need a Username when API key is given.')
            self.client = PyDanbooru(site_name=self.name, site_url=self.url, api_key=self.api, username=self.username)
        else:
            self.client = PyDanbooru(site_name=self.name, site_url=self.url)

        self.user_level = self.get_user_level()
        self.tag_limit = self.LEVEL_RESTRICTIONS['tag_limit'][self.user_level]
        self.censored_tags = self.LEVEL_RESTRICTIONS['censored_tags'][self.user_level]

        if not self.url:
            self.url = self.client.site_url.lstrip('/')

    def init_session(self):
        if self.username and self.password and self.url:
            self.session = HTMLSession()
            login_page = self.session.get(f'{self.url.lstrip("/")}/session/new')
            try:
                form = login_page.html.find('.simple_form')[0]
            except Exception as err:
                __import__('pdb').set_trace()
                raise err

            login_data = {
                'name': self.username,
                'password': self.password,
                'remember': '1',
            }
            for input in form.find('input'):
                value = input.attrs.get('value', None)
                name = input.attrs.get('name', None)
                if name:
                    login_data.setdefault(name, value)

            self.session.post(f'{self.url.lstrip("/")}/session', login_data)

    def get_user_level(self):
        user_level = 20
        if self.username:
            user = self.client.user_list(name_matches=self.client.username)
            user_level = user[0]['level']
        return user_level
Пример #30
0
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
from pybooru import Danbooru

client = Danbooru('danbooru', username='******', api_key='yout-api_key')
response = client.comment_create(post_id=id, body='your comment')

print(client.last_call)
Пример #31
0
#!/usr/bin/env python
# -*- coding: utf-8 -*-

from __future__ import unicode_literals
from telegram.ext import Updater, CommandHandler, MessageHandler, Filters
import logging

from pybooru import Danbooru

client = Danbooru('danbooru')

# Enable logging
logging.basicConfig(
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    level=logging.INFO)

logger = logging.getLogger(__name__)
configFile = open("config.txt", "r")  #Replace that line with YOUR config.txt
token = str(configFile.readline())


def start(bot, update):

    update.message.reply_text('Hi {}!'.format(
        update.message.from_user.first_name))


def help(bot, update):

    update.message.reply_text("""
    Jill at your service.
Пример #32
0
# encoding: utf-8
from __future__ import print_function
from pybooru import Danbooru
from pybooru import Moebooru

konachan = Moebooru("konachan")

kona_tags = konachan.tag_list(order='date')
print(konachan.last_call)
kona_post = konachan.post_list()
print(konachan.last_call)

danbooru = Danbooru('danbooru')

dan_tags = danbooru.tag_list(order='name')
print(danbooru.last_call)
dan_post = danbooru.post_list(tags="computer")
print(danbooru.last_call)
Пример #33
0
 def __init__(self, bot):
     self.bot = bot
     self.danbooru_client = Danbooru(site_name='danbooru')
Пример #34
0
def parser(bot,
           update,
           tags,
           pages,
           chat_id,
           info=None,
           ch_id=None):  #Usual parser for usual commands
    global x
    global p_id
    randomint = randint(1000, 10000000)
    if ch_id == '9':
        bot.sendChatAction(chat_id, "upload_document")
        client = Danbooru('danbooru',
                          username='******',
                          api_key=danbooru_key)
    else:
        bot.sendChatAction(chat_id, "upload_photo")
        client = Moebooru('yandere')
    try:
        randompage = randint(1, int(pages))
        if len(x[str(ch_id)]['url']) == 0:
            posts = client.post_list(tags=str(tags), page=randompage, limit=40)
            for post in posts:
                if ch_id == '9':
                    fileurl = post['file_url']
                else:
                    fileurl = post['sample_url']
                x[str(ch_id)]['url'].append(fileurl)
                x[str(ch_id)]['id'].append(post['id'])
        if ch_id == '9':
            ikeyboard = InlineKeyboardMarkup(
                [[
                    InlineKeyboardButton("Donate",
                                         url='https://paypal.me/ev3rest')
                ],
                 [InlineKeyboardButton("Music", url='https://t.me/musicave')],
                 [
                     InlineKeyboardButton(
                         "More",
                         callback_data="{'data':'More', 'c_id':%s}" % ch_id)
                 ]])
        else:
            ikeyboard = InlineKeyboardMarkup(
                [[
                    InlineKeyboardButton("Donate",
                                         url='https://paypal.me/ev3rest')
                ],
                 [InlineKeyboardButton("Music", url='https://t.me/musicave')],
                 [
                     InlineKeyboardButton(
                         "Download",
                         callback_data="{'data':'Download', 'id':%s}" %
                         x[str(ch_id)]['id'][0])
                 ],
                 [
                     InlineKeyboardButton(
                         "More",
                         callback_data="{'data':'More', 'c_id':%s}" % ch_id)
                 ]])
        reply_markup = ikeyboard
        if ch_id != '9':
            bot.sendPhoto(chat_id,
                          photo=x[str(ch_id)]['url'][0],
                          reply_markup=reply_markup,
                          caption=info)
        else:
            bot.sendDocument(chat_id,
                             document=x[str(ch_id)]['url'][0],
                             reply_markup=reply_markup,
                             caption=info)
        try:
            x[str(ch_id)]['url'].pop(0)
        except:
            traceback.print_exc()
        try:
            x[str(ch_id)]['id'].pop(0)
        except:
            traceback.print_exc()

    except Exception:
        traceback.print_exc()
        bot.sendMessage(
            chat_id,
            'Oops... Something went wrong, please call the command again!')
        try:
            os.remove('tmp/uncensored_bot_' + str(randomint) + ".jpg")
        except:
            pass
        try:
            x[str(ch_id)]['url'].pop(0)
        except:
            traceback.print_exc()
        try:
            x[str(ch_id)]['id'].pop(0)
        except:
            traceback.print_exc()
Пример #35
0
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
from pybooru import Danbooru

client = Danbooru('danbooru')
posts = client.post_list(tags='blue_eyes', limit=5)

for post in posts:
    print("Image path: {0}".format(post['file_url']))