def main():
images_url = 'https://api.spacexdata.com/v3/launches/latest'
response = requests.get(images_url)
response.raise_for_status()
image_links = response.json()['links']['flickr_images']
for link_number, link in enumerate(image_links):
download_image(link, f'spacex{link_number + 1}.jpg')
def post_reply(self, status):
statusID = status.id_str
i = 0
print(f"Processing status {statusID}.")
media = get_status_media(status)
if media is None or media[0]["type"] != "photo":
print("Sem imagens.")
return
urlArray = get_media_url(media)
print("Downloading images...")
for i, url in enumerate(urlArray):
utils.download_image(f"image{i}.jpg", urlArray[0])
print("Completed!")
print("Coloring images...")
for i, url in enumerate(urlArray):
colorize_image(f"image{i}.jpg")
print("Completed!")
print("Uploading images...")
newMedias = []
for i, url in enumerate(urlArray):
newMedia = self.client.media_upload(f"image{i}.jpg")
newMedias.append(newMedia.media_id)
res = self.client.update_status("",
in_reply_to_status_id=statusID,
media_ids=newMedias,
auto_populate_reply_metadata=True)
print("Completed!")
def fetch_hubble_image(image_id, source_path):
response = requests.get(f'http://hubblesite.org/api/v3/image/{image_id}')
response.raise_for_status()
review_result = response.json()
file_link = review_result['image_files'][-1]['file_url']
logger.info(f'download http:{file_link}')
utils.download_image(image_id, f'http:{file_link}', source_path)
def selfie2anime():
img_id = os.environ['id']
result_id = os.environ['result']
parser = get_parser()
args = parser.parse_args("--phase test".split())
with tf.Session(config=tf.ConfigProto(allow_soft_placement=True)) as sess:
#sess.reuse_variables()
gan = UGATIT(sess, args)
# build graph
gan.build_model()
# download target img
download_path = os.path.join(img_path, img_id)
download_image(images_bucket, img_id, dest=download_path)
dataset_tool.create_from_images(record_path, img_path, True)
# os.remove(del_record)
img = gan.infer(download_path)
image_url = upload_image(img, result_id)
return download_path, img
def fetch_hubble_images(image_url, collection_name, folder):
for image_id in get_images_ids(collection_name):
user_url = get_best_image_url(image_url, image_id)
filename = os.path.join(os.getcwd(), folder,
f'{image_id}{os.path.splitext(user_url)[-1]}')
download_image(user_url, filename)
print(f'File {image_id} downloaded')
def colorize_image(filename):
api_url = "https://api.deepai.org/api/colorizer"
files = {"image": open(filename, 'rb')}
headers = {"api-key": keys["deepai_key"]}
res = requests.post(api_url, files=files, headers=headers)
res_data = res.json()
utils.download_image(filename, res_data["output_url"])
def fetch_hubble_image(image_id):
response = requests.get(f"{HUBBLE_IMAGE_API}{image_id}")
response.raise_for_status()
image_data = response.json()
url = f"https:{image_data['image_files'][-1]['file_url']}"
(_, ext) = os.path.splitext(url)
name = f"{image_id}{ext}"
utils.download_image(url, name)
def fetch_spacex_launch(images_url, folder):
file_path = os.path.join(os.getcwd(), folder, 'spacex')
file_extension = '.jpg'
spacex_response = requests.get(images_url)
spacex_response.raise_for_status()
images_links = spacex_response.json()['links']['flickr_images']
for image_number, image_link in enumerate(images_links, start=1):
download_image(image_link,
f'{file_path}{image_number}{file_extension}')
def get_profile_photos(browser, username):
save_dir = 'profiles/' + username + '/'
create_dir(save_dir) # need to fix these names
i = 0
for image in browser.find_elements_by_xpath('//div[@id="profile_thumbs"]//img[@src]'):
image_url = image.get_attribute('src')
save_path = save_dir + str(i) + '.webp' # probably a bad idea to assume the img format
download_image(image_url, save_path)
i += 1 # using 'i' is probably not the clean way to name these images
def download_book_cover(url, image_name):
r = requests.get(url)
soup = BeautifulSoup(r.content, 'html.parser')
img_tag = soup.find('img', attrs={'id': 'coverImage'})
if img_tag:
image_url = img_tag.attrs['src']
download_image(image_url=image_url, image_name=image_name)
return True
return False
def download_book_covers(books):
for book in books:
my_logger.debug("Downloading book cover for: {}".format(book['name']))
image_url = book['image_url']
extention = image_url.split('.')[-1]
image_name = "{}.{}".format(book['goodreads_id'], extention)
download_image(image_url=image_url, image_name=image_name)
book['image_name'] = image_name
time.sleep(1)
return books
def fetch_spacex_last_launch(images_path=IMAGES_FOLDER):
"""Download pics from last SpaceX launch."""
default_filename = "spacex"
for num, link in enumerate(get_latest_launch_images_links()):
_, ext = os.path.splitext(link)
file_name = f"{default_filename}{str(num)}{ext}"
print("Download by link: {0} ".format(link))
download_image(url=link, img_path=images_path, img_name=file_name)
print("File {0} saved".format(file_name))
def echo_photo(update, context):
global message
global current_command
if current_command == 'upload':
current_command = 'o'
chat = update.message['chat']['id']
photo_id = update.message['photo'][-1]['file_id']
random_string = str(time.time())
download_image(chat, photo_id, random_string)
#attatchents.append('photo.jpg'+ random_string)
temp.append('photo.jpg'+ random_string)
update.message.reply_text("enter link for order button..")
def fetch_spacex_launch(source_path, launch_id):
logger.info('download SpaceX images')
response = requests.get(
f'https://api.spacexdata.com/v4/launches/{launch_id}')
response.raise_for_status()
review_result = response.json()
picture_links = review_result['links']['flickr']['original']
for picture_number, picture_link in enumerate(picture_links):
file_name = f'spacex{picture_number}'
logger.info(f'download {picture_link}')
utils.download_image(file_name, picture_link, source_path)
def download_versioned_cdragon_item_icon(item_id):
item_id = item_id.lower().split("/")[-1].replace(".dds", ".png")
if settings.patch[
'cdragon'] == "pbe": # Season 11 items in different location
return utils.download_image(
constants.cdragon_url +
f"/{settings.patch['cdragon']}/game/assets/items/icons2d/{item_id}"
)
else:
return utils.download_image(
constants.cdragon_url +
f"/{settings.patch['cdragon']}/game/data/items/icons2d/{item_id}")
def download_image_file(meta):
download_image(meta)
path, dirs, files = next(os.walk(base_path + 'images/logs'))
file_count = len(files)
printProgressBar(file_count,
14653,
prefix='Progress:',
suffix='Complete',
decimals=2,
length=50)
def fetch_spacex_last_launch():
response = requests.get(SPACEX_LATEST_API)
response.raise_for_status()
launches = response.json()
if not launches["links"]["flickr"]["original"]:
response = requests.get(SPACEX_API)
launches = response.json()
for launch in launches:
if launch["links"]["flickr"]["original"]:
spacex_image = launch["links"]["flickr"]["original"]
break
for num_image, url_image in enumerate(spacex_image):
utils.download_image(url_image, f"spacex{num_image}.jpg")
def scrape_picture(picture_url, save_location, ids, verbose, gallery_name):
"""
Scrape a single picture.
Parameters
----------
- picture_url (str): The URL of the picture to save, e.g.
`http://www.imagefap.com/photo/361343809/?pgid=&gid=7225770&page=0&idx=2`.
- save_location (str): The location to save to, e.g. `downloads`.
- gallery_name (str): Gallery name used for the save folder.
- ids (boolean): Whether or not to use IDs for gallery and picture names.
- verbose (boolean): Whether or not to print information.
"""
# Get the download url
picture_dl_url = picture_dl_url_from_picture_url(picture_url)
# Get information for saving
username, gallery_id, picture_id, picture_name_full, filetype = \
information_from_picture_dl_url(picture_dl_url)
# Choose a directory name to save to,
# either using gallery ids or gallery name
if ids:
save_directory = os.path.join(save_location, gallery_id)
else:
save_directory = os.path.join(save_location, gallery_name)
# Create the directory if it does not exist
if not os.path.exists(save_directory):
os.makedirs(save_directory)
# Save images
if ids:
save_directory = os.path.join(save_directory, picture_id + '.' + filetype)
else:
save_directory = os.path.join(save_directory, picture_name_full)
# Download the image
download_image(picture_dl_url, save_directory)
if verbose:
print('Downloaded:', save_directory)
def make_background(self):
photos = self.get_panoramas()
image_list = []
for p in photos:
url = p.get('photo_file_url')
name = url.split('/').pop()
print 'downloading %s ...' % name
download_image(url, self.id, name)
image_list.append(name)
print 'total: %i' % len(image_list)
grid = 10
sizex = 60
sizey = 60
xy = (sizex * grid, sizey * grid)
blank_image = Image.new("RGB", xy)
ycar = 0
xcar = 0
y = 0
x = 0
statics_path = settings.MEDIA_ROOT
downloads_path = os.path.join(settings.DOWNLOAD_IMAGE_PATH, str(self.id))
for i in range(0, (grid*grid)):
if i % grid == 0:
y = ycar * sizey
ycar = ycar + 1
xcar = 0
else:
xcar = xcar + 1
x = sizex * xcar
img = Image.open( os.path.join(downloads_path, image_list[i]) )
blank_image.paste(img, (x,y))
negro = Image.open( os.path.join(statics_path, 'negro.jpg') )
blank_image.save( os.path.join(statics_path, 'backgrounds', '%i.jpg' % self.id) , quality=100)
image = Image.blend(blank_image, negro, 0.5)
image.save( os.path.join(statics_path, 'backgrounds', '%i_black.jpg' % self.id) , quality = 100)
image = Image.open(os.path.join(statics_path, 'backgrounds', '%i_black.jpg' % self.id))
self.image = image.filename.split('static/').pop()
self.save()
def winner_tweet(api, winner_handle, auction_id, image_url, product_url,
product_name):
image_path = utils.download_image(auction_id, image_url)
tweet = "The auction for " + product_name[:
50] + " is won by: " + winner_handle + "\n Get your product here : " + product_url
api.update_with_media(image_path, status=tweet)
def get_support_card(uri: str, soup: BeautifulSoup):
wiki_id = int(uri.split('/')[-1])
h3 = soup.find('h3')
card_name = h3.text.replace('の性能', '')
illust_uri = h3.find_next_sibling('img')['data-original']
image_filename = download_image(illust_uri)
card_table: BeautifulSoup = soup.find_all('table')[1]
card_field = card_table.find_all('td')
rare_degree = card_field[0].text
card_type = card_field[1].text
second_name = card_field[2].text
support_card = SupportCard(card_name=card_name,
card_name_kr=card_name,
card_type=card_type,
card_type_kr=card_type,
card_image=image_filename,
gamewith_wiki_id=wiki_id,
rare_degree=rare_degree,
second_name=second_name,
second_name_kr=second_name)
db_session.add(support_card)
return support_card
def check_new_songs(artist, collection):
"""Checks if there is any new song
It compares the old discography of the artist with the new (already fetched) discography.
It tweets if there is a new release or featuring of the artist.
Args:
- artist: dictionary that contains all the data about the single artist
- collection: dictionary that contains all the updated discography of the artist
Returns:
an artist dictionary with updated discography details
"""
print("[{}] ({}) Checking new songs...".format(module, artist["name"]))
old = artist["discography"]
for album in collection:
found = False
for old_album in old:
if album["name"] == old_album["name"]:
found = True
break
if not found:
if album["type"] != 'appears_on':
twitter_post_image(
"#{} released a new {} on #Spotify: {}\n{}\n{}".format(artist["name"].upper(), album["type"], album["name"], link_album(album["id"]), hashtags),
download_image(album["image"]),
None
)
else:
twitter_post("#{} appeared on {} by {} with the song {}\n{}\n{} #spotify".format(artist["name"].upper(), album["name"], album["artist_collab"], album["tracks"][0]["name"], link_album(album["id"]), hashtags ))
artist["discography"] = collection
return artist
async def main() -> None:
utils.log.info("kiitensupport bot started")
api = await create_api()
while True:
if not "DRYRUN" in os.environ:
await asyncio.sleep(utils.next_hour(19).seconds)
else:
await asyncio.sleep(1)
try:
phrase = await get_random_message()
if not phrase:
continue
kitten_url = await get_random_kitten_image_url()
if not kitten_url:
continue
async with utils.download_image(kitten_url) as path:
new_image_path = await mememaker.create_meme_tempfile(
path, phrase)
if not new_image_path:
continue
if not "DRYRUN" in os.environ:
status = await api.update_with_media(new_image_path)
utils.log.info("Posted %s", await
utils.get_tweet_url(api, status))
else:
utils.log.debug("DRYRUN, skipping")
except TweepError as e:
utils.log.error(f"TweepError %s", e)
except Exception as e:
utils.log.error("Uncaught exception %s", e)
def main():
args = parse_args()
names_to_urls = {
'australian_bass':
'https://yaffa-cdn.s3.amazonaws.com/yaffadsp/images/dmImage/StandardImage/bass11.jpg',
'barramundi':
'https://www.abc.net.au/news/image/9320982-3x2-700x467.jpg',
'barred_cheek_coral_trout':
'https://app.fisheries.qld.gov.au/images/barred-cheek-coral-trout-2.jpg',
'giant_trevally':
'https://upload.wikimedia.org/wikipedia/commons/thumb/e/ed/Caranx_ignobilis.jpg/1200px-Caranx_ignobilis.jpg',
'diamond_scale_mullet':
'https://us.123rf.com/450wm/aozz85/aozz851708/aozz85170800005/83943872-diamond-scale-mullet-liza-vaigiensis-also-known-as-diamond-scaled-mullet-squaretail-mullet-blackfin-.jpg?ver=6',
'mahi_mahi':
'https://cdn-tp2.mozu.com/15440-22239/cms/files/7bb4f59f-02ae-4a62-a788-f985f0951012?maxWidth=960&quality=75&_mzcb=_1536869987056',
'wahoo':
'https://www.fishingcairns.com.au/wp-content/uploads/2017/05/Wahoo-e1510617727696.jpg',
}
for name, url in names_to_urls.items():
path = os.path.join(args.path, name)
if not os.path.isdir(path):
os.makedirs(path)
try:
digest, file_ext, path = download_image(url, path)
print("Downloaded", url, "to", path)
except Exception as e:
print("[INFO] error downloading %s" % url)
print(e)
def check_birthdays(group):
"""Checks if today is the birthday of a member of the group
It tweets if it is the birthday of someone
Args:
group: a dictionary with all the details of the group
Returns:
an dictionary containing all the updated data of the group
"""
now = datetime.datetime.today()
print("[{}] Today is {}".format(module, now.date()))
print("[{}] Checking...".format(module))
for member in group["members"]:
birthday = datetime.datetime.strptime(member["birthday"], '%d/%m/%Y')
difference = round((now - birthday).days / 365.25)
birthday = birthday.replace(year=now.year)
if birthday.date() == now.date():
print("[{}] ({}) Birthday: {} years!".format(
module, member["name"], difference))
if member["years"] != difference:
member["years"] = difference
twitter_post_image(
"Today is #{}'s birthday! She did {} years\n#{}bday #blackpink @BLACKPINK"
.format(member["name"].upper(), difference,
member["name"].lower()),
download_image(member["instagram"]["image"]),
str(difference))
print()
return group
def fetch_spacex(args) -> None:
mission = args.spacex_mission
try:
mission_name, images_urls = get_mission_name_and_images_urls(mission)
except Exception as e:
logger.error(
'An error is occurred, SpaceX images data cannot be retrieved: %s',
str(e))
return
if not images_urls:
logger.warning(
'Images data on the SpaceX site is empty. Try another mission.')
return
logger.info('Start downloading SpaceX.')
logger.info('%i SpaceX images found.', len(images_urls))
for i, image_url in enumerate(images_urls):
image_path = utils.get_image_path(mission_name, image_url, i)
logger.info(f'Downloading image %s.', image_url)
try:
is_downloaded = utils.download_image(image_url, image_path)
except Exception as e:
logger.error('Image %s cannot be retrieved: %s', image_path,
str(e))
continue
if is_downloaded:
logger.info('%s is fetched.', image_url)
else:
logger.warning('Skip %s.', image_url)
logger.info('SpaceX downloading is finished.')
def handler(event, context):
# Initialize Logger
log = init_logger()
log = add_handler(log)
input_data = json.loads(event['body'])
log.info(f"Input data: {input_data}")
# Retrieve inputs
input_url, n_predictions = input_data['input_url'], input_data[
'n_predictions']
# Download image
input_image = download_image(input_url)
# Process input image
log.info(f"INFO -- Processing Image")
batch = preprocess_image(input_image)
# Generate prediction
log.info(f"INFO -- Generating Prediction")
pred = prediction(input_batch=batch, mdl=mobilenet_v2)
# Top n results
log.info(f"INFO -- Generating Top n predictions")
n_results = number_output(mdl_output=pred,
mdl_labels=labels,
top_n=n_predictions)
# prediction = model.predict(url)
response = {"statusCode": 200, "body": json.dumps(n_results)}
return response
async def main():
redis = utils.redis()
reddit = await create_reddit()
twitter = await utils.create_twitter(
key=os.environ["MEMESBR_TWITTER_ACCESS_KEY"],
secret=os.environ["MEMESBR_TWITTER_ACCESS_SECRET"],
access_token=os.environ["MEMESBR_TWITTER_ACCESS_TOKEN"],
access_token_secret=os.environ["MEMESBR_TWITTER_ACCESS_TOKEN_SECRET"],
)
utils.log.info("memesbr bot started")
while True:
utils.log.info("sleeping")
await asyncio.sleep(utils.next_hour(19).total_seconds())
memeurl = await getmemeurl(redis, reddit)
if memeurl is None:
return
async with utils.download_image(memeurl) as memepath:
utils.log.debug("memepath %s", memepath)
if "DRYRUN" not in os.environ:
status = await twitter.update_with_media(memepath)
else:
utils.log.info("dryrun, skipping")
def youtube_check_videos_change(name, old_videos, new_videos, hashtags):
"""Checks if there is any new video
It compares the old videos list of the artist with the new (already fetched) videos list.
It tweets if there is a new release or if a video reaches a new views goal.
Args:
- name: name of the channel
- old_videos: list that contains all the old videos
- new_videos: list that contains all the updated videos
- hashtags: hashtags to append to the Tweet
Returns:
new_videos
"""
if old_videos is not None:
for new_video in new_videos:
found = False
for old_video in old_videos:
if new_video["url"] == old_video["url"]:
found = True
if not found:
twitter_post_image(
"{} uploaded a new #video on #YouTube: {}\n{}\n{}".format(
name, new_video["name"], url_video + new_video["url"],
hashtags),
download_image(new_video["image"]),
"NEW",
text_size=100,
crop=True)
return new_videos
def task(self):
self.session = scoped_session(SessionFactory)
images = self.session.query(LVV2Image).filter(
LVV2Image.status == "new").all()
download_count = 0
notfound_count = 0
exception_count = 0
for _image in images:
try:
status_code = download_image(
_image.url,
os.path.join(Config.Get('default.base_output'), "lvv2",
_image.date.strftime("%Y-%m-%d"),
self.get_thread_by_id(
_image.thread_id).title))
if status_code == 200:
_image.status = 'download'
self.logger.info('下载图片: {}'.format(_image.url))
download_count += 1
if status_code == 404:
_image.status = 'notfound'
notfound_count += 1
except Exception as e:
_image.status = 'exception'
_image.exception_string = str(e)
exception_count += 1
self.session.commit()
time.sleep(1)
self.logger.info('下载图片: 成功 {} 张, Not Found {} 张, 错误 {} 张'.format(
download_count, notfound_count, exception_count))
self.session.close()
def create_animal_picture_dict(tag: Tag) -> Dict[str, str]:
"""
extract from tag animal name and animal picture and update dictionary
"""
animal_name = tag.get(HtmlTags.TITLE)
animal_image_path = download_image(get_specific_animal_url(tag),
animal_name)
return {ANIMAL_NAME: animal_name, PICTURE_URL: animal_image_path}
def youtube_check_channel_change(old_channel, new_channel, hashtags):
"""Checks if there is any change in the number of subscribers or total views of the channel
It compares the old channel data with the new (already fetched) data.
Args:
- old_channel: dictionary that contains all the old data of the channel
- new_channel: dictionary that contains all the updated data of the channel
- hashtags: hashtags to add to the Tweet
Returns:
a dictionary with updated data of the channel
"""
# Tweet if subs reach a new 100 thousands
if convert_num("100K", new_channel["subs"]) != convert_num(
"100K", old_channel["subs"]):
twitter_post_image("{} reached {} subscribers on #YouTube\n{}".format(
new_channel["name"], display_num(new_channel["subs"],
decimal=True), hashtags),
download_image(new_channel["image"]),
display_num(new_channel["subs"],
short=True,
decimal=True),
text_size=150)
old_channel["subs"] = new_channel["subs"]
# Tweet if total views increase and reach a new mark (based on the views_scale)
if new_channel["views"] > old_channel["total_views"]:
if convert_num(old_channel["views_scale"],
new_channel["views"]) != convert_num(
old_channel["views_scale"],
old_channel["total_views"]):
twitter_post_image(
"{} reached {} total views on #YouTube\n{}".format(
new_channel["name"], display_num(new_channel["views"]),
hashtags), download_image(new_channel["image"]),
display_num(new_channel["views"], short=True))
old_channel["total_views"] = new_channel["views"]
old_channel["playlist"] = new_channel["playlist"]
old_channel["name"] = new_channel["name"]
old_channel["image"] = new_channel["image"]
return old_channel
def get_image_online(**kwargs):
if kwargs.get('used images'):
txt_name = kwargs.get('used images')
used_links = open(txt_name, 'r').read().splitlines()
else:
txt_name = os.path.join(os.getcwd(), "Used sankaku {0}.txt".format(
kwargs['bot name']))
try:
used_links = open(txt_name, 'r').read().splitlines()
except:
if not os.path.exists(txt_name):
print("Didn't find any used links! Creating a TXT!")
print("Set it to:\n{0}".format(txt_name))
used_links = []
else:
used_links = open(txt_name, 'r').read().splitlines()
if kwargs.get('highest page'):
high_page = int(kwargs.get('highest page'))
else:
high_page = 50
tried_pages = [high_page]
cookie_file = None
try_count = 0
low_page = 0
page = 0
x = None
no_images = False
url_start = "https://chan.sankakucomplex.com"
url_search = "https://chan.sankakucomplex.com/?tags="
if utils.is_bool(kwargs.get('login')):
cookie_file = "../sankakucomplex.txt"
url_login = "******"
form_num = 0
form_user = "******"
form_password = "******"
username = kwargs.get('username')
password = kwargs.get('password')
if not os.path.exists(cookie_file):
browser, s = utils.scrape_site(url_login, cookie_file, True)
form = browser.get_form(form_num)
form[form_user].value = username
form[form_password].value = password
browser.submit_form(form)
s.cookies.save()
if utils.is_bool(kwargs.get('save images')):
if kwargs.get('path'):
path = kwargs.get('path')
else:
path = os.path.abspath(os.path.join(os.getcwd(),
"images"))
if not os.path.exists(path):
os.makedirs(path)
else:
path = os.path.abspath(os.path.join(os.getcwd()))
if kwargs.get('tags'):
if isinstance(kwargs.get('tags'), list):
tags = '+'.join(kwargs.get('tags'))
else:
tags = '+'.join(kwargs.get('tags').split(', '))
else:
tags = ""
if kwargs.get('ignore tags'):
if isinstance(kwargs.get('ignore tags'), list):
ignore_tags = kwargs.get('ignore tags')
else:
ignore_tags = kwargs.get('ignore tags').split(', ')
else:
ignore_tags = []
if utils.is_bool(kwargs.get('ignore cosplay')):
ignore_cosplay = utils.is_bool(kwargs.get('ignore cosplay'))
else:
ignore_cosplay = False
if utils.is_bool(kwargs.get('accept webm')):
accept_webm = utils.is_bool(kwargs.get('accept webm'))
else:
accept_webm = False
tried_pages = [high_page + 1]
while True:
while True:
while True:
while True:
no_images = False
try_count += 1
if try_count == 15:
return False, False
page = str(int(random.randint(low_page, high_page) * 1))
while int(page) in tried_pages:
if int(page) == 0:
break
if not x:
x = high_page
page = str(int(
random.randint(low_page, high_page) * 1))
if int(page) > int(x):
continue
tried_pages.append(int(page))
x = min(tried_pages)
page_url = "&page=" + str(page)
url = "%s%s%s" % (url_search, tags, page_url)
browser = utils.scrape_site(url, cookie_file)
if browser.find('div', text="No matching posts"):
no_images = True
time.sleep(1)
if not no_images:
break
elif no_images and int(page) == 0:
return False, False
good_image_links = []
image_links = browser.find_all('a')
for link in image_links:
try:
link['href']
except:
continue
if "/post/show/" not in link['href']:
continue
good_image_links.append(link['href'])
if good_image_links == []:
return False, False
random.shuffle(good_image_links)
url = "%s%s" % (url_start, random.choice(good_image_links))
try_count = 0
while url in used_links:
url = "%s/%s" % (
url_start, random.choice(good_image_links))
try_count = try_count + 1
if try_count == 20:
break
used_links.append(url)
# Make a copy for better use in message
post_url = url
browser.open(url)
if not accept_webm:
if browser.find('video', attrs={'id': 'image'}):
continue
image_tags = []
char_tags = []
art_tags = []
sers_tags = []
tags_tags = []
site_tag = browser.find('ul', id="tag-sidebar")
site_tag = site_tag.find_all('li')
for taga in site_tag:
tag = tag_clean(taga)
if taga['class'][0] == "tag-type-artist":
art_tags.append(tag.title())
elif taga['class'][0] == "tag-type-copyright":
sers_tags.append(tag.title())
elif taga['class'][0] == "tag-type-character":
char_tags.append(tag.title())
else:
tags_tags.append(tag.title())
image_tags.append(tag.lower())
if any([item in [x.lower() for x in ignore_tags]
for item in [x.lower() for x in image_tags]]):
continue
if ignore_cosplay:
if any(" (cosplay)" in s for s in image_tags):
continue
break
image_url = browser.find('img', attrs={'id': 'image'})
if not image_url:
image_url = browser.find('video', attrs={'id': 'image'})
try:
url = urllib.parse.urljoin("https:", image_url['src'])
except:
# Flash File
continue
filename = ""
if not utils.is_bool(kwargs.get('message')):
message = ""
sn_kwgs = {}
sn_url, sn_kwgs = utils.saucenao(url, kwargs['saucenao api'], True)
re_dict = {'{#artist}': (
'#' if art_tags else '') + ' #'.join(
[x.replace(" ", "_") for x in art_tags]),
'{#character}': (
'#' if char_tags else '') + ' #'.join(
[x.replace(" ", "_") for x in char_tags]),
'{#series}': (
'#' if sers_tags else '') + ' #'.join(
[x.replace(" ", "_") for x in sers_tags]),
'{#tags}': (
'#' if tags_tags else '') + ' #'.join(
[x.replace(" ", "_") for x in tags_tags]),
'{artist}': ', '.join(art_tags),
'{character}': ', '.join(char_tags),
'{series}': ', '.join(sers_tags),
'{tags}': ', '.join(tags_tags),
'{url}': post_url,
'{title}': sn_kwgs.get('title'),
'{sn title}': sn_kwgs.get('title'),
'{sn illust id}': sn_kwgs.get('illust id'),
'{sn illust url}': sn_url,
'{sn artist}': sn_kwgs.get('artist'),
'{sn artist id}': sn_kwgs.get('artist id'),
'{sn artist url}': sn_kwgs.get('artist url')}
if kwargs.get('filename'):
filename = utils.replace_all(kwargs.get('filename'), re_dict)
filename = utils.safe_msg(filename)
if kwargs.get('message'):
message = utils.replace_all(kwargs.get('message'), re_dict)
message = utils.safe_msg(message)
with open(txt_name, 'w+') as f:
f.write("\n".join(used_links))
tweet_image = utils.download_image(url, path, filename, **kwargs)
if tweet_image:
break
if not utils.is_bool(kwargs.get('save images')):
from threading import Thread
Thread(name="Delete Image", target=delete_image, args=(
tweet_image, )).start()
return message, tweet_image
import sys
import os
sys.path.append('plugins/')
account_list = OrderedDict()
api_objects = OrderedDict()
__version__ = '0.1.0'
CHECK_UPDATE = True
BASE_DIR = os.path.dirname(os.path.realpath(__file__))
if os.environ.get('DEBUG') == "travis":
DEBUG = "travis"
DEBUG_ACCS = os.environ.get('ACCOUNTS', '').split("||")
# Download test image for folder testing
from utils import download_image
url = "https://www.google.co.uk/images/nav_logo231_hr.png"
download_image(url)
else:
# Local testing. Edit this for your own testing.
DEBUG = False
DEBUG_ACCS = ["test"]
def latest_ver():
import urllib.request
url = "http://ace3df.github.io/AcePictureBot/it_ver.txt"
try:
site_ver = urllib.request.urlopen(url).read().strip().decode("utf-8")
if site_ver != __version__:
print("!WARNING! A new version is out ({0})!".format(site_ver))
print("Download it here: http://bombch.us/BWVH")
print("----------------------------------------\n")
def get_reddit(**kwargs):
if kwargs.get('used images'):
txt_name = kwargs.get('used images')
used_links = open(txt_name, 'r').read().splitlines()
else:
txt_name = os.path.join(os.getcwd(), "Used reddit {0}.txt".format(
kwargs['bot name']))
try:
used_links = open(txt_name, 'r').read().splitlines()
except:
if not os.path.exists(txt_name):
print("Didn't find any used links! Creating a TXT!")
print("Set it to:\n{0}".format(txt_name))
used_links = []
else:
used_links = open(txt_name, 'r').read().splitlines()
try:
sub = used_links[0]
used_links = used_links[1:]
except:
# Probably doesn't exist (i hope only that)
pass
if kwargs.get('save images'):
if kwargs.get('path'):
path = kwargs.get('path')
else:
path = os.path.abspath(os.path.join(os.getcwd(),
"images"))
if not os.path.exists(path):
os.makedirs(path)
else:
path = os.path.abspath(os.path.join(os.getcwd()))
start_url = "https://www.reddit.com/r/"
subreddits = kwargs.get('subreddits')
is_random = kwargs.get('random subreddit')
is_random_link = kwargs.get('random link')
if subreddits is None:
return False, False
if isinstance(subreddits, str):
subreddits = subreddits.split(", ")
if utils.is_bool(is_random):
import random
sub = random.choice(subreddits)
else:
# Get last used sub and + 1
try:
sub = open(os.path.join(os.getcwd(), "Used reddit {0}.txt".format(
kwargs['bot name'])),
'r').read().splitlines
sub = subreddits[(subreddits.index(sub) + 1)]
except:
# Doesn't exsist / end of list
sub = subreddits[0]
url = start_url + sub + "/.rss"
soup = utils.scrape_site(url, is_rss=True)
pic_imgs = []
for a in soup.find_all('item'):
img_string = a.find('description').string
img_title = a.find('title').string
img_link = a.find('link').string
img_string = img_string[:img_string.index("[link]")]
img_string = BeautifulSoup(img_string, 'html5lib').find_all('a')
for item in img_string:
if "reddit.com" not in item['href'] and "http" in item['href']:
pic_imgs.append([item['href'], img_title, img_link])
if utils.is_bool(is_random_link):
import random
image = random.choice(pic_imgs)
else:
image = pic_imgs[0]
safe_break = 0
count = 0
while image[0] in used_links:
if utils.is_bool(is_random_link):
image = random.choice(pic_imgs)
else:
image = pic_imgs[count]
if image[0] in used_links:
count += 1
continue
break
safe_break += 1
if safe_break == 50:
break
used_links.append(image[0])
imgTypes = {"jpg": "image/jpeg",
"jpeg": "image/jpeg",
"png": "image/png",
"gif": "image/gif",
"webm": "video/webm"}
filepath = urlparse(image[0]).path
ext = os.path.splitext(filepath)[1].lower()
if not ext[ext.rfind(".") + 1:] in imgTypes:
if "imgur" in image[0]:
# Just make it .png it still returns correct image
image[0] = "http://i.imgur.com/" + image[0].rsplit(
'/', 1)[1] + ".png"
ext = ".png"
sn_kwgs = {}
if "(x-post" in image[1].lower() or "(via" in image[1].lower():
image[1] = re.sub(r'\([^)]*\)', '', image[1])
if "sn" in kwargs.get('message'):
sn_url, sn_kwgs = utils.saucenao(fname=image[0],
api_key=kwargs.get('saucenao api'),
metainfo=True)
re_dict = {'{url}': image[2],
'{title}': image[1],
'{sn title}': sn_kwgs.get('title'),
'{sn illust id}': sn_kwgs.get('illust id'),
'{sn illust url}': sn_url,
'{sn artist}': sn_kwgs.get('artist'),
'{sn artist id}': sn_kwgs.get('artist id'),
'{sn artist url}': sn_kwgs.get('artist url')}
if kwargs.get('filename'):
filename = utils.replace_all(kwargs.get('filename'), re_dict)
filename = utils.safe_msg(filename)
else:
filename = ""
if kwargs.get('message'):
message = utils.replace_all(kwargs.get('message'), re_dict)
message = utils.safe_msg(message)
else:
message = ""
image = utils.download_image(image[0], path, filename, **kwargs)
used_links = [sub] + used_links
with open(txt_name, 'w') as f:
f.write("\n".join(used_links))
return message, image