def getTags(file):
    # assumes environment variables are set.
    clarifai_api = ClarifaiApi()
    result = clarifai_api.tag_images(file)
    #parsing Json
    res = []
    return result['results'][0]['result']['tag']['classes']
예제 #2
0
def get_tags():
	#TODO: Error checking
	global d 
	d = {}
	clarifai_api = ClarifaiApi()
	blob_service = BlobService('calhacks', 'mm7EmY+T+MGahePBDSDU5LHpZR5tRXuh4MSco4jFrzHovOPEf06e18c89pxtPIo4NDVhhjSeaQY/FQmKNxjjyA==')	

	blob_name = request.data
	blob_name = blob_name.decode('utf-8')
	blob_service.get_blob_to_path('imagestore', blob_name, 'out.png')	
	print("checkpoint 1")
	i = open ('out.png', 'r')
	strd = ""
	for line in i:
		strd += line.strip()
	fname = 'img.png'
	with open (fname, 'wb') as f:
		f.write (base64.b64decode(strd))
		f.close()

	f = open (fname, 'rb')
	result = clarifai_api.tag_images(f)
	print(result)
	st = result['results'][0]['result']['tag']['classes'][0:6]

	for i in ['food', 'nobody', 'still life', 'meal', 'dish', 'plate', 'delicious', 'isolated', 'cutout', 'unhealthy', 'one', 'background']: 
		while i in st:
			st.remove(i)
	d = {blob_name: search_terms(st)}
	return "success!"
예제 #3
0
    def process_data(self, url):
        url = url.decode('utf-8')
        annotations_filename = self.get_model_filename(url)
        model_filename = get_cache_filename(url)
        pdf_filename = model_filename + '.data'
        images_dir = pdf_filename + '-images/'

        clarifai_api = ClarifaiApi()

        annotations = self.get_new_model()

        for file in os.listdir(images_dir):
            if file.endswith(".png"):
                response = clarifai_api.tag_images(open(images_dir + file, 'rb'))
                result = response['results'][0]['result']['tag']
                for tag, prob in zip(result['classes'], result['probs']):
                    print('Tag: ' + tag + ' Prob: ' + str(prob))
                    annotation = create_annotation(
                                                (namespaces.oa.confidence, Literal(prob, datatype=XSD.decimal)),
                                                target=URIRef(url) + '#image' + file,
                                                body=Literal(tag, datatype=XSD.string),
                                                annotator=Literal('Clarif.ai', datatype=XSD.string))

                annotations += annotation
        self.write_and_merge_model(annotations, annotations_filename)
예제 #4
0
  def test_unicode_urls(self):
    image_url = u'http://www.alvaronoboa.com/wp-content/uploads/2013/02/Álvaro-Noboa-y-Annabella-Azín-Votaciones-41-1024x682.jpg'

    api = ClarifaiApi()
    response = api.tag_image_urls(image_url)
    self.assertTrue(response)
    self.assertTrue(response['results'][0]['url'] == image_url)
예제 #5
0
 def test_embed_one_image_from_localfs(self):
     image_file = 'tests/data/toddler-flowers.jpeg'
     api = ClarifaiApi()
     if os.path.exists(image_file):
         with open(image_file, 'rb') as fb:
             response = api.embed_images(fb)
             self.assertTrue(response)
예제 #6
0
def getTags(file):
    # assumes environment variables are set.
    clarifai_api = ClarifaiApi() 
    result = clarifai_api.tag_images(file)
    #parsing Json
    res = []
    return result['results'][0]['result']['tag']['classes']
예제 #7
0
def main(argv):
  if len(argv) > 1:
    imageurl = argv[1]
  else:
    imageurl = 'http://clarifai-img.s3.amazonaws.com/test/toddler-flowers.jpeg'
    print("We will be using the default since you provided no local directories")

  api = ClarifaiApi()

  if imageurl.startswith('http'):
    response = api.tag_image_urls(imageurl)

  elif os.path.isdir(imageurl):
    tags_list = tag_images_in_directory(imageurl, api)


    # this is a list of lists
    # you get simply something like ['hot', 'girl', 'model', 'young', 'brunette']
    # so take that, join it as one string with _ between each word 
    # and rename each file accordingly. 

    response = rename_images_in_directory_with_tags(format_tags_with_filenames(tags_list, images), imageurl)


  elif os.path.isfile(imageurl):
    with open(imageurl,'rb') as image_file:
      response = api.tag_images(image_file)

  else:
    raise Exception("Must input url, directory path, or file path")
예제 #8
0
    def test_unicode_urls(self):
        image_url = u"http://www.alvaronoboa.com/wp-content/uploads/2013/02/Álvaro-Noboa-y-Annabella-Azín-Votaciones-41-1024x682.jpg"

        api = ClarifaiApi()
        response = api.tag_image_urls(image_url)
        self.assertTrue(response)
        self.assertTrue(response["results"][0]["url"] == image_url)
예제 #9
0
def find_type(image_name):
    clarifai_api = ClarifaiApi('ph4Sk2DtEk0Et_9aRUxdzxLPzMpMjv75WlFPnT5H',
                               'kg_cH9uYZHYikRSrjv7izSRA1fgxCORKryLe8Mn6')  # assumes environment variables are set.

    road_classes = ['vehicle', 'road', 'car', 'transportation system', 'truck', 'street', 'ambulance', 'storm']
    common_classes = ['calamity', 'battle', 'accident', 'offense', 'police']
    fire_classes = ['flame', 'smoke', 'burnt', 'light', 'energy', 'fire_truck', 'heat', 'explosion']

    clf = clarifai_api.tag_images(open(image_name, 'rb'))
    img_classes = clf['results'][0]['result']['tag']['classes']
    if len(img_classes) == 0:
        return 'Failed'
    common_score = 0
    road_score = 0
    fire_score = 0
    for cl in img_classes:
        if cl in common_classes:
            common_score += 1
        if cl in road_classes:
            road_score += 1
        if cl in fire_classes:
            fire_score += 1
    res = {'fire': fire_score, 'road': road_score, 'fine': common_score}
    print res
    if (res['road'] >= 3 and res['road'] > res['fire']):
        return 'road'
    if (res['fire'] > 1):
        print res['fire']
        return 'fire'
    if (res['fine'] <= 1):
        return 'fine'
    else:
        return 'police'

#print find_type('1.jpg')
예제 #10
0
def getImage():
	image = request.args.get('urlname')
	if image:
		clarifai_api = ClarifaiApi(CLARIFAI_APP_ID, CLARIFAI_APP_SECRET)
		try:
			response = clarifai_api.tag_image_urls('%s' %(str(image)))
			tags = response['results'][0]['result']['tag']['classes']
			for tag in tags:
				joke = searchForJoke(jokes, tag)
				if joke != "No joke with keyword found!":
					break
			try:
				page = wikipedia.page(tags[0])
			except wikipedia.exceptions.DisambiguationError as e:
				page = e.options[0]		
			return jsonify(result=str(tags).strip("[").strip("]"), 
						   joke="Possibly inappro Chuck Norris Joke: " + joke, 
						   wiki="Fun fact: " + page.summary + "...",
						   readMore="Read more here: " + page.url)
		except:
			return jsonify(result="API keys failed!",
				           joke="No image!",
				           wiki="No image!",
				           readMore="No image!")
	return jsonify(result="No input or failed to locate image!",
		           joke="No image!",
		           wiki="No image!",
		           readMore="No image!")
예제 #11
0
def getTags(item):
	clarifai_api = ClarifaiApi() # assumes environment variables are set.
	result = clarifai_api.tag_image_urls(item.imgURL)

	result = result["results"][0]["result"]["tag"]["classes"]
	for i in result:
		Tag(tagText=i, item=item).save()
예제 #12
0
파일: images.py 프로젝트: jayrav13/cat-tax
def send_image():
	image = Images.query.filter_by(is_sent=0).first()

	if image == None:
		parameters = {
			"format" : "xml",
			"results_per_page" : "100"
		}
		result = requests.get('http://thecatapi.com/api/images/get', params=parameters)
		tree = html.document_fromstring(result.text)

		clarifai_api = ClarifaiApi()

		for val in tree.xpath('//images'):
			for elem in val:
				try:
					result = clarifai_api.tag_image_urls(elem.xpath('url')[0].text)
					total_results = result['results'][0]['result']['tag']['classes']
					if 'cat' in total_results or 'kitten' in total_results:
						db.session.add(Images(elem.xpath('url')[0].text, elem.xpath('id')[0].text, elem.xpath('source_url')[0].text, 0))
						db.session.commit()
				except:
					pass

		image = Images.query.filter_by(is_sent=0).first()

	users = Users.query.filter_by(active=1).all()

	for elem in users:
		client = TwilioRestClient(os.environ.get('TWILIO_ACCOUNT_SID'), os.environ.get('TWILIO_AUTH_TOKEN'))
		message = client.messages.create(to=elem.number, from_="+19733214779", media_url=[image.url])

	image.is_sent = 1
	db.session.commit()
예제 #13
0
파일: main.py 프로젝트: nikonikolov/uknao
def  doStuff() :

	# get the image
	tts.say("Downloading image")
	myURL = mem.getData("LanguageLearner/ImageURL")
	urllib.urlretrieve(myURL, "C:/Users/Max/Documents/My Stuff/UK-NAO-hackathon/PepperPic.jpg")

	# image processing
	tts.say("Hmmmm let me see")
	clarifai_api = ClarifaiApi(language="fr") # assumes environment variables are set.
	result = clarifai_api.tag_images(open( "C:/Users/Max/Documents/My Stuff/UK-NAO-hackathon/PepperPic.jpg", 'rb'))
	resultList = result['results'][0]['result']['tag']['classes']
	print resultList

	# Return the result to Pepper
	#print str(resultList[0])
	#tts.say("I think this is a " + str(resultList[0]))
	print "sending word to Pepper:"
	
	try:
		mem.insertData("LanguageLearner/Object",str(resultList[0]))
		print resultList[0]
	except:
		mem.insertData("LanguageLearner/Object",str(resultList[1]))
		print resultList[1]
예제 #14
0
def clarifai():
    if request_format_okay(request):
        s3_base_url = 'https://make-or-break.s3.amazonaws.com/'
        data = request.get_json()
        request_obj = Request.query.get(data["request_id"])
        image_url = str(data["image_encoded"] + "")
        file_type = data["file_type"] if data["file_type"] else ".png"

        fileName = id_generator() + "." + file_type
        fh = open(fileName, "wb")
        fh.write(base64.b64decode(image_url))
        fh.close()

        aws_key = os.environ.get('AWS_KEY')
        aws_secret = os.environ.get('AWS_SECRET')
        conn = tinys3.Connection(aws_key, aws_secret, tls=True)
        f = open(fileName, 'rb')
        conn.upload(fileName, f, 'make-or-break')
        f.close()

        s3_url = s3_base_url + fileName

        request_obj.image_url = s3_url
        db.session.commit()

        os.remove(fileName)

        clarifai_api = ClarifaiApi() # assumes environment variables are set
        result = clarifai_api.tag_image_urls(s3_url)
        return jsonify(result)
    else:
        return abort(415)
예제 #15
0
def get_tags():
	#TODO: Error checking
#       global d 
#       d = {}

	clarifai_api = ClarifaiApi()
	blob_service = BlobService('calhacks', 'mm7EmY+T+MGahePBDSDU5LHpZR5tRXuh4MSco4jFrzHovOPEf06e18c89pxtPIo4NDVhhjSeaQY/FQmKNxjjyA==')      

	blob_name = request.form['blob_id']
#       blob_name = blob_name.decode('utf-8')
	blob_service.get_blob_to_path('imagestore', blob_name, 'out.png')       
	print("checkpoint 1")
	i = open ('out.png', 'r')
	strd = ""
	for line in i:
		strd += line.strip()
	fname = 'img.png'
	with open (fname, 'wb') as f:
		f.write (base64.b64decode(strd))
		f.close()

	f = open (fname, 'rb')
	result = clarifai_api.tag_images(f)
	st = result['results'][0]['result']['tag']['classes'][0:6]
	print(st)

	for i in []:#['food', 'nobody', 'still life', 'meal', 'dish', 'plate', 'delicious', 'isolated', 'cutout', 'unhealthy', 'one', 'background']: 
		while i in st:
			st.remove(i)
	js = json.dumps(search_terms(st))
	print(js)
	return js
예제 #16
0
def tags():
    url = request.args["url"] 
    clarifai_api = ClarifaiApi()  # assumes environment variables are set.
    result = clarifai_api.tag_image_urls(url)
    results = result['results'][0]["result"]["tag"]["classes"]#[:3]

    client = foursquare.Foursquare(client_id='JEK02X44TGMNJSE0VC1UBEB4FRNNW3UMFQ4IQOPI4BAR2GXA', \
                                    client_secret='A2Z50VTUHHXEUYJBHCQKB1LXTNVVBYBQR4SDASVTXTWUMWXS') #foursquare shit

    address = request.args["address"] #address is currently a string
    geolocator = Nominatim()
    location = geolocator.geocode(address)
    newLocation = str(location.latitude) + str(", ") + str(location.longitude)
    
    
    # foursquare_dictionary = client.venues.explore(params={'ll': '40.7, -74', 'v': '20160402', 'query': results[0] + ',' + results[1] + ',' + results[2]})

    foursquare_dictionary = client.venues.explore(params={'ll': newLocation, 'v': '20160402', 'query': results[0] + ',' + results[1] + ',' + results[2]})

    #first place to eat
    # status1 = foursquare_dictionary['groups'][0]['items'][0]['venue']['hours']['status']
    address1 = foursquare_dictionary['groups'][0]['items'][0]['venue']['location']['formattedAddress']
    name = foursquare_dictionary['groups'][0]['items'][0]['venue']['name']

    #second place to eat
    address2 = foursquare_dictionary['groups'][0]['items'][1]['venue']['location']['formattedAddress']
   # status2 = foursquare_dictionary['groups'][0]['items'][1]['venue']['hours']['status']
    name1 = foursquare_dictionary['groups'][0]['items'][1]['venue']['name']

    return render_template('tags.html',\
                           newAddress1 = newAddress(address1), name = name,\
                           newAddress2 = newAddress(address2), name1 = name1,\
                           newLocation = newLocation)
예제 #17
0
def main(argv):

  # parse arguments
  parser = argparse.ArgumentParser()
  parser.add_argument("-t", "--tag", help="tag images", action='store_true')
  parser.add_argument("-c", "--color", help="color images", action='store_true')
  parser.add_argument("-u", "--usage", help="usage", action='store_true')

  args, argv = parser.parse_known_args()

  if len(argv) == 1:
    imageurl = argv[0]
  else:
    imageurl = 'http://clarifai-img.s3.amazonaws.com/test/toddler-flowers.jpeg'

  api = ClarifaiApi()

  if args.usage:
    response = api.get_usage()
  elif not args.color:
    response = tag_images(api, imageurl)
  elif args.color and not args.tag:
    response = color_images(api, imageurl)
  else:
    raise Exception('call with --tag or --color for the image')

  print(json.dumps(response))
예제 #18
0
파일: imgur.py 프로젝트: jayrav13/cat-tax
def send_message():
	image = Images.query.filter_by(is_sent=0).first()

	if image == None:
		imgur_client = ImgurClient(os.environ.get('IMGUR_CLIENT_ID'), os.environ.get('IMGUR_CLIENT_SECRET'))
		clarifai_api = ClarifaiApi()

		images = imgur_client.subreddit_gallery(subreddit='aww', page=0)

		for image in images:
			if image.is_album == False and ('jpeg' in image.type):
				try:
					result = clarifai_api.tag_image_urls(image.link)
					total_result = result['results'][0]['result']['tag']['classes']
					if len(set(total_result).intersection(['dog', 'puppy', 'cat', 'kitten', 'bird'])) > 0:
						db.session.add(Images(image.link))
						db.session.commit()
				except:
					pass

		image = Images.query.filter_by(is_sent=0).first()

	users = Users.query.filter_by(active=1).all()

	for user in users:
		try:
			client = TwilioRestClient(os.environ.get('TWILIO_ACCOUNT_SID'), os.environ.get('TWILIO_AUTH_TOKEN'))
			message  = client.messages.create(to=user.number, from_="+19733214779", media_url=[image.link])
		except:
			pass
		
	image.is_sent = 1
	db.session.commit()
예제 #19
0
파일: shorturl.py 프로젝트: mape2k/Bytebot
def greetings(bot, mask, target, data=None, **kw):
    # log.msg("Shortening URL %s" % url)
    if bot.nick == mask.nick:
        return

    url = None
    for match in __URL_REGEX.finditer(data):
        url = match.group(0)
        break

    if not url:
        return
    """Load configuration"""
    config = bot.config.get(__name__, {})

    with aiohttp.Timeout(10):
        with aiohttp.ClientSession(loop=bot.loop) as session:
            headers = {"Content-Type": "application/json"}
            payload = {"url": url, "key": None}
            resp = yield from session.post(__URL_KRZUS,
                                           data=json.dumps(payload),
                                           headers=headers)

            if resp.status != 200:
                raise Exception

            r = yield from resp.read()

    data = json.loads(r.decode('utf-8'))

    short = data.get("url_short")
    if not url:
        return

    desc = None
    if url.endswith(__IMAGE_EXT) and ClarifaiApi is not None:
        api = ClarifaiApi(config['clarifai_app_id'],
                          config['clarifai_app_secret'])
        tags = api.tag_image_urls(url)

        if tags['status_code'] == "OK":
            ret = ', '.join(tags['results'][0]['result']['tag']['classes'])
            desc = "Tags: {}".format(ret)
    elif BeautifulSoup is not None:
        with aiohttp.Timeout(10):
            with aiohttp.ClientSession(loop=bot.loop) as session:
                resp = yield from session.get(url)
                if resp.status == 200:
                    r = yield from resp.read()
                    soup = BeautifulSoup(r, "html.parser")
                    title = soup.title.getText()
                    if len(title) > 60:
                        title = title[:60] + "…"
                    desc = "Title: {}".format(title)

    if desc:
        bot.privmsg(target, desc)
        bot.privmsg(target, "\tURL: {}".format(short))
    else:
        bot.privmsg(target, "URL: {}".format(short))
예제 #20
0
def call_vision_api(image_filename, api_keys):
    clarifai_api = ClarifaiApi(
        app_id=api_keys['clarifai']['client_id'],
        app_secret=api_keys['clarifai']['client_secret'])
    result = clarifai_api.tag_images(open(image_filename, 'rb'))
    text_result = json.dumps(result)
    return text_result
예제 #21
0
def main(argv):

    if len(sys.argv) > 1:
        api = ClarifaiApi()

        path = argv[1]

        ids = index_list(path + "/img")

        l = name_list(path + "/img", ids)

        resp = []
        for elem in l:
            with open(elem['fullname'], 'rb') as image_file:
                print(elem['name'])
                response = api.tag_images(image_file)

                response['id'] = elem['id']
                response['name'] = elem['name']

                print(response)
                resp.append(response)
        save_obj(path, resp, "taglist")

    else:
        print("No path found")
        sys.exit()
예제 #22
0
    def __init__(self,
                 app_id=None,
                 app_secret=None,
                 model=None,
                 select_classes=None):
        ImageExtractor.__init__(self)
        if app_id is None or app_secret is None:
            try:
                app_id = os.environ['CLARIFAI_APP_ID']
                app_secret = os.environ['CLARIFAI_APP_SECRET']
            except KeyError:
                raise ValueError("A valid Clarifai API APP_ID and APP_SECRET "
                                 "must be passed the first time a Clarifai "
                                 "extractor is initialized.")

        self.tagger = ClarifaiApi(app_id=app_id, app_secret=app_secret)
        if model is not None:
            self.tagger.set_model(model)

        self.model = model

        if select_classes is None:
            self.select_classes = None
        else:
            self.select_classes = ','.join(select_classes)
예제 #23
0
def get_words_url(url):
    clarifai_api = ClarifaiApi() # assumes environment variables are set.
    result = clarifai_api.tag_image_urls(url)

    tags=result['results'][0]['result']['tag']['classes']
    probs=result['results'][0]['result']['tag']['probs']
    return { tags[i] : probs[i] for i in range(len(tags)) }
예제 #24
0
def getTags(item):
    clarifai_api = ClarifaiApi()  # assumes environment variables are set.
    result = clarifai_api.tag_image_urls(item.imgURL)

    result = result["results"][0]["result"]["tag"]["classes"]
    for i in result:
        Tag(tagText=i, item=item).save()
예제 #25
0
class ClarifaiAPIExtractor(ImageExtractor):
    ''' Uses the Clarifai API to extract tags of images.
    Args:
        app_id (str): A valid APP_ID for the Clarifai API. Only needs to be
            passed the first time the extractor is initialized.
        app_secret (str): A valid APP_SECRET for the Clarifai API. 
            Only needs to be passed the first time the extractor is initialized.
        model (str): The name of the Clarifai model to use. 
            If None, defaults to the general image tagger. 
        select_classes (list): List of classes (strings) to query from the API.
            For example, ['food', 'animal'].
    '''

    _log_attributes = ('model', 'select_classes')

    def __init__(self,
                 app_id=None,
                 app_secret=None,
                 model=None,
                 select_classes=None):
        ImageExtractor.__init__(self)
        if app_id is None or app_secret is None:
            try:
                app_id = os.environ['CLARIFAI_APP_ID']
                app_secret = os.environ['CLARIFAI_APP_SECRET']
            except KeyError:
                raise ValueError("A valid Clarifai API APP_ID and APP_SECRET "
                                 "must be passed the first time a Clarifai "
                                 "extractor is initialized.")

        self.tagger = ClarifaiApi(app_id=app_id, app_secret=app_secret)
        if not (model is None):
            self.tagger.set_model(model)

        self.model = model

        if select_classes is None:
            self.select_classes = None
        else:
            self.select_classes = ','.join(select_classes)

    def _extract(self, stim):
        if stim.filename is None:
            file = tempfile.mktemp() + '.png'
            imsave(file, stim.data)
        else:
            file = stim.filename

        tags = self.tagger.tag_images(open(file, 'rb'),
                                      select_classes=self.select_classes)

        if stim.filename is None:
            os.remove(file)

        tagged = tags['results'][0]['result']['tag']
        return ExtractorResult([tagged['probs']],
                               stim,
                               self,
                               features=tagged['classes'])
예제 #26
0
def get_tags_and_probs(url):
    clarifai_api = ClarifaiApi()
    result = clarifai_api.tag_image_urls(url)
    tags = result['results'][0]['result']['tag']['classes']
    probs = result['results'][0]['result']['tag']['probs']
    #print tags
    #print probs
    return tags, probs
예제 #27
0
 def test_tag_one_video_from_localfs(self):
     # video source: http://techslides.com/demos/sample-videos/small.mp4
     video_file = "tests/data/small.mp4"
     api = ClarifaiApi()
     if os.path.exists(video_file):
         with open(video_file, "rb") as fb:
             response = api.tag_images(fb)
             self.assertTrue(response)
예제 #28
0
    def test_tag_one_video(self):
        # video source: http://techslides.com/demos/sample-videos/small.mp4
        video_url = "http://techslides.com/demos/sample-videos/small.mp4"

        api = ClarifaiApi()
        response = api.tag_image_urls(video_url)
        self.assertTrue(response)
        self.assertTrue(response["results"][0]["url"] == video_url)
예제 #29
0
  def test_tag_one_video(self):
    # video source: http://techslides.com/demos/sample-videos/small.mp4
    video_url = 'http://techslides.com/demos/sample-videos/small.mp4'

    api = ClarifaiApi()
    response = api.tag_image_urls(video_url)
    self.assertTrue(response)
    self.assertTrue(response['results'][0]['url'] == video_url)
예제 #30
0
def get_tags_and_probs(url):
    clarifai_api = ClarifaiApi()  
    result = clarifai_api.tag_image_urls(url)
    tags = result['results'][0]['result']['tag']['classes']
    probs = result['results'][0]['result']['tag']['probs']
    #print tags
    #print probs
    return tags, probs
예제 #31
0
파일: views.py 프로젝트: adunna/STASiS
def process_file_b64(b64, classes):
    clarifai_api = ClarifaiApi()
    data = {'encoded_data': b64}
    if (classes != ""):
        data = {'encoded_data': b64, 'select_classes': classes}
    json_resp = clarifai_api._base64_encoded_data_op(data, 'tag')
    queue.push(json_resp)
    return json_resp
예제 #32
0
def get_the_fucking_tags(image):
    """Uses clarifai api to get image tags."""
    clarifai_api = ClarifaiApi() # assumes environment variables are set.
    result = clarifai_api.tag_images(open(image))
    data = json.dumps(result)
    jdata = json.loads(data)
    jresults = jdata['results'][0]['result']['tag']['classes'][0]
    return jresults
예제 #33
0
def processClarifai(imgUrl):
	clarifai_api = ClarifaiApi("3RJprl1ls24WbI4X4FAfJe9zOL5TO_ogBU4druEW", "A7i9vHq95Kck9lbgsWZ_s4ZuLkUQBfL_iWE3J5Kt")  # assumes environment variables are set.
	result = clarifai_api.tag_image_urls(imgUrl)
	classes = result['results'][0]['result']['tag']['classes']
	total = []
	for c in classes:
		total.append(c)
	return total
예제 #34
0
 def test_tag_one_video_from_localfs(self):
     # video source: http://techslides.com/demos/sample-videos/small.mp4
     video_file = 'tests/data/small.mp4'
     api = ClarifaiApi()
     if os.path.exists(video_file):
         with open(video_file, 'rb') as fb:
             response = api.tag_images(fb)
             self.assertTrue(response)
예제 #35
0
 def __init__(self):
     client_id, client_secret = DATASOURCES['instagram'][
         'client_id'], DATASOURCES['instagram']['client_secret']
     self.api = InstagramAPI(client_id=client_id,
                             client_secret=client_secret)
     app_id, app_secret = DATASOURCES['clarifai']['app_id'], DATASOURCES[
         'clarifai']['app_secret']
     self.image_api = ClarifaiApi(app_id=app_id, app_secret=app_secret)
예제 #36
0
def getTaggedPics(pictureURLsList):

	taggedPics = []
	clarifai_api = ClarifaiApi()  # assumes environment variables are set.
	for picURL in pictureURLsList:
		result = clarifai_api.tag_image_urls(picURL)
		tagsPic = result['results'][0]['result']['tag']['classes']
		taggedPics.append(tagsPic)
	return taggedPics
예제 #37
0
def getTagsFromImages(images):
    clarifai_api = ClarifaiApi() # assumes environment variables are set.
    ans = []
    y = clarifai_api.tag_image_urls(images)
    ans = {}
    for x in y["results"]:
        for i in range(len(x["result"]["tag"]["classes"])):
            ans[x["result"]["tag"]["classes"][i]] = x["result"]["tag"]["probs"][i]/3
    return ans
예제 #38
0
 def test_embed_one_image(self):
     image_url = 'https://samples.clarifai.com/toddler-flowers.jpeg'
     api = ClarifaiApi()
     try:
         response = api.embed_image_urls(image_url)
         self.assertTrue(response)
         self.assertTrue(response['results'][0]['url'] == image_url)
     except ApiError as e:  # User does not have permission.
         self.check_unauth(e)
예제 #39
0
def process_image(urls):
    tags = dict()
    api = ClarifaiApi("KuQ2EWXhdosMQyktSI1tw6Z3be7c677oA11p1g9o","Kt84XYqK7nVnx3f05_B8pe2biv9bBlGZAHjFvEwF")

    for u in urls:
        response = api.tag_image_urls(u)
        tags[u] = response['results'][0]['result']['tag']['classes']

    return tags
예제 #40
0
def get_keywords_for_image(img_url):
    """ Gets the keyword associated with the image through the Clarifai API """

    clarifai_api = ClarifaiApi("_O7oVw0TVQ2SC7l3Bwkb_UJ95LAzE8amEMQp0VGr",
                               "hAhcV7cMgFmXDq-91Bvbk-V5FEaL1dTfTxtVtRzz"
                               )  # assumes environment variables are set.
    # result = clarifai_api.tag_images(open(img_url, "rb"))
    result = clarifai_api.tag_image_urls(img_url)
    return result['results'][0]['result']['tag']['classes']
예제 #41
0
 def __init__(self, tags, band, album):
     self._tags, self.tags = tags, tags
     self.band = band
     self.album = album
     self.available_fonts = [
         font for font in os.listdir('./fonts')
         if font.lower().endswith('ttf')
     ]
     self.flickr = FlickrAPI(FLICKR_API_KEY, FLICKR_API_SECRET)
     self.clarifai = ClarifaiApi(CLARIFAI_API_KEY, CLARIFAI_API_SECRET)
예제 #42
0
def getTags(gifUrl):
	cleanTags = []	
	clarifai_api = ClarifaiApi()  # assumes environment variables are set.
	result = clarifai_api.tag_image_urls(gifUrl)
	tags = result['results'][0]['result']['tag']['classes']
	#tags = map(str, tags)
	for element in tags:
		cleanTags += eval(element)
		
	return cleanTags
예제 #43
0
  def test_i18n(self):
    api = ClarifaiApi(language='aaa')

    api = self.get_client()
    request_body = api._setup_multi_data([], ['urls'], language='en')
    self.assertEqual(request_body['language'], 'en', 'language field was not set')

    languages = api.get_languages()
    self.assertTrue(len(languages), 'did not return any languages')
    self.assertTrue('en' in languages, 'english code not included in languages')
예제 #44
0
    def test_i18n(self):
        api = ClarifaiApi(language="aaa")

        api = self.get_client()
        request_body = api._setup_multi_data([], ["urls"], language="en")
        self.assertEqual(request_body["language"], "en", "language field was not set")

        languages = api.get_languages()
        self.assertTrue(len(languages), "did not return any languages")
        self.assertTrue("en" in languages, "english code not included in languages")
예제 #45
0
파일: urllib.py 프로젝트: whyneed/Bytebot
def getTags(url):
    ret = ''
    api = ClarifaiApi(BYTEBOT_PLUGIN_CONFIG['shorturl']['clarifai_app_id'],
                      BYTEBOT_PLUGIN_CONFIG['shorturl']['clarifai_app_secret'])
    tags = api.tag_image_urls(url)

    if (tags[u'status_code'] == "OK"):
        ret = ', '.join(tags[u'results'][0][u'result'][u'tag'][u'classes'])

    return ret
예제 #46
0
  def test_i18n(self):
    api = ClarifaiApi(language='aaa')

    api = self.get_client()
    request_body = api._setup_multi_data([], ['urls'], language='en')
    self.assertEqual(request_body['language'], 'en', 'language field was not set')

    languages = api.get_languages()
    self.assertTrue(len(languages), 'did not return any languages')
    self.assertTrue('en' in languages, 'english code not included in languages')
예제 #47
0
def defineFood(fooditem):
	"""Send picture to clarafai, return tags"""
	tags=[]
	clarifai_api = ClarifaiApi(app_id='tbndTvx-Mv_OGD4CKeOhPap1gfAFSSWDUzPT2X6x', app_secret='JQNnSLBftBwJLMkNtIsdhUdU7OQ0a5HZDKLdPTtR') # assumes environment variables are set.
	result = clarifai_api.tag_images(fooditem)
	#parse result
	i=0
	while (i<len(result[u'results'][0][u'result'][u'tag'][u'classes'])):
		tags.append(result[u'results'][0][u'result'][u'tag'][u'classes'][i])
		i=i+1
	return tags
예제 #48
0
def get_words_here(path):
    clarifai_api = ClarifaiApi() # assumes environment variables are set.
    result = clarifai_api.tag_images(open(path))
    #print(result)

    tags=result['results'][0]['result']['tag']['classes']
    probs=result['results'][0]['result']['tag']['probs']
    d={}
    for i in range(len(tags)):
        d[tags[i]]=probs[i]
    return d
예제 #49
0
파일: urllib.py 프로젝트: petrk94/Bytebot
def getTags(url):
    ret = ''
    api = ClarifaiApi(
        BYTEBOT_PLUGIN_CONFIG['shorturl']['clarifai_app_id'],
        BYTEBOT_PLUGIN_CONFIG['shorturl']['clarifai_app_secret']
    )
    tags = api.tag_image_urls(url)

    if(tags[u'status_code'] == "OK"):
        ret = ', '.join(tags[u'results'][0][u'result'][u'tag'][u'classes'])

    return ret
예제 #50
0
    def test_tag_n_embed_one_image(self):
        image_url_base = 'http://clarifai-img.s3.amazonaws.com/test'
        image_files = [
            'metro-north.jpg', 'octopus.jpg', 'tahoe.jpg', 'thai-market.jpg'
        ]
        image_urls = [
            os.path.join(image_url_base, one_file) for one_file in image_files
        ]

        api = ClarifaiApi()
        response = api.tag_and_embed_image_urls(image_urls)
        self.assertTrue(response)
예제 #51
0
def main():
    clarifai_api = ClarifaiApi()

    #ADD ANY MORE IMAGES HERE, PROGRAM SHOULD ADJUST
    image_array = [open('output/rgb_img_' + str(x) + ".jpg", 'rb') for x in xrange(1,13)]
    results_json = clarifai_api.tag_images(image_array)
    results = results_json['results']
    createHashmap(results)

    find_objects()
    text_results_string = str(namesOfObjects)
    say(text_results_string)
예제 #52
0
    def test_tag_n_embed_one_image(self):
        image_url_base = 'https://samples.clarifai.com'
        image_files = ['metro-north.jpg', 'tahoe.jpg', 'thai-market.jpg']
        image_urls = [
            os.path.join(image_url_base, one_file) for one_file in image_files
        ]

        api = ClarifaiApi()
        try:
            response = api.tag_and_embed_image_urls(image_urls)
            self.assertTrue(response)
        except ApiError as e:
            self.check_unauth(e)
예제 #53
0
    def test_no_resizing(self, mock_api):
        """ test with no image resizing """
        image_file = 'tests/data/toddler-flowers.jpeg'
        api = ClarifaiApi(resize=False)

        self.assertFalse(api.resize)

        if os.path.exists(image_file):
            with open(image_file, 'rb') as fb:
                response = api.tag_images(fb)
                self.assertTrue(response)

        self.assertFalse(mock_api._resize_image_tuple.called)
예제 #54
0
    def test_send_feedback(self):
        """ test sending various feedback """

        urls = ['https://samples.clarifai.com/metro-north.jpg', \
                'https://samples.clarifai.com/metro-north.jpg']

        api = ClarifaiApi()

        response = api.feedback(urls=urls[0], add_tags='train')
        self.assertTrue(response)

        response = api.feedback(urls=urls[0], remove_tags='speed,test')
        self.assertTrue(response)

        response = api.feedback(urls=urls[0],
                                add_tags='train',
                                remove_tags='speed,test')
        self.assertTrue(response)

        docids = [hashlib.md5(url.encode('utf-8')).hexdigest() for url in urls]

        response = api.feedback(urls=urls[:2], similar_docids=docids[:2])
        self.assertTrue(response)

        response = api.feedback(urls=urls[1:], dissimilar_docids=docids[1:])
        self.assertTrue(response)

        response = api.feedback(urls=urls,
                                similar_docids=docids[:2],
                                dissimilar_docids=docids[1:])
        self.assertTrue(response)
예제 #55
0
파일: lib.py 프로젝트: sitefeng/dojo
def get_clarifai(filename):
    clarifai_api = ClarifaiApi()  # assumes environment variables are set.
    result = clarifai_api.tag_images(open('uploads/' + filename, 'rb'))

    api_results = {}
    tag_results = result[u'results'][0][u'result'][u'tag'][u'classes']
    probability_results = result[u'results'][0][u'result'][u'tag'][u'probs']
    for index in enumerate(probability_results):
        probability = round(probability_results[index[0]] * 100)
        tag = str(tag_results[index[0]])

        api_results[probability] = tag

    return api_results
예제 #56
0
파일: api.py 프로젝트: qmac/featureX
class ClarifaiAPIExtractor(ImageExtractor):

    ''' Uses the Clarifai API to extract tags of images.
    Args:
        app_id (str): A valid APP_ID for the Clarifai API. Only needs to be
            passed the first time the extractor is initialized.
        app_secret (str): A valid APP_SECRET for the Clarifai API. 
            Only needs to be passed the first time the extractor is initialized.
        model (str): The name of the Clarifai model to use. 
            If None, defaults to the general image tagger. 
        select_classes (list): List of classes (strings) to query from the API.
            For example, ['food', 'animal'].
    '''

    def __init__(self, app_id=None, app_secret=None, model=None, select_classes=None):
        ImageExtractor.__init__(self)
        if app_id is None or app_secret is None:
            try:
                app_id = os.environ['CLARIFAI_APP_ID']
                app_secret = os.environ['CLARIFAI_APP_SECRET']
            except KeyError:
                raise ValueError("A valid Clarifai API APP_ID and APP_SECRET "
                                 "must be passed the first time a Clarifai "
                                 "extractor is initialized.")

        self.tagger = ClarifaiApi(app_id=app_id, app_secret=app_secret)
        if not (model is None):
            self.tagger.set_model(model)
        
        if select_classes is None:
            self.select_classes = None
        else:
            self.select_classes = ','.join(select_classes)

    def _extract(self, stim):
        if stim.filename is None:
            file = tempfile.mktemp() + '.png'
            imsave(file, stim.data)
        else:
            file = stim.filename
        
        tags = self.tagger.tag_images(open(file, 'rb'), 
                                    select_classes=self.select_classes)
        
        if stim.filename is None:
            os.remove(temp_file)

        tagged = tags['results'][0]['result']['tag']
        return ExtractorResult([tagged['probs']], stim, self, 
                                features=tagged['classes'])
예제 #57
0
파일: views.py 프로젝트: jrdbnntt/facetags
def pull_tags_from_clarafai(img_urls):
    friends = []
    clarifai_api = ClarifaiApi()
    clarifai_results = clarifai_api.tag_image_urls(img_urls)

    for image in clarifai_results["results"]:
        friend = {"url": image["url"], "tags": []}

        for i, tag_name in enumerate(image["result"]["tag"]["classes"]):
            if image["result"]["tag"]["probs"][i] >= 0.9:
                friend["tags"].append(tag_name)

        friends.append(friend)

    return friends
예제 #58
0
def check_pretty(imageurl):
    api = ClarifaiApi()
    #api.set_model("")
    if imageurl.startswith('http'):
        response = api.tag_image_urls(imageurl, select_classes="pretty,human")
    elif os.path.isdir(imageurl):
        response = tag_images_in_directory(imageurl)
    elif os.path.isfile(imageurl):
        with open(imageurl,'rb') as image_file:
            response = api.tag(image_file, select_classes="pretty,human,man,woman")
    else:
        raise Exception("Must input url, directory path, or file path")
    
    print json.dumps(response, indent=2)
    return response
예제 #59
0
파일: main.py 프로젝트: claryssa/princeton
def img_handler():
    """
    - Grabs the binary data from the WebRTC still grab attached to POST
    - WebRTC is intuitive--unicode or ASCII byte-encodings not-so-much.
      Manipulates the unicode that Python gets from the POST request form dictionary
      and turns it into the appropriate ASCII byte-encoding, which is then base-64-decoded,
      and then piped into a random UUID-named .png file.
    - As a hack, I used sshfs to mount the public_html directory of my UT Austin CS account address
      into my working dir, and sent the new .png files into that folder, chmodding per upload.
    - This renders the image into a resource that's easily accessible by APIs.
      (Although this obviously won't scale, I only have 2 GB as an undergrad.)
    - Finally, sends the URL via POST to the Microsoft Emotions API
    - tl;dr I changed an image data-uri to a publicly available URL so it'd play better with some
      ML libraries that didn't have native Python clients, but did have RESTful APIs.
    """
    data = request.form.get('stillIn')
    data = data[22:].encode('latin-1')
    binary_data = a2b_base64(data)
    session['uuid'] = str(uuid4())
    fn = session['uuid'] + ".png"
    with open('./models/mount/{}'.format(fn), 'wb') as fd:
        fd.write(binary_data)
    subprocess.call("chmod 755 ./models/mount/{}".format(fn),
                    shell=True)
    resource = "http://cs.utexas.edu/~rainier/{}".format(fn)
    print json.dumps({'url': resource})

    # msft request
    try:
        msft_url = "https://api.projectoxford.ai/emotion/v1.0/recognize"
        headers = {'Ocp-Apim-Subscription-Key': config['MSFT_EMOTION_KEY'],
                   'Content-Type': 'application/json'}
        msft_req = requests.post(url=msft_url, data=json.dumps({'url': resource}), headers=headers)
        print "msft {}".format(msft_req.json())
    except:
        flash('No face was detected!')
        return redirect('/', messages=get_flashed_messages())
    session['msft'] = msft_parse(msft_req.json())

    # indicoio request
    session['indico'] = indicoio.fer(resource)

    # clarifai request
    clarifai_api = ClarifaiApi()
    clarifai_req = clarifai_api.tag_image_urls(resource)
    session['clarifai'] = clarifai_parse(clarifai_req)

    return redirect('/results')
예제 #60
0
class ClarifaiParse:
    def __init__(self, app_id=None, app_secret=None):
        self.api = ClarifaiApi(app_id, app_secret)

    def parse(self, url):
        try:
            api_result = self.api.tag_image_urls(url)

            if api_result["status_code"] == "OK":
                matches = []

                for r in api_result['results']:
                    tag = r["result"]["tag"]
                    number_results = len(tag["classes"])
                    for i in range(number_results):
                        data = {
                            "tag": tag["classes"][i],
                            "probs": tag["probs"][i],
                            "id": tag["concept_ids"][i]
                        }
                        matches.append(data)

                return matches
            else:
                print(api_result["status_code"])
                print(api_result["status_msg"])
                return []
        except IOError:
            print("can't open", filename)
            return []
        except Exception as e:
            print(e)
            return []