class uploader(): def __init__(self): self.client_id = os.environ.get('Client_ID') self.client_secret = os.environ.get('Client_Secret') self.access_token = os.environ.get('access_token') self.refresh_token = os.environ.get('refresh_token') self.album_id = os.environ.get('Album_ID') self.mashape_key = os.environ.get('Mashape_key') # self.client_id = config['imgur_api']['Client_ID'] # self.client_secret = config['imgur_api']['Client_Secret'] # self.access_token = config['imgur_api']['access_token'] # self.refresh_token = config['imgur_api']['refresh_token'] # self.album_id = config['imgur_api']['Album_ID'] # self.mashape_key = config['imgur_api']['Mashape_key'] # self.client = ImgurClient(self.client_id, self.client_secret, self.access_token, self.refresh_token) self.client = ImgurClient(self.client_id, self.client_secret, self.access_token, self.refresh_token, self.mashape_key) self.logger = None def exelogging(self, msg): if self.logger: self.logger.debug(msg) else: print(msg) def upload_photo(self, image_url, album, name): config = { 'album': album, 'name': name, } self.exelogging(config) self.exelogging("Uploading image... ") try: if not self.mashape_key : self.client.upload_from_url(image_url, config=config, anon=False) else: #### imgurpython is no longer support, #### when mashape_key not null, use request directly header = { 'Authorization' : 'Bearer {}'.format(self.access_token), 'X-RapidAPI-Key' : self.mashape_key, } config["type"] = "url" config["image"] = image_url url = "https://imgur-apiv3.p.rapidapi.com/3/image" response = requests.post(url, headers=header, data=config) print("url={},headers={},data={}".format(url, header, config)) print("status_code={}".format(response.status_code)) except Exception as e: self.exelogging(e) return False self.exelogging("Done") return True
def upload_image(imgur_client_id, imgur_client_secret, app_name, image_url=None, image_file_path=None): """Uploads an image to Imgur by the image's url or file_path. Returns the Imgur api response.""" if image_url is None and image_file_path is None: raise ValueError('Either image_url or image_file_path must be ' 'supplied.') client = ImgurClient(imgur_client_id, imgur_client_secret) title = '{} Image Upload'.format(current_app.config['APP_NAME']) description = 'This is part of an idling vehicle report on {}.'.format( current_app.config['APP_NAME']) if image_url is not None: result = client.upload_from_url(url=image_url, config={ 'title': title, 'description': description, }) else: result = client.upload_from_path(path=image_file_path, config={ 'title': title, 'description': description, }) os.remove(image_file_path) return result['link'], result['deletehash']
def uploadToImgur(userid,url): db = app.connect_db() c = db.cursor() c.execute('SELECT map_url,name,farmname,date,imgur_json FROM playerinfo WHERE url='+app.app.sqlesc,(url,)) result = c.fetchone() if result[4] != None: previous_upload_properties = json.loads(result[4]) if time.time() < previous_upload_properties['upload_time']+(2*3600): return {'error':'too_soon','link':previous_upload_properties['imgur_url']} map_url = result[0] titlestring = u"{} Farm, {} by {}".format(result[2],result[3],result[1]) descriptionstring = u"Stardew Valley game progress, full summary at http://upload.farm/{}".format(url) # try: c.execute('SELECT imgur_json FROM users WHERE id='+app.app.sqlesc,(userid,)) r = json.loads(c.fetchone()[0]) access_token = r['access_token'] refresh_token = r['refresh_token'] client = ImgurClient(app.app.config['IMGUR_CLIENTID'],app.app.config['IMGUR_SECRET']) client.set_user_auth(access_token,refresh_token) # file = url_for('home',filename=map_url,_external=True) # print 'uploaded to',file # client.upload_from_url(file,config={'title':'uploaded from','description':'upload.farm'},anon=False) if app.app.config['IMGUR_DIRECT_UPLOAD'] == True: result = client.upload_from_path(map_url,config={'title':titlestring,'description':descriptionstring},anon=False) else: map_url = u"http://upload.farm/{}".format(map_url) result = client.upload_from_url(map_url,config={'title':titlestring,'description':descriptionstring},anon=False) print(result) imgur_json = json.dumps({'imgur_url':'http://imgur.com/'+result['id'],'upload_time':time.time()}) c.execute('UPDATE playerinfo SET imgur_json='+app.app.sqlesc+' WHERE url='+app.app.sqlesc,(imgur_json,url)) db.commit() try: return {'success':None,'link':result['link']} except: return {'error':'upload_issue','link':None}
def upload_img_from_url(url): imgur_api = ImgurClient(app.config['CLIENT_ID'], app.config['CLIENT_SECRET']) resp = imgur_api.upload_from_url(url) resp['link'] = normalize_url(resp['link']) return {u'link': resp['link']}
class uploader(): def __init__(self): self.client_id = os.environ.get('Client_ID') self.client_secret = os.environ.get('Client_Secret') self.access_token = os.environ.get('access_token') self.refresh_token = os.environ.get('refresh_token') self.client = ImgurClient(self.client_id, self.client_secret, self.access_token, self.refresh_token) def upload_photo(self, image_url, album): config = { 'album': album, } print(config) print("Uploading image... ") try: image = self.client.upload_from_url(image_url, config=config, anon=False) except Exception as e: print(e) return True print("Done") return False
def run(): client = ImgurClient(os.environ['IMGUR_CLIENT_ID'], os.environ['IMGUR_CLIENT_SECRET'], os.environ['IMGUR_ACCESS_TOKEN'], os.environ['IMGUR_REFRESH_TOKEN']) url = "http://www.elztalflieger1.de/webcamsp/images/current.jpg" try: client.upload_from_url(url, config={'album': '1EN5T'}, anon=False) print("Uploaded " + url) except ImgurClientError as e: print(e.error_message) url = current_image_url(2) try: client.upload_from_url(url, config={'album': 'BN5AE'}, anon=False) print("Uploaded " + url) except ImgurClientError as e: print(url + ' ' + e.error_message)
async def buildEmbed(msg, url, tweet='', author=''): if url != "": if cfg["config"]["cache"] == True: try: url2 = url if not any(ext in url for ext in ['.mp4', ".mov", ".webm", ".webp"]): client = ImgurClient(cfg["config"]["imgur_usr"], cfg["config"]["imgur_scr"]) url = client.upload_from_url(url, anon=True)["link"] except: url = url2 pass embed = discord.Embed() if len(tweet): embed.add_field(name='Tweet/Embed Content', value=tweet, inline=False) elif isinstance(msg, discord.Message) and len(msg.content): embed.add_field(name='Content', value=msg.content, inline=False) embed.add_field(name='Message Link', value='https://discordapp.com/channels/{}/{}/{}'.format( msg.guild.id, msg.channel.id, msg.id), inline=False) if len(author): auth = msg.guild.get_member_named(author).mention else: auth = msg.author.mention embed.add_field(name='Author', value=auth, inline=True) embed.add_field(name='Channel', value=msg.channel.mention, inline=True) embed.set_image(url=url) await bot.get_channel(cfg[str(msg.guild.id)]['bot']['archive_channel'] ).send(embed=embed)
class ImgurReuploader: def __init__(self, config_address = 'imgur.ini'): self.images_address = 'images.json' config = configparser.ConfigParser() config.read(config_address) self.client = ImgurClient(config["imgur"]["client_id"], config["imgur"]["client_secret"], config["imgur"]["access_token"], config["imgur"]["refresh_token"]) self.uploads = {} self.load_from_json() def upload(self, url): if url in self.uploads: return self.uploads[url] final_url = requests.get(url).url rehost = self.client.upload_from_url(final_url) self.uploads[url] = rehost['link'] return rehost['link'] def save_to_json(self): with open(self.images_address, 'w') as json_file: json.dump(self.uploads, json_file) def load_from_json(self): if os.path.isfile(self.images_address): with open(self.images_address) as json_file: self.uploads = json.load(json_file)
def uploadToImgur(userid, url): db = app.connect_db() c = db.cursor() c.execute( 'SELECT map_url,name,farmname,date,imgur_json FROM playerinfo WHERE url=' + app.app.sqlesc, (url, )) result = c.fetchone() if result[4] != None: previous_upload_properties = json.loads(result[4]) if time.time() < previous_upload_properties['upload_time'] + (2 * 3600): return { 'error': 'too_soon', 'link': previous_upload_properties['imgur_url'] } map_url = result[0] titlestring = u"{} Farm, {} by {}".format(result[2], result[3], result[1]) descriptionstring = u"Stardew Valley game progress, full summary at http://upload.farm/{}".format( url) # try: c.execute('SELECT imgur_json FROM users WHERE id=' + app.app.sqlesc, (userid, )) r = json.loads(c.fetchone()[0]) access_token = r['access_token'] refresh_token = r['refresh_token'] client = ImgurClient(app.app.config['IMGUR_CLIENTID'], app.app.config['IMGUR_SECRET']) client.set_user_auth(access_token, refresh_token) # file = url_for('home',filename=map_url,_external=True) # print 'uploaded to',file # client.upload_from_url(file,config={'title':'uploaded from','description':'upload.farm'},anon=False) if app.app.config['IMGUR_DIRECT_UPLOAD'] == True: result = client.upload_from_path(map_url, config={ 'title': titlestring, 'description': descriptionstring }, anon=False) else: map_url = u"http://upload.farm/{}".format(map_url) result = client.upload_from_url(map_url, config={ 'title': titlestring, 'description': descriptionstring }, anon=False) print(result) imgur_json = json.dumps({ 'imgur_url': 'http://imgur.com/' + result['id'], 'upload_time': time.time() }) c.execute( 'UPDATE playerinfo SET imgur_json=' + app.app.sqlesc + ' WHERE url=' + app.app.sqlesc, (imgur_json, url)) db.commit() try: return {'success': None, 'link': result['link']} except: return {'error': 'upload_issue', 'link': None}
class ImgurBot: def __init__(self): self.client = None self.authorized = False if (req_info.needToAddInfo(useImgur=True)): print( "Need to update required_info.py with correct credentials before running, see README for more info" ) super().__init__() def authenticate(self): self.client = ImgurClient(req_info.client_id_imgur, req_info.client_secret_imgur) authorization_url = self.client.get_auth_url('pin') print("Go to the following URL: {0}".format(authorization_url)) # Read in the pin, handle Python 2 or 3 here. pin = get_input("Enter pin code: ") # ... redirect user to `authorization_url`, obtain pin (or code or token) ... credentials = self.client.authorize(pin, 'pin') self.client.set_user_auth(credentials['access_token'], credentials['refresh_token']) print("Authentication successful! Here are the details:") print(" Access token: {0}".format(credentials['access_token'])) print(" Refresh token: {0}".format(credentials['refresh_token'])) self.authorized = True def getalbums(self): albums = self.client.get_account_albums(req_info.imgur_account, page=0) print("Done") print(albums) def upload_to_album(self, albumId, title, description, image_url): config = { 'album': albumId, 'name': title, 'title': title, 'description': description } self.client.upload_from_url(image_url, config=config, anon=False) pass
def upload(self, url): imagecloud = ImageCloud().get_by_id('1') logging.info('Image cloud: '+str(imagecloud)) try: client = ImgurClient(imagecloud.client_id, imagecloud.client_secret) client.set_user_auth(imagecloud.access_token, imagecloud.refresh_token) conf = {"album" : "KHz1y"} resp = client.upload_from_url(url, config=conf, anon=False) logging.info('Resp imgur: '+str(resp)) return resp['link'] except Exception as e: logging.info("Erro imgur: "+str(e)) raise ErrorUploadImage
class Imgur(): def __init__(self): self.imgur_client = ImgurClient(IMGUR_ID, IMGUR_SECRET) def save_from_url(self, image_url): logging.debug("trying to save %s" % image_url) response = self.imgur_client.upload_from_url(clean_path(image_url)) return str(response['link']) def save_from_file(self, file_path): logging.debug("trying to save file %s" % file_path) response = self.imgur_client.upload_from_path(file_path) return (str(response['link']))
def upload_photo(image_url): client_id = '08dd33b004aeb70' client_secret = 'df0e8f73218d6046b49cf3d481f898ff658868fa' access_token = '714846b6f07dddaea1b9144a0b5fdc1e49c2cc93' refresh_token = '714846b6f07dddaea1b9144a0b5fdc1e49c2cc93' client = ImgurClient(client_id, client_secret, access_token, refresh_token) album = None # You can also enter an album ID here config = { 'album': album, } print("Uploading image... ") image = client.upload_from_url(image_url, config=config, anon=False) print("Done") return image['link']
def reupload_image_to_imgur(url): try: if 'jpg' in url: client = ImgurClient(IMGUR_CLIENT_ID, IMGUR_CLIENT_SECRET) # print(client.credits) time.sleep(3) # Be nice to Imgur, we're a bot in no rush. print("Uploading image") item = client.upload_from_url(url) return item['link'] else: return url except Exception as e: print(f"error in reupload_image_to_imgur() : {e}") return url
def upload_photo(image_url): client_id = '9efb779cd512a75' client_secret = 'f0c60f6d82e3b9b2d33a7f81318ac950ee424aa4' access_token = '3827abdb987541f4e5d7831cfa91f64b838d6fcf' refresh_token = '1df2672c250d33d5823ddf7d7a1d34ffbca0b2fc' client = ImgurClient(client_id, client_secret, access_token, refresh_token) album = None # You can also enter an album ID here config = { 'album': album, } print("Uploading image... ") image = client.upload_from_url(image_url, config=config, anon=False) print("Done") return image['link']
def upload_photo(image_url): client_id = 'happysorry34' client_secret = 'jeff81397' access_token = 'your token' refresh_token = 'your token' client = ImgurClient(client_id, client_secret, access_token, refresh_token) album = None # You can also enter an album ID here config = { 'album': album, } print("Uploading image... ") image = client.upload_from_url(image_url, config=config, anon=False) print("Done") return image['link']
def upload(self, client: ImgurClient) -> list[int]: """Upload images to Imgur :param client: imgur api client :type client: ImgurClient :return: list of uplaoded image ids :rtype: list[int] """ if self.image_id is None: logging.info('Uploading image to album "%s"', self.deletehash) print(self.status["twitter"]["media"], self.gen_config()) ret = client.upload_from_url( self.status["twitter"]["media"], config=self.gen_config(), anon=False ) self.image_id = ret["id"] else: logging.info( 'Image already uploaded to album "%s" with id "%s"', self.deletehash, self.image_id, ) return self.image_id
def upload_photo(image_url, image_name): client_id = 'YOUR_CLIENT_ID' client_secret = 'YOUR_CLIENT_SECRET' access_token = 'YOUR_ACCESS_TOKEN' refresh_token = 'YOUR_REFRESH_TOKEN' client = ImgurClient(client_id, client_secret, access_token, refresh_token) album_id = 'YOUR_ALBUM_ID' album = client.get_album(album_id) # check whether image have been upload ever for image in album.images: if image['name'] == image_name: print('Find image in Album {}!'.format(album_id)) return image['link'] # set configuration config = { 'album': album_id, 'name': image_name } print('Uploading image to imgur.com ... ...') image = client.upload_from_url(image_url, config=config, anon=False) print('Upload Done~') return image['link']
class Author: """Class that represents an author inside some underhood account, tweets and has even few API calls when needed.""" underhood: str twitter_token: InitVar[str] name: str = "" username: str = "" has_twitter: bool = True avatar: str = "" first_id: InitVar[int] = 0 until_id: InitVar[int] = 0 limit: int = 0 def __post_init__(self, twitter_token: str, first_id: int = 0, until_id: int = 0): self.client = Client(twitter_token) self.user = self.client.get_user( username=self.underhood, expansions="pinned_tweet_id", user_fields=["profile_image_url", "description"]) first_id = first_id or self.user.data.pinned_tweet_id _first_tweet = self.get_tweet(first_id) all_tweets = [_first_tweet] for response in reversed( list( Paginator( self.client.get_users_tweets, id=self.user.data.id, since_id=first_id, until_id=until_id or None, expansions=EXPANSIONS, tweet_fields=TWEET_FIELDS, media_fields=MEDIA_FIELDS, ))): for t in response.data or []: if t.attachments: if t.attachments.get("media_keys"): t.attachments["media"] = [ # v2 api me no like it m.get("url") or m.get("preview_image_url") for m in response.includes.get("media", []) for mkey in t.attachments.get("media_keys", []) if m["media_key"] == mkey ] if t.attachments.get("poll_ids"): t.attachments["polls"] = [ p.get("options") for p in response.includes.get("polls", []) if p.get("id") == t.attachments.get( "poll_ids", [0])[0] # TODO: refactor this ] all_tweets.append(t) self.timeline = [] self.conversations: defaultdict[ int, list[UnderhoodTweet]] = defaultdict(list) for t in sorted(all_tweets, key=lambda k: k.id): if not t.text.startswith(("@", "RT @")): tweet = UnderhoodTweet( tweet=t, quoted= ( # Twitter V2 API :( or I don't know the best way to do this self.get_tweet(t.referenced_tweets[0].id) if t.referenced_tweets and t.referenced_tweets[0].type == "quoted" else None), ) self.timeline.append(tweet) self.conversations[tweet.conversation_id].append(tweet) if self.limit and len(self.timeline) >= self.limit: break if not self.username: self.username = self.extract_username() or self.author_hash if not self.name: self.name = self.extract_name() if not self.avatar: self.imgur_client = ImgurClient(environ.get("IMGUR_API_ID"), environ.get("IMGUR_API_SECRET")) response = self.imgur_client.upload_from_url( self.user.data.profile_image_url.replace("_normal", ""), anon=True) self.avatar = response["link"] def get_tweet(self, tweet_id: int) -> Tweet: """Get tweet from Twitter API by id.""" return self.client.get_tweet(id=tweet_id, expansions=EXPANSIONS, tweet_fields=TWEET_FIELDS, media_fields=MEDIA_FIELDS).data @property def author_hash(self) -> str: """Internal first author tweet hash needed for different purposes.""" self.has_twitter = False return hashlib.sha256(self.first_tweet.text.encode()).hexdigest()[:7] @property def description(self) -> str: """Profile description property.""" return self.user.data.description @cached_property def first_tweet(self): """Last author tweet property.""" return self.timeline[0] @cached_property def last_tweet(self): """Last author tweet property.""" return self.timeline[-1] def extract_name(self): """Get author name from description or the first author tweet by using Spacy NER. Returns: name if found else an empty string """ def search_name(d): """Extract first found two-word string (real person name) from Spacy entities analysis.""" names = [ x.text for x in d.ents if x.label_ == "PER" if len(x.text.split()) > 1 ] return names[0] if names else "" description, tweet = self.description, self.first_tweet nlp = load(LOCALE.spacy_model) for text in (description, tweet.text): doc = nlp(text) name = search_name(doc) if name: break return name def extract_username(self) -> str: """Get username from description or the first author tweet by searching for @. Returns: username if found else an empty string """ description, tweet = self.description, self.first_tweet for text in (description, tweet.text): if "@" in text: text = text.translate( str.maketrans(string.punctuation.replace("@", ""), " " * (len(string.punctuation) - 1))) return text.split("@")[1].split()[0] return ""
class MirrorOnImgurBot(tweepy.StreamListener): def __init__(self): # bot twitter user name self.username = '******' self.auth_twitter() self.auth_imgur() log.info('Init done') def auth_twitter(self): """ Authenticate with twitter and setup the 'api' object """ log.info('Wiring up twitter auth') # wire up stuff with twitter auth self.auth = tweepy.OAuthHandler(creds.T_CONSUMER_KEY, creds.T_CONSUMER_SECRET) self.auth.set_access_token(creds.T_ACCESS_TOKEN, creds.T_ACCESS_TOKEN_SECRET) self.api = tweepy.API(self.auth, wait_on_rate_limit = True, wait_on_rate_limit_notify = True) def auth_imgur(self): """ Authenticate with imgur and setup the imgur client """ log.info('Wiring up imgur auth') # wire up stuff with imgur auth self.imgur_client = ImgurClient(creds.I_CLIENT_ID, creds.I_CLIENT_SECRET) def rate_limit_status(self): """ Print twitter rate limit status """ log.info('Rate limit status:\n%r' % self.api.rate_limit_status()) def on_error(self, status): """ Handle twitter streaming endpoint error """ log.error('Error: %r' % status) self.rate_limit_status() def on_data(self, raw_data): """ Handle tweets received from the twitter streaming endpoint. This method is pretty much the whole bot. It parses the tweet, pulls out the url, uploads to imgur and replies to the tweet it had received with the new imgur url """ data = json.loads(raw_data) user_mentions = data.get('entities', {}).get('user_mentions', []) sender_username = data.get('user', {}).get('screen_name', 'UnknownUser') bot_is_mentioned = len(filter(lambda mentioned_user : mentioned_user['screen_name'] == self.username, user_mentions)) > 0 log.debug('Data %r' % data) log.info('Message from: %r' % sender_username) log.info('Is the bot mentioned? %r' % bot_is_mentioned) # if it's not a retweet and it isn't a tweet to myself from my own account # and if bot is mentioned then do stuff if not data['retweeted'] and sender_username != self.username and bot_is_mentioned: try: tweet_id = data.get('id_str') url = 'http' + data.get('text', '').split('http')[1].strip().split()[0].strip() except Exception as e: log.error('Error: %r', e) url = '' finally: self.handle_url(url, tweet_id, sender_username) def handle_url(self, url, tweet_id, sender_username): """ Decide what to do based on url If it's valid, upload to imgur else reply with an error message """ sender_username = '******' + sender_username log.info('Url received: %r' % url) log.info('Reply to user: %r' % sender_username) try: parsedUrl = urlparse(url) # if the url is indeed valid (has a hostname) if parsedUrl.netloc != '': # mirror on imgur imgur_reply = self.imgur_client.upload_from_url(url) msg = sender_username + ' ' + imgur_reply.get('link', 'Upload failed') log.debug('Imgur response: %r' % imgur_reply) log.info('Bot reply: %r to tweet id %r' % (msg, tweet_id)) self.api.update_status(status = msg, in_reply_to_status_id = tweet_id) else: self.api.update_status(status = sender_username + ' ' + 'send me a valid url please :)', in_reply_to_status_id = tweet_id) except Exception as e: log.error('Error: %r' % e) self.api.update_status(status = sender_username + ' ' + 'something went wrong. womp womp :(', in_reply_to_status_id = tweet_id) finally: log.info('Reply sent')
class Imgur: imgur = None client_id = None client_secret = None def __init__(self): config = get_config() config.read('auth.ini') self.client_id = config.get('imgur', 'client_id') self.client_secret = config.get('imgur', 'client_secret') self.imgur = ImgurClient(self.client_id, self.client_secret) def createAlbum(self, album_title): log.d('Starting album creation...') fields = { 'Authorization':'Client-ID {' + self.client_id + '}', 'title':album_title } try: album = self.imgur.create_album(fields) log.d('Album created successfully.') return album except ImgurClientError as e: log.e('Failed to create album, aborting.') log.e(e.error_message) log.e(e.status_code) return None def uploadImagesToAlbum(self, album, imgList): # For anonymous albums, use album's deletehash instead of id config = { 'album': album['deletehash'] } log.d(imgList) #Upload images to album for link in imgList: log.d('Uploading ' + link + '...') try: response = self.imgur.upload_from_url(link, config=config, anon=True) log.d('Image uploaded successfully.') except ImgurClientError as e: print(e.error_message) print(e.status_code) log.e("Image upload failed, aborting.") return 0 # Wait for n seconds so Imgur doesn't get upset with us time.sleep(5) log.d('All images uploaded successfully.') return 1 def upload(self, imgLinks, albumName): # Create new Imgur album album = self.createAlbum(albumName) if(album is None): return None success = self.uploadImagesToAlbum(album, imgLinks) if(not success): return None # Return album URL albumLink = 'https://imgur.com/a/' + album['id'] log.d('Album Link: ' + albumLink) return albumLink
def uploadToImgur(userid, url): db = app.connect_db() c = db.cursor() c.execute( "SELECT map_url,name,farmname,date,imgur_json FROM playerinfo WHERE url=" + app.app.sqlesc, (url, ), ) result = c.fetchone() if result[4] != None: previous_upload_properties = json.loads(result[4]) if time.time() < previous_upload_properties["upload_time"] + (2 * 3600): return { "error": "too_soon", "link": previous_upload_properties["imgur_url"], } map_url = result[0] titlestring = u"{} Farm, {} by {}".format(result[2], result[3], result[1]) descriptionstring = ( u"Stardew Valley game progress, full summary at http://upload.farm/{}". format(url)) # try: c.execute("SELECT imgur_json FROM users WHERE id=" + app.app.sqlesc, (userid, )) r = json.loads(c.fetchone()[0]) access_token = r["access_token"] refresh_token = r["refresh_token"] client = ImgurClient(app.app.config["IMGUR_CLIENTID"], app.app.config["IMGUR_SECRET"]) client.set_user_auth(access_token, refresh_token) # file = url_for('home',filename=map_url,_external=True) # print 'uploaded to',file # client.upload_from_url(file,config={'title':'uploaded from','description':'upload.farm'},anon=False) if app.app.config["IMGUR_DIRECT_UPLOAD"] == True: result = client.upload_from_path( map_url, config={ "title": titlestring, "description": descriptionstring }, anon=False, ) else: map_url = u"http://upload.farm/{}".format(map_url) result = client.upload_from_url( map_url, config={ "title": titlestring, "description": descriptionstring }, anon=False, ) print(result) imgur_json = json.dumps({ "imgur_url": "http://imgur.com/" + result["id"], "upload_time": time.time() }) c.execute( "UPDATE playerinfo SET imgur_json=" + app.app.sqlesc + " WHERE url=" + app.app.sqlesc, (imgur_json, url), ) db.commit() try: return {"success": None, "link": result["link"]} except: return {"error": "upload_issue", "link": None}
class MirrorOnImgurBot(tweepy.StreamListener): def __init__(self): # bot twitter user name self.username = '******' self.auth_twitter() self.auth_imgur() log.info('Init done') def auth_twitter(self): """ Authenticate with twitter and setup the 'api' object """ log.info('Wiring up twitter auth') # wire up stuff with twitter auth self.auth = tweepy.OAuthHandler(creds.T_CONSUMER_KEY, creds.T_CONSUMER_SECRET) self.auth.set_access_token(creds.T_ACCESS_TOKEN, creds.T_ACCESS_TOKEN_SECRET) self.api = tweepy.API(self.auth, wait_on_rate_limit=True, wait_on_rate_limit_notify=True) def auth_imgur(self): """ Authenticate with imgur and setup the imgur client """ log.info('Wiring up imgur auth') # wire up stuff with imgur auth self.imgur_client = ImgurClient(creds.I_CLIENT_ID, creds.I_CLIENT_SECRET) def rate_limit_status(self): """ Print twitter rate limit status """ log.info('Rate limit status:\n%r' % self.api.rate_limit_status()) def on_error(self, status): """ Handle twitter streaming endpoint error """ log.error('Error: %r' % status) self.rate_limit_status() def on_data(self, raw_data): """ Handle tweets received from the twitter streaming endpoint. This method is pretty much the whole bot. It parses the tweet, pulls out the url, uploads to imgur and replies to the tweet it had received with the new imgur url """ data = json.loads(raw_data) user_mentions = data.get('entities', {}).get('user_mentions', []) sender_username = data.get('user', {}).get('screen_name', 'UnknownUser') bot_is_mentioned = len( filter( lambda mentioned_user: mentioned_user['screen_name'] == self. username, user_mentions)) > 0 log.debug('Data %r' % data) log.info('Message from: %r' % sender_username) log.info('Is the bot mentioned? %r' % bot_is_mentioned) # if it's not a retweet and it isn't a tweet to myself from my own account # and if bot is mentioned then do stuff if not data[ 'retweeted'] and sender_username != self.username and bot_is_mentioned: try: tweet_id = data.get('id_str') url = 'http' + data.get( 'text', '').split('http')[1].strip().split()[0].strip() except Exception as e: log.error('Error: %r', e) url = '' finally: self.handle_url(url, tweet_id, sender_username) def handle_url(self, url, tweet_id, sender_username): """ Decide what to do based on url If it's valid, upload to imgur else reply with an error message """ sender_username = '******' + sender_username log.info('Url received: %r' % url) log.info('Reply to user: %r' % sender_username) try: parsedUrl = urlparse(url) # if the url is indeed valid (has a hostname) if parsedUrl.netloc != '': # mirror on imgur imgur_reply = self.imgur_client.upload_from_url(url) msg = sender_username + ' ' + imgur_reply.get( 'link', 'Upload failed') log.debug('Imgur response: %r' % imgur_reply) log.info('Bot reply: %r to tweet id %r' % (msg, tweet_id)) self.api.update_status(status=msg, in_reply_to_status_id=tweet_id) else: self.api.update_status(status=sender_username + ' ' + 'send me a valid url please :)', in_reply_to_status_id=tweet_id) except Exception as e: log.error('Error: %r' % e) self.api.update_status(status=sender_username + ' ' + 'something went wrong. womp womp :(', in_reply_to_status_id=tweet_id) finally: log.info('Reply sent')
submission_generator = reddit.get_subreddit('gifs').get_new(limit=5) found_something = False for submission in submission_generator: post_id = vars(submission)['id'] if post_id in open("processed.txt").read(): print("Already processed") continue title = submission.title found_something = True url = vars(submission)['url'] permalink = vars(submission)['permalink'] #print(pprint.pprint(vars(submission))) extension = url[len(url) - 3:] if (extension == "gif"): try: result = client.upload_from_url(url, config=None, anon=True) gifv = result['gifv'] #print("gifv version: " + gifv) v_fixed.append([url, gifv]) submission.add_comment('Here is a blazing fast gifv version! ' + gifv) print(("Title: " + title + "\nPermalink: " + permalink + "\nURL: " + url + "\ngifv: " + gifv)) with open("processed.txt", "a") as test: test.write(post_id + "\n") except: print("Looks like an error, skipping to the next post...") continue time.sleep(5)
from imgurpython import ImgurClient # If you already have an access/refresh pair in hand client_id = 'ffc7dd68362e1f6' client_secret = '9a2a06c85329e39648ac4094ed6174a3215f098e' access_token = '00b4ebf77302bf9665cb8d016858d77e19a4f93a' refresh_token = '6e7c6da8f481ee71cbae41a046dcedeec84797db' # Note since access tokens expire after an hour, only the refresh token is required (library handles autorefresh) client = ImgurClient(client_id, client_secret, access_token, refresh_token) url = 'https://im.ezgif.com/tmp/ezgif-1-7847e769eb.mp4' client.upload_from_url(url, config=None, anon=False)
class Imgur: """The most awesome images on the internet! This plugin allows basic searching on Imgur including subreddits. Warning: Searching on subreddits cannot be easily moderated, therefore it is extremely easy for a user to post images from an nsfw subreddit to whatever channel the bot is enabled in if this plugin is enabled without modification. The subreddit command can be disabled by changing 'enabled=True' to 'enabled=False' in the plugin's main file: 'plugins/imgur.py' on line 53. """ def __init__(self, bot): self.bot = bot self.client = ImgurClient(config["client_id"], config["client_secret"]) @c.group(pass_context=True) async def imgur(self, ctx): """Search on Imgur!""" if ctx.invoked_subcommand is None: await self.bot.say("Zoinks! You've taken a wrong turn! Try `help imgur`.") # Helper function to actually get/post the images async def post_image(self, request, query=None): case = { "subreddit": lambda: self.client.subreddit_gallery(query), "search" : lambda: self.client.gallery_search(query), "random" : lambda: self.client.gallery_random(), "top" : lambda: self.client.gallery("top"), "hot" : lambda: self.client.gallery("hot"), "rehost" : lambda: self.client.upload_from_url(query), } function = case.get(request, None) image = self.bot.loop.run_in_executor(None, function) while True: await asyncio.sleep(0.25) if image.done(): image = image.result() break if request == "rehost": await self.bot.say(image.get("link", None)) else: await self.bot.say(random.choice(image).link) @imgur.command(name="sub", aliases=["subreddit", "reddit", "r/"], enabled=True) async def imgur_subreddit(self, subreddit: str): """Get an image from a subreddit.""" await self.post_image("subreddit", subreddit) @imgur.command(name="search") async def imgur_search(self, *, query: str): """Search Imgur for (almost) anything.""" await self.post_image("search", query) @imgur.command(name="random") async def imgur_random(self): """One free random image.""" await self.post_image("random") @imgur.command(name="viral") async def imgur_viral(self, section: str = "top"): """Get one of the most viral images of the day. Section may be either 'top' or 'hot' and will get an image based on that criteria.""" section = section.lower() if section != "top": section = "hot" await self.post_image(section) @imgur.command(name="rehost") async def imgur_rehost(self, url: str): """Rehost an image from any link to Imgur.""" await self.post_image("rehost", url)
from imgurpython import ImgurClient PATH = "https://www.shardveil.com/images/cards/placeholder/arcanum-steward.png" client = ImgurClient("ee1f0e6204e2e8d", "263d92665bb96cc79098637b79958f6a317f554f") uploaded_image = client.upload_from_url(PATH) print(uploaded_image['id'])
class App: def __init__(self): self.client = None def initialize_client(self): with open(os.path.join(dirname, "creds.json"), "r") as f: stored_creds = json.load(f) if "client_id" not in stored_creds: stored_creds["client_id"] = None if "client_secret" not in stored_creds: stored_creds["client_secret"] = None client_id = stored_creds["client_id"] client_secret = stored_creds["client_secret"] new_creds = False while True: try: self.client = ImgurClient(client_id, client_secret) break except: print("*** Missing or invalid client credentials. ", end="") print("You must first register an applicaton with Imgur ", end="") print("and provide the client id and secret. ", end="") print("See README.md for help.") client_id = input("Client ID: ") client_secret = input("Client secret: ") new_creds = True # Update creds file if there was a change. if new_creds: print("Client credentials successfully validated.\n") stored_creds["client_id"] = client_id stored_creds["client_secret"] = client_secret with open(os.path.join(dirname, "creds.json"), "w") as f: json.dump(stored_creds, f) def authorize_user(self): with open(os.path.join(dirname, "creds.json"), "r") as f: stored_creds = json.load(f) if "access_token" not in stored_creds: stored_creds["access_token"] = None if "refresh_token" not in stored_creds: stored_creds["refresh_token"] = None access_token = stored_creds["access_token"] refresh_token = stored_creds["refresh_token"] new_tokens = False while True: try: self.client.set_user_auth(access_token, refresh_token) break except: print("*** Missing or invalid tokens. ", end="") print("Please follow the OAuth flow and enter the pin.") webbrowser.open(self.client.get_auth_url("pin")) pin = input("Pin: ") try: credentials = self.client.authorize(pin, "pin") except: print("Invalid pin.") continue access_token = credentials["access_token"] refresh_token = credentials["refresh_token"] new_tokens = True # Update creds file if there was a change. if new_tokens: print("Tokens successfully validated.\n") stored_creds["access_token"] = access_token stored_creds["refresh_token"] = refresh_token with open(os.path.join(dirname, "creds.json"), "w") as f: json.dump(stored_creds, f) def create_album(self, targets, title, description): print("Creating album... ", end="", flush=True) album = self.client.create_album({ "title": title, "description": description }) print(f"done. (id={album['id']})") config = { "album": album["deletehash"] } # If there is only one image, add title/description to the image also. if len(targets) == 1: config["title"] = title config["description"] = description images = [] for target in targets: # URL upload. if urllib.parse.urlparse(target).scheme in ("http", "https"): images += filter(None, [self.upload_image(config, url=target)]) # File upload. elif os.path.isfile(target): images += filter(None, [self.upload_image(config, path=target)]) # Directory upload. elif os.path.isdir(target): for filepath in glob.glob(f"{target}/**"): images += filter(None, [self.upload_image(config, path=filepath)]) else: print(f"*** Invalid target: {target} ***") print("========================================") print(f"Album: https://imgur.com/a/{album['id']}") if images: print(f"First Image: https://imgur.com/{images[0]['id']}.png") print("") return { "album_id": album["id"], "image_ids": [i["id"] for i in images] } def upload_image(self, config, url=None, path=None): try: if url is not None: print(f"Uploading {url}... ", end="", flush=True) image = self.client.upload_from_url(url, config=config) elif path is not None: print(f"Uploading {path}... ", end="", flush=True) image = self.client.upload_from_path(path, config=config) else: return except Exception as e: print(f"failed.\n*** {e} ***") return print(f"done. (id={image['id']})") return image def parse_args(self, raw_args): parser = argparse.ArgumentParser(raw_args) parser.add_argument( "targets", metavar="target", nargs="+", help="directory, filepath, or url to upload" ) parser.add_argument( "-t", "--title", dest="title", metavar="title", help="post's title" ) parser.add_argument( "-d", "--description", dest="description", metavar="desc", help="post's description" ) parser.add_argument( "-a", "--anonymous", dest="anon", action="store_const", const=True, default=False, help="anonymously upload (no imgur account)" ) return parser.parse_args() def prompt_args(self): print("-- Targets may be a url, filepath, or directory.") targets = [] while True: target = input("Target: ") if target: targets.append(target) else: break title = input("Title: ") description = input("Description: ") anon = (input("Anonymous (y/n): ") == "y") print("") return argparse.Namespace(targets=targets, title=title, description=description, anon=anon) def run(self, raw_args): self.initialize_client() if raw_args: interactive = False args = self.parse_args(raw_args) else: interactive = True args = self.prompt_args() if not args.anon: self.authorize_user() self.create_album(args.targets, args.title, args.description) print(self.client.credits) if interactive: input("press enter to exit...")