Exemple #1
0
def getFromPexels():
    api_key = 'useyourownapi'

    py_pexels = PyPexels(api_key=api_key)
    listback=[]
    popular_photos = py_pexels.popular(page=random.randrange(0,202,2))
    for photo in popular_photos.entries:
        landsc=photo.src["landscape"]
        if landsc is not "":
           listback.append(photo.src["landscape"])
           #print(listback)
        #else:
        #   popular_photos=popular_photos.get_next_page()
    for i in range(len(listback)):
        try:
            print(listback[i])
            opener = urllib.request.Request(listback[i])
            opener.add_header('User-Agent','Mozilla/5.0 (X11; Linux x86_64; rv:65.0) Gecko/20100101 Firefox/65.0')
            fx = open('/home/devnull/Pictures/background/background.jpg','wb')
            fx.write(urllib.request.urlopen(opener).read())
            fx.close()
            #listback.remove(listback[i])
            time.sleep(660)
        except IndexError:
            print("List Index Out of Range")
            break
Exemple #2
0
    def test_curated(self):
        index = 'curated'
        resource_filepath = self.store_mapping[index]
        stored_response = json.loads(open(resource_filepath).read())

        responses.add(
            responses.GET,
            'https://api.pexels.com/v1/curated?page=2&per_page=5',
            json=stored_response,
            status=200,
            content_type='application/json',
            adding_headers={'Authorization': api_key},
            match_querystring=True,
        )
        py_pexels = PyPexels(api_key=api_key)
        curated_results_page = py_pexels.curated(page=2, per_page=5)

        # Page properties
        print(curated_results_page.page)
        print(curated_results_page.per_page)
        print(curated_results_page.has_next)
        print(curated_results_page.has_previous)
        print(curated_results_page.link_self)
        print(curated_results_page.link_first)
        print(curated_results_page.link_last)
        print(curated_results_page.link_next)
        print(curated_results_page.link_previous)

        # Entries
        for photo in curated_results_page.entries:
            print(photo.id, photo.photographer, photo.width, photo.height, photo.url)
            print(photo.src)
Exemple #3
0
    def test_search(self):
        index = 'redflowervideo'
        resource_filepath = self.store_mapping[index]
        stored_response = json.loads(open(resource_filepath).read())

        responses.add(
            responses.GET,
            '{}{}'.format(API_ROOT, stored_response.get('_url')),
            # _url contains only the short path like /popular?page=2&per_page=5
            json=stored_response.get('body'),
            status=stored_response.get('status_code'),
            content_type='application/json',
            adding_headers=stored_response.get('headers'),
            match_querystring=True,
        )
        py_pexels = PyPexels(api_key=api_key)
        search_results_page = py_pexels.videos_search(query='red flower',
                                                      page=2,
                                                      per_page=5)

        # Page properties
        print(search_results_page.page)
        print(search_results_page.per_page)
        print(search_results_page.has_next)
        print(search_results_page.has_previous)
        print(search_results_page.link_self)
        print(search_results_page.link_first)
        print(search_results_page.link_last)
        print(search_results_page.link_next)
        print(search_results_page.link_previous)

        # Entries
        for video in search_results_page.entries:
            print(video.id, video.user, video.width, video.height, video.url)
            print(video.video_files)
Exemple #4
0
def pexels_parse_resp(subject):
    """
    From Pexels API resp, collect the top 4 images from results.
        :param subject: The subject to be used for the image search or type(None). If None, random photos are fetched.
        :rtype images: A list containing data on the fetched images.
        :except AttributeErrror: Occurs when resp fails to fetch images and enumerate cannot parse resp.
    """
    py_pexel = PyPexels(api_key=PEXELS_API_KEY)
    if subject is not None:
        resp = py_pexel.search(query=subject, per_page=4)
    else:
        resp = py_pexel.random(per_page=4)
    images = []
    try:
        for num, item in enumerate(resp.entries, 1):
            image_info = {
                "author_name": item.photographer,
                "full_image": item.src["original"],
                "image_id": item.id,
                "author_profile": item.photographer_url,
            }
            images.append(image_info)
        return images
    except AttributeError as err:
        handle_err(
            f"Failed to parse pexels resp object: {err}\nCheck that your API_KEYs are setup correctly."
        )
Exemple #5
0
    def test_popular(self):
        index = 'popular'
        resource_filepath = self.store_mapping[index]
        stored_response = json.loads(open(resource_filepath).read())

        responses.add(
            responses.GET,
            '{}/{}{}'.format(API_ROOT, API_VERSION,
                             stored_response.get('_url')),
            # _url contains only the short path like /popular?page=2&per_page=5
            json=stored_response.get('body'),
            status=stored_response.get('status_code'),
            content_type='application/json',
            adding_headers=stored_response.get('headers'),
            match_querystring=True,
        )
        py_pexels = PyPexels(api_key=api_key)
        popular_results_page = py_pexels.popular(page=2, per_page=5)

        # Page properties
        print(popular_results_page.page)
        print(popular_results_page.per_page)
        print(popular_results_page.has_next)
        print(popular_results_page.has_previous)
        print(popular_results_page.link_self)
        print(popular_results_page.link_first)
        print(popular_results_page.link_last)
        print(popular_results_page.link_next)
        print(popular_results_page.link_previous)

        # Entries
        for photo in popular_results_page.entries:
            print(photo.id, photo.photographer, photo.width, photo.height,
                  photo.url)
            print(photo.src)
Exemple #6
0
def execute_search(key, string, pages, format):

    pexels_instance = PyPexels(api_key=key)
    search_results = pexels_instance.search(query=string, per_page=pages)

    while True:
        for image in search_results.entries:
            search_urls.append(image.src.get(format))
            print(image.src.get(format))
        if not search_results.has_next:
            break
        search_results = search_results.get_next_page()
Exemple #7
0
def img(term='Puppies'):

    py_pexels = PyPexels(api_key=pexels_token)

    search_results = py_pexels.search(query=term, per_page=5)

    i = 0
    while i < 5:
        for photo in search_results.entries:
            id.append(photo.id)
            l = f"https://images.pexels.com/photos/{photo.id}/pexels-photo-{photo.id}.jpeg?auto=compress&cs=tinysrgb&dpr=2&h=650&w=940"
            links.append(l)
            i += 1
Exemple #8
0
class PyPexelApi:
    pypexels = None

    def __init__(self, pypexels_api_key=None):
        self.pypexels = PyPexels(api_key=pypexels_api_key)

    def get_single_random_photo(self):
        random_photo = self.pypexels.random(per_page=1)
        for photo in random_photo.entries:
            photo_url = str(photo.src['large'])
            photo_photographer_name = photo.photographer.encode('utf-8')
            photo_photographer_url = str(photo.photographer_url)
            photo_id = str(photo.id)
            photo = Photo(photo_url, photo_photographer_name,
                          photo_photographer_url, photo_id)

        return photo

    def get_photos_by_search(self, search_term=None, limit=None):
        list_photos = []
        search_results_page = self.pypexels.search(query=search_term,
                                                   per_page=limit)
        for pexel_photo in search_results_page.entries:
            photo_url = str(pexel_photo.src['large'])
            photo_photographer_name = str(pexel_photo.photographer)
            photo_photographer_url = str(pexel_photo.photographer_url)
            photo_id = str(pexel_photo.id)
            photo = Photo(photo_url, photo_photographer_name,
                          photo_photographer_url, photo_id)
            list.append(photo)

        return list_photos

    def get_popular_photos(self, limit=None):
        list_photos = []
        popular_photos_page = self.pypexels.popular(per_page=limit)
        for pexel_photo in popular_photos_page.entries:
            photo_url = str(pexel_photo.src['large'])
            photo_photographer_name = str(pexel_photo.photographer)
            photo_photographer_url = str(pexel_photo.photographer_url)
            photo_id = str(pexel_photo.id)
            photo = Photo(photo_url, photo_photographer_name,
                          photo_photographer_url, photo_id)
            list_photos.append(photo)

        return list_photos
Exemple #9
0
def execute_search(key, string, pages, format, progress_function):

    if (len(search_urls) > 0):
        search_urls.clear()

    pexels_instance = PyPexels(api_key=key)
    search_results = pexels_instance.search(query=string, per_page=pages)

    progress_function(0)

    while True:
        for image in search_results.entries:
            search_urls.append(image.src.get(format))
            print(image.src.get(format))
        if not search_results.has_next:
            break
        search_results = search_results.get_next_page()

    progress_function('finished')
Exemple #10
0
def searchPhotos(searchTerm="",
                 amountPerPage=10,
                 AmountOfPages=5,
                 AmountOfPagesToSkip=5):

    theurls = []

    py_pexel = PyPexels(api_key=api_key)

    search_results = py_pexel.search(query=searchTerm, per_page=amountPerPage)

    cc = 0
    c2 = 0
    c3 = 0

    tradeLog("Searching for: ", searchTerm)

    while search_results.has_next and c2 < AmountOfPages:

        if c3 > AmountOfPagesToSkip:

            for photo in search_results.entries:

                if photo.photographer != "Pixabay":

                    theurls.append(
                        [photo.src.get("original"), photo.photographer])

                    cc = cc + 1

            c2 = c2 + 1

        search_results.get_next_page()

        c3 = c3 + 1

    return theurls
Exemple #11
0
 def __init__(self, vname=''):
     self.py_pexel = PyPexels(api_key=api_key)
     self.latestIDs = []
     self.vname = vname
Exemple #12
0
import json
import time
from pathlib import Path
import os
import requests
from pypexels import PyPexels

from azure.storage.blob import BlobClient

api_key = '563492ad6f91700001000001aeb006d415ed4a22bda755bf22efc602'

# instantiate PyPexels object
py_pexels = PyPexels(api_key=api_key)


def download_image(url, root_dir, filename):
    headers = {
        "user-agent":
        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.106 Safari/537.36"
    }
    response = requests.get(url, stream=True, headers=headers)
    filename = f"{filename}.jpg"
    filepath = Path(root_dir) / filename

    with open(filepath, 'wb') as file:
        for chunk in response.iter_content(10000):
            file.write(chunk)


search_results = py_pexels.search(query='funny dogs', per_page=10)
Exemple #13
0
# -*- coding: utf-8 -*-
"""
Created on Sat Aug 24 20:07:32 2019

@author: Jacky
"""

from pypexels import PyPexels
api_key = ''  #Insert API key here

# instantiate PyPexels object
py_pexels = PyPexels(api_key=api_key)

search_results = py_pexels.search(query='dog', per_page=40)
while True:
    for photo in search_results.entries:
        print(photo.id, photo.photographer, photo.url)
    if not search_results.has_next:
        break
    search_results = search_results.get_next_page()
    def pullvideos(wordlist):
        api_key = '@@@@@@@@@@'
        py_pexel = PyPexels(api_key=api_key)
        novid = False
        video_links = []
        length = len(wordlist)

        def search_vids(word, flag, topicused, multiplevids):
            # search for vids
            print(word)
            if multiplevids == True:
                search_videos_page = py_pexel.videos_search(query=word,
                                                            per_page=5,
                                                            min_duration=6,
                                                            max_duration=30)
                links = []
                for video in search_videos_page.entries:
                    for x in video.video_files:
                        link = str(x.get("link"))
                        links.append(link)
                    for link in links:
                        if not link in video_links:
                            video_links.append(link)
                            multiplevids = False
                            return video_links
            else:
                search_videos_page = py_pexel.videos_search(query=word,
                                                            per_page=1,
                                                            min_duration=6,
                                                            max_duration=30)

                for video in search_videos_page.entries:
                    for x in video.video_files:
                        # get link of video from json output >> dictionary
                        link = str(x.get("link"))
                        if not link in video_links:
                            video_links.append(link)
                            return video_links
                        else:
                            if flag == 1 and topicused == True:

                                topic = wordlist[length - 3]
                                multiplevids = True
                                search_vids(topic, flag, topicused,
                                            multiplevids)
                            else:
                                topic = wordlist[length - 3]
                                flag = 1
                                topicused = True
                                search_vids(topic, flag, topicused,
                                            multiplevids)

            return video_links

        # loop through word list and search for vids
        multiplevids = False
        flag = 0
        topicused = False
        for word in wordlist:
            video_links = search_vids(word, flag, topicused, multiplevids)
        video_links = list(set(video_links))
        return video_links
Exemple #15
0
#   Comment: What's new in revision 1
#
###############################################################################
import logging
import os
from pypexels import PyPexels
api_key = os.environ.get('API_KEY', None) or 'DUMMY_API_KEY'

# Initialize app logging
logger = logging.getLogger()
logging.basicConfig(filename='app_random.log', level=logging.DEBUG)

# pypexels logger defaults to level logging.ERROR
# If you need to change that, use getLogger/setLevel
# on the module logger, like this:
logging.getLogger(PyPexels.logger_name).setLevel(logging.DEBUG)

# add a headers to the log
logger.debug(80*'=')
logging.debug('Testing PyPexels.random()')
logger.debug(80*'=')

# instantiate PyPexels object
py_pexel = PyPexels(api_key=api_key)


random_photos_page = py_pexel.random(per_page=7)
for photo in random_photos_page.entries:
    print(photo.id, photo.photographer, photo.url)

Exemple #16
0
 def __init__(self, pypexels_api_key=None):
     self.pypexels = PyPexels(api_key=pypexels_api_key)
Exemple #17
0
# Initialize app logging
logger = logging.getLogger()
logging.basicConfig(filename='app_popular.log', level=logging.DEBUG)

# pypexels logger defaults to level logging.ERROR
# If you need to change that, use getLogger/setLevel
# on the module logger, like this:
logging.getLogger(PyPexels.logger_name).setLevel(logging.DEBUG)

# add a headers to the log
logger.debug(80*'=')
logging.debug('Testing PyPexels.popular()')
logger.debug(80*'=')

# instantiate PyPexels object
py_pexel = PyPexels(api_key=api_key)

# Start with the generic collection, maximize number of items per page
# Note: this will run until all popular photos have been visited,
#       unless a connection error occurs.
#       Typically the API hourly limit gets hit during this
#
popular_photos_page = py_pexel.popular(per_page=40)
while True:
    for photo in popular_photos_page.entries:
        print((photo.id, photo.photographer, photo.url))
    if not popular_photos_page.has_next:
        break
    popular_photos_page = popular_photos_page.get_next_page()
Exemple #18
0
#
###############################################################################
import logging
import os
from pypexels import PyPexels
api_key = os.environ.get('API_KEY', None) or 'DUMMY_API_KEY'


# Initialize app logging
logger = logging.getLogger()
logging.basicConfig(filename='app_single_video.log', level=logging.DEBUG)

# pypexels logger defaults to level logging.ERROR
# If you need to change that, use getLogger/setLevel
# on the module logger, like this:
logging.getLogger(PyPexels.logger_name).setLevel(logging.DEBUG)

# add a headers to the log
logger.debug(80*'=')
logging.debug('Testing PyPexels.single_video()')
logger.debug(80*'=')

# instantiate PyPexels object
py_pexel = PyPexels(api_key=api_key)

# Retrieve a single video, known by its ID
video = py_pexel.single_video(video_id=1448735)
print(video.id, video.user.get('name'), video.url)
print(video.get_attribution('txt'))
print(video.get_attribution('html'))
Exemple #19
0
# Initialize app logging
logger = logging.getLogger()
logging.basicConfig(filename='app_search.log', level=logging.DEBUG)

# pypexels logger defaults to level logging.ERROR
# If you need to change that, use getLogger/setLevel
# on the module logger, like this:
logging.getLogger(PyPexels.logger_name).setLevel(logging.DEBUG)

# add a headers to the log
logger.debug(80 * '=')
logging.debug('Testing PyPexels.search()')
logger.debug(80 * '=')

# instantiate PyPexels object
py_pexel = PyPexels(api_key=api_key)

# Start with a search query, maximize number of items per page
# Note: this will run until all results pages have been visited,
#       unless a connection error occurs.
#       Typically the API hourly limit gets hit during this
#
search_results_page = py_pexel.search(query='red flowers', per_page=40)
while True:
    for photo in search_results_page.entries:
        print((photo.id, photo.photographer, photo.url))
    if not search_results_page.has_next:
        break
    search_results_page = search_results_page.get_next_page()
Exemple #20
0
class PexelPusher:
    def __init__(self, vname=''):
        self.py_pexel = PyPexels(api_key=api_key)
        self.latestIDs = []
        self.vname = vname

    def searchVideos(self, query='', qSize=10):
        selected_videos = []
        search_videos_page = self.py_pexel.videos_search(query=query, per_page=qSize)
        while True:
            for video in search_videos_page.entries:
                self.latestIDs.append(video.id)
                if video.width/video.height >= 1.33:
                    image = video.image.split('?')
                    selected_videos.append(image[0])
            if not search_videos_page.has_next:
                break
            search_videos_page = search_videos_page.get_next_page()
        return selected_videos

    def getThumbs(self, querylist,qSize):
        nlist = 0
        root = '.\\cacheimages\\'
        if self.vname == '':
            print('Please name your video first, champion.')
            return
        for query in querylist:
            video_list = self.searchVideos(query, qSize)
            nlist = '{:04d}'.format(querylist.index(query)+1)
            cache_folder = ('.\\cacheimages\\')
            if not os.path.exists(cache_folder):
                os.mkdir(cache_folder)
            random.shuffle(video_list)
            for imageurl in video_list:
                r = requests.get(imageurl)
                filename = cache_folder+os.path.split(imageurl)[1]
                with open(filename, 'wb') as outfile:
                    outfile.write(r.content)
                    outfile.close()
                image = Image.open(filename)
                image.thumbnail((400,400))
                image.save(filename)
        self.makeContactSheet()

    def makeContactSheet(self):
        root = '.\\cacheimages\\'
        vname = self.vname
        images = []
        for root, dirs, files in os.walk(root):
            #print(root)
            targetPath = os.listdir(os.path.join(root))
            random.shuffle(targetPath)
            for file in targetPath:
                    images.append(os.path.join(root,file))
        outfile = os.path.join('.\\media\\cs_{0}.jpg'.format(vname))
        montaner.generate_montage(images, outfile)
        self.saveVideoIDs()
        img = Image.open(outfile)
        img.show()
        shutil.rmtree(root)

    def saveVideoIDs(self):
        file = '.\\modules\\config\\{0}_IDs.json'.format(self.vname)
        if os.path.exists(file):
            os.remove(file)
            tobiasj.saveThis(self.latestIDs, file)
        else:
            tobiasj.saveThis(self.latestIDs, file)

    def downloadVideos(self):
        file = '.\\modules\\config\\{0}_IDs.json'.format(self.vname)
        ids = tobiasj.loadThis(file)
        namelist = []
        root = '.\\media\\videos\\{0}\\'.format(self.vname)
        if not os.path.exists(root):
            os.mkdir(root)
        for videoid in ids:
            video = self.py_pexel.single_video(video_id=videoid)
            for each in video.video_files:
                if 'hd' in each['quality']:
                    link = each['link']
                    name = 'ID{0}_{1}'.format(videoid,video.user.get('name'))
                    if name not in namelist:
                        namelist.append(name)
                    filename = root+'{0}.mp4'.format(videoid)
                    if not os.path.isfile(filename):
                        print('Downloading this video: {0}'.format(filename))
                        r = requests.get(link)
                        with open(filename, 'wb') as outfile:
                            outfile.write(r.content)
                            outfile.close()
                    else:
                        print('Skipping this video because it already exists: {0}'.format(filename))
        tobiasj.saveThis(namelist,'.\\modules\\config\\{0}.credits.json'.format(self.vname))
Exemple #21
0
def do_stuff(infinite=True):

    db = DB(host=DB_HOST,
            port=DB_PORT,
            user=DB_USER,
            passwd=DB_PASS,
            name=DB_NAME)

    rmq = Rmq(host=RMQ_HOST, port=RMQ_PORT, user=RMQ_USER, passw=RMQ_PASS)

    pexel = PyPexels(api_key=API)

    log.info('started')

    banned = False
    while True:
        try:
            log.info('Attempting to get photos!')
            entries = set(pexel.random(per_page=PER_PAGE).entries)
            banned = False

        except PexelsError:
            word = "Still" if banned else "Got"
            log.warning(f'{word} banned on pexels, waiting 5 min.')
            banned = True
            for _ in range(6):
                rmq.connection.process_data_events()
                sleep(50)
            continue

        rejected_pics = db.seen_pictures

        for photo in entries:
            source = photo.src["original"]
            if source in rejected_pics:
                log.info(f'Already seen this({source}) picture!')
                continue

            db.add_seen_pic(source)

            pic = PictureValid(service="Pexels",
                               download_url=photo.src["original"],
                               preview_url=photo.src["large"],
                               source_url=photo.url,
                               height=int(photo.height),
                               width=int(photo.width))

            if photo.height > photo.width:
                log.info(
                    'not adding this pic because height > weight, for now')
                log.debug(f' height = {photo.height}\nwidth={photo.width}')
                continue

            log.info(f'Adding {pic}!')

            rmq.channel.basic_publish(exchange='',
                                      routing_key='check_out',
                                      body=pic.json(),
                                      properties=rmq.durable)

        if not infinite:
            return

        int_range = range(0, INTERVAL, 20)
        for _ in int_range:
            how_many = len(list(int_range))
            rmq.connection.process_data_events()
            sleep(INTERVAL / how_many)
Exemple #22
0
#
###############################################################################
import logging
import os
from pypexels import PyPexels

api_key = os.environ.get('API_KEY', None) or 'DUMMY_API_KEY'

# Initialize app logging
logger = logging.getLogger()
logging.basicConfig(filename='app_single_photo.log', level=logging.DEBUG)

# pypexels logger defaults to level logging.ERROR
# If you need to change that, use getLogger/setLevel
# on the module logger, like this:
logging.getLogger(PyPexels.logger_name).setLevel(logging.DEBUG)

# add a headers to the log
logger.debug(80 * '=')
logging.debug('Testing PyPexels.single_photo()')
logger.debug(80 * '=')

# instantiate PyPexels object
py_pexel = PyPexels(api_key=api_key)

# Retrieve a single photo, known by its ID
photo = py_pexel.single_photo(photo_id=415071)
print(photo.id, photo.photographer, photo.url)
print(photo.get_attribution('txt'))
print(photo.get_attribution('html'))
# Initialize app logging
logger = logging.getLogger()
logging.basicConfig(filename='app_video_search.log', level=logging.DEBUG)

# pypexels logger defaults to level logging.ERROR
# If you need to change that, use getLogger/setLevel
# on the module logger, like this:
logging.getLogger(PyPexels.logger_name).setLevel(logging.DEBUG)

# add a headers to the log
logger.debug(80 * '=')
logging.debug('Testing PyPexels.videos_search()')
logger.debug(80 * '=')

# instantiate PyPexels object
py_pexel = PyPexels(api_key=api_key)

# Start with the generic collection, maximize number of items per page
# Note: this will run until all popular photos have been visited,
#       unless a connection error occurs.
#       Typically the API hourly limit gets hit during this
#
#  Note2: the video API is not currently (May 2020) producing next_page/prev_page links
#         so this example will not be able to keep walking forward
#
search_videos_page = py_pexel.videos_search(query="red+flower", per_page=40)
while True:
    for video in search_videos_page.entries:
        print(video.id, video.user.get('name'), video.url)
    if not search_videos_page.has_next:
        break
    
    # Need to complete download, and try next time again manually
    print('....')
    print('Completed download')
    #time.sleep(30)
    print('....')
    
    return total_downloaded

# api_key from Cao Liang
#api_key = '563492ad6f917000010000018cd4391b02e24cb683cd90ac888d7189'
# api_key from Jacky
api_key = '563492ad6f917000010000015dee3b636ab44279b6f1edf055de1fe0'

# instantiate PyPexels object
py_pexels = PyPexels(api_key=api_key)

#search_target = 'domestic cat'
search_target = 'bird'
# Each time only allow maximum 200 images to be downloaded
total_images = 200

# Existing downloaded image files
exiting_num_images = 1200

print("{0} - Try to download {1} images for '{2}'".format(
        show_time(), total_images, search_target))
print("---------")

num_images = complete_download_task(py_pexels, search_target, total_images, 
                       ignore_num_images = exiting_num_images)
Exemple #25
0
"""pexels api.ipynb

Automatically generated by Colaboratory.

Original file is located at
    https://colab.research.google.com/drive/1vA-xqWtQfoFyj-5j7ikFK-bNmJDE28hI
"""

!pip install -q pexels_api
!pip install -q PyPexels

from pypexels import PyPexels
# add your api key
api_key = ''

# instantiate PyPexels object
py_pexel = PyPexels(api_key=api_key)

# create a list for the results
empty = []


search_results = py_pexel.search(query='bears', per_page=6)
while True:
    for photo in search_results.entries:
        print(photo.id, photo.photographer, photo.url)
        empty.append(photo.url)
        print(empty)
    if not search_results.has_next:
        break
    search_results = search_results.get_next_page()
Exemple #26
0
from __future__ import division
from pypexels import PyPexels
import json

api_key = '563492ad6f9170000100000121984210cc7b4f57a4fdb0d06251dec5'

# instantiate PyPexels object
py_pexels = PyPexels(api_key=api_key)

result_photos = []
nature_photos = py_pexels.search(query='nature', per_page=40, page=200)
count = 0

fh = open('photos.json', 'w')
while nature_photos.has_next:
    try:
        print 'page number:', nature_photos.page
        for photo in nature_photos.entries:
            #print photo.src.get('medium')
            height = photo.height
            width = photo.width
            #print 'size demision', width/height
            if (width / height > 1.4) and (width / height < 1.6):
                mediumPhoto = photo.src.get('medium')
                #print mediumPhoto
                result_photos.append(mediumPhoto)
                fh.write(mediumPhoto)
                fh.write('\n')
                count = count + 1
            else:
                #print 'size does not match to 1.5'
from pypexels import PyPexels
from os import chdir
import urllib.request as req
import requests

chdir("imgs")

api_key = '563492ad6f9170000100000133e1d38b49754e5ebcf024313a5fdbc2'

# instantiate PyPexels object
py_pexels = PyPexels(api_key=api_key)

for i in range(100):
    popular_photos = py_pexels.random(per_page=10)
    for photo in popular_photos.entries:
        print(photo.id, photo.photographer, photo.url)
        img_data = requests.get(photo.src['medium']).content
        with open('{0}.jpeg'.format(photo.id), 'wb') as handler:
            handler.write(img_data)
        break
    break
# Initialize app logging
logger = logging.getLogger()
logging.basicConfig(filename='app_video_popular.log', level=logging.DEBUG)

# pypexels logger defaults to level logging.ERROR
# If you need to change that, use getLogger/setLevel
# on the module logger, like this:
logging.getLogger(PyPexels.logger_name).setLevel(logging.DEBUG)

# add a headers to the log
logger.debug(80 * '=')
logging.debug('Testing PyPexels.videos_popular()')
logger.debug(80 * '=')

# instantiate PyPexels object
py_pexel = PyPexels(api_key=api_key)

# Start with the generic collection, maximize number of items per page
# Note: this will run until all popular videos have been visited,
#       unless a connection error occurs.
#       Typically the API hourly limit gets hit during this
#
#  Note2: the video API is not currently (May 2020) producing next_page/prev_page links
#         so this example will not be able to keep walking forward
#
popular_videos_page = py_pexel.videos_popular(per_page=40)
while True:
    for video in popular_videos_page.entries:
        print(video.id, video.user.get('name'), video.url)
    if not popular_videos_page.has_next:
        break
Exemple #29
0
from pypexels import PyPexels
import requests
from PIL import Image
import os
from multiprocessing import Pool

API_KEY = '563492ad6f917000010000014db666f070d64bec826d5746cf55d29d'
# OUTPUT_DIR = 'E:\\user\\Pictures\\!Wallpapers\\stock'
OUTPUT_DIR = os.path.abspath(__file__)

px = PyPexels(api_key=API_KEY)


def get_image(img_url):
    # open
    img = Image.open(requests.get(img_url, stream=True).raw)

    # determine filename
    filename = img_url.split('/')[-1]
    os.path.join(OUTPUT_DIR, filename)

    # save the image
    img.save(filename)
    # print success message
    print(f"{filename} saved.")


if __name__ == '__main__':

    popular_photos = px.curated(per_page=30)