download_images | Download images - | Download Utils library

You make the very rookie mistake of not calling close / closing the file (ZipFile here) after opening it, best use the ZipFile as a context manager:

I think you should check getting the variable image_link. Failed to parse: http://data:image/jpeg;base64,/9j/ and etc... - this error describe prompt to us that something wrong with our url

With Selenium:

1. Click an image from search results.

2. Wait until the image is visible.

3. image_link = driver.find_element_by_css_selector(".tvh9oe.BIB1wf .eHAdSb>img").get_attribute("src")

You can use the same locator for bs4

Sometimes (when you're unlucky) as your pool is spinning up, one of the child processes will be "fork"ed while your downloader thread is writing a message to the logging module. The logging module uses a queue protected by a lock in order to pass messages around, so when "fork" happens, that lock can get copied in the locked state. Then when the download thread is done writing its message to the queue, only the lock on the main process gets released, so you're left with a subprocess waiting on the copy of that lock to write a message to logging. That lock can never be released because the downloader thread does not get copied (fork doesn't copy threads). This is the deadlock that occurs. This type of error can be patched in some ways, but is one of the reasons "spawn" exists.

Additionally, "spawn" is the only method supported by all architectures. It is just so easy to use a library that happens to be multithreaded under the hood without realizing it, and "fork" just isn't real multi-threading friendly. I don't have much knowledge of "forkserver" in case you really do need the reduced overhead afforded by "fork". In theory it is a little more multi-threading safe.

fork

The parent process uses os.fork() to fork the Python interpreter. The child process, when it begins, is effectively identical to the parent process. All resources of the parent are inherited by the child process. Note that safely forking a multithreaded process is problematic.

Here's a more in-depth discussion with a few references on this problem which I used as my primary resource

• tfds.load is a utility method of tensorflow using which you download a predefined set of datasets. The advantage of using this method is that it returns the data in tf.data.Dataset which can be directly used for training the model. It also returns a second value of type tfds.core.DatasetInfo which contains the information about the dataset.
• urllib.request.urlretrieve is the python module to download the data from a url. So you will have to download a dataset hosted on a url, understand its format and convert it into the format so that it can be used for training a model or doing inference.
• If your intension is to train an inception model in tensorflow then its meaning full use tfds.load to download the data and use the tensorflow dataset to train it.
• However, if your dataset is not available as part of tfds.load named datasets, then you will have to download the data and convert it into the required format and one way of doing it is using urllib

Your download_file function catches the timeout error and re-raises it. Your download_files function uses asyncio.gather() which exits on first exception and propagates it to the caller. It is reasonable to assume that, when downloading a large number of files, sooner or later one of them times out, in which case your whole program gets interrupted.

What should I do?

That depends on what you want your program to do in case of a timeout. For example, you might want to retry that file, or you might want to give up. But you most likely don't want to interrupt the whole download because of a single file that has timed out.

While re-raising an exception you've caught is in many cases the right thing to do, it is not the right thing here. You can change raise at the end of download_file to return (remote_url, filename) which will result in gather() returning a list of failed downloads and you can try to download them again.

However, converting from drawings to png is not possible directly, you need to perform the following steps:

• Create an export link for exporting the file as image/png
• Fetch this link with the UrlFetchApp
• Create a file from the blob of the result

Sample

At first do removing the ppt.write(out); from your code. That writes the whole XMLSlideShow ppt into the FileOutputStream out for each the single ppt_image_*.jpg. That is useless and only adds unnecessary bytes to each of the ppt_image_*.jpg files.

If then the size is not small enough, you could use java.awt.geom.AffineTransform to set a zoom scaling factor and then set that transform to the used Graphics2D.