You can quickly watch videos with a few mouse clicks, but downloading videos is difficult. But in a recent upgrade, YouTube now allows you to save videos in its download folder for offline viewing. Still, you are unable to save them locally.

In this tutorial, you will learn how to use Python code to download YouTube videos. As you may know, one of Python's great strengths is its huge number of modules and libraries. We will write the Python script using the popular pytube package.

Prerequisites

Below are the basic requirements to proceed with this tutorial:

• Understanding of the Python Programming language
• You must have Python 3+ installed on your computer
• You must have installed the Python library Pytube
• You should have a Python code editor such as Pycharm, Vscode, and so on.

Pytube Overview and Installation

Pytube is a small, dependency-free Python module for accessing videos from the internet.

The native library is not pytube – you must first install it to be able to use it. When you have pip, installation is simple.

To install Pytube using pip, you will need to open your command prompt CLI as an administrator and enter the following command:

pip install pytube

The pytube library improves video downloads. Build the YouTube module's object by supplying the URL as a parameter. Then, obtain the video's proper extension and resolution. You can change the name of the file at your leisure – otherwise, the original name will be retained.

Now let's get to the main aspect of writing and implementing the code to download our favorite videos from YouTube.

from pytube import YouTube

def Download(link):
    youtubeObject = YouTube(link)
    youtubeObject = youtubeObject.streams.get_highest_resolution()
    try:
        youtubeObject.download()
    except:
        print("An error has occurred")
    print("Download is completed successfully")


link = input("Enter the YouTube video URL: ")
Download(link)

You use the from pytube import YouTube function to import the Python Pytube library before continuing with the other aspects. Then you define the function download link.

The youtubeObject = youtubeObject.streams.get_highest_resolution() command will automatically download the highest resolution available.
Then I implemented the Try and Except to return an error message if the download fails – else it will print out that the download is completed successfully.

The Link function will ask for the preferred YouTube video link to download, then immediately after you hit the enter button, the video downloading will commence.

The Output:

The video I downloaded was successful. You can see the video in the same Python folder where the file you are working on is located. But if you wish, you can then move the video to your preferred storage location. In my case the video name is "Ronaldo celebrates with Antony.mp4."

However, it would be preferable if you had a reliable internet connection.

This library also has numerous sophisticated features, but we have covered all of the major ones. You can learn more about the pytube library by visiting its official well-written documentation.

Conclusion

We have successfully built a YouTube video downloader script of our own in Python. This helps you avoid the stress of looking for an external website or application to get your preferred video to your local storage.

It also saves you from having to expose your data on a third-party website or phishing link – all in the name of getting a video from YouTube to your local storage.

Hopefully after going through this article, you will understand the process required to download videos from YouTube without the need to download an external application or visit any website you don't trust.

Over the past few months, I've found a new use for the pictures that I've taken while hiking. I started using them as Zoom virtual backgrounds.

If you are anything like me and take a lot of pictures, it can be hard to decide which one looks good. And then I decided to use them all, on different days.

Sadly, Zoom does not have this as a built-in feature. So being a Software developer, I had to automate the process of choosing a random Zoom virtual background every day.

What does the script do?

Zoom does have an API that I could have used to change my background every day – but that seemed like too much effort for this task. Software developers are born lazy, right? :)

Instead, I found out that the Zoom application creates a copy of the background that gets selected in its preferences folder and references it. The script just takes in a random file and replaces it with this background file. And voila! A different Zoom virtual background is shown.

You can then put this in a cron job to be executed every day (or any frequency you prefer) to periodically change the background.

Get Set Up

I have put all the images I want to use as backgrounds in a folder in my user directory. Mine is at /zoom/bgpictures/, and that is what I use in the script. But it is a variable that you can change to whatever you want it to be.

Next, we set a Zoom virtual background in our application. It does not matter which background you choose. All we need is the unique ID that Zoom will assign to this background.

There might be some files already in the directory, but we want to select the one that corresponds to the image that we just uploaded to avoid replacing a different file.

The directory is located at: ~/Library/Application Support/zoom.us/data/VirtualBkgnd_Custom. The file name will be something like: 9WAE197F-90G2-4EL2-9M1F-AP784B4C2FAD

How to Write the Script

We will be using a bash script to replace the image we just used. I will be putting this scrip in the Zoom folder that I created for the background images. Again, it can be named whatever you like – I am naming mine ~/zoom/zoombg.sh.

The script is as follows:

#!/bin/bash
# The name of file that we copied before and will be replaced with
OG_BG="9WAE197F-90G2-4EL2-9M1F-AP784B4C2FAD";

# Directory where Zoom keeps the backgrounds
ZOOM_DIR="/Users/$USER/Library/Application Support/zoom.us/data/VirtualBkgnd_Custom/";

# Directory of our images
BGPATH="/Users/$USER/zoom/bgpictures/";

# Picking a random file
NEW_BG=$(find "$BGPATH" -type f | sort -R | head -1);

# Replacing the file
cp -R "$NEW_BG" "$ZOOM_DIR/$OG_BG";

If you choose different paths for the directory, just make sure to change that in the variable. We need to make this script executable by running the command:

chmod 755 ~/zoom/zoombg.sh

How to Change Your Zoom Background Randomly

The script is ready. All we need to do is put it in a cron job which is a built-in time-based job scheduler. We need to decide a schedule for how frequently we want to change the Zoom virtual background. I do mine at 9:55 AM every day since my meetings start at 10 AM.

If you are new to cron jobs, you can use the generator to help you. I use:

55 9 * * 1-5 /Users/saranshkataria/zoom/zoombg.sh > /dev/null 2>&1

The first part (55 9 1–5) is what you will need to customize according to your schedule. The second part is just telling the OS what to do at that point in time. You'll need to update the path if you chose a different location for the bash script.

To put it in a cron job, type:

crontab -e

and it will open up an editor using vi. Hit the I key on the keyboard to enter insert mode, paste in the line, and press Escape followed by “:wq” and enter to save and quit.

That is all there is to it! Now you'll have a random Zoom virtual background every day (or however often you choose).

If you are using Windows, you can modify the script accordingly and it should be fairly straightforward to use.

If you have any questions, feel free to reach out to me.

Read more of my posts at: https://www.wisdomgeek.com

The problem with that solution was that I had SES save new messages to an S3 bucket, and using the AWS Management Console to read files within S3 buckets gets stale really fast.

So I decided to write a Bash script to automate the process of downloading, properly storing, and viewing new messages.

While I wrote this script for use on my Ubuntu Linux desktop, it wouldn't require too much fiddling to make it work on a macOS or Windows 10 system through Windows SubSystem for Linux.

Here's the complete script all in one piece. After you take a few moments to look it over, I'll walk you through it one step at a time.

#!/bin/bash
# Retrieve new messages from S3 and save to tmpemails/ directory:
aws s3 cp \
   --recursive \
   s3://bucket-name/ \
   /home/david/s3-emails/tmpemails/  \
   --profile myaccount

# Set location variables:
tmp_file_location=/home/david/s3-emails/tmpemails/*
base_location=/home/david/s3-emails/emails/

# Create new directory to store today's messages:
today=$(date +"%m_%d_%Y")
[[ -d ${base_location}/"$today" ]] || mkdir ${base_location}/"$today"

# Give the message files readable names:
for FILE in $tmp_file_location
do
   mv $FILE ${base_location}/${today}/email$(rand)
done

# Open new files in Gedit:
for NEWFILE in ${base_location}/${today}/*
do
   gedit $NEWFILE
done

We'll begin with the single command to download any messages currently residing in my S3 bucket (by the way, I've changed the names of the bucket and other filesystem and authentication details to protect my privacy).

aws s3 cp \
   --recursive \
   s3://bucket-name/ \
   /home/david/s3-emails/tmpemails/  \
   --profile myaccount

Of course, this will only work if you've already installed and configured the AWS CLI for your local system. Now's the time to do that if you haven't already.

The cp command stands for "copy," --recursive tells the CLI to apply the operation even to multiple objects, s3://bucket-name points to my bucket (your bucket name will obviously be different), the /home/david... line is the absolute filesystem address to which I'd like the messages copied, and the --profile argument tells the CLI which of my multiple AWS accounts I'm referring to.

The next section sets two variables that will make it much easier for me to specify filesystem locations through the rest of the script.

tmp_file_location=/home/david/s3-emails/tmpemails/*
base_location=/home/david/s3-emails/emails/

Note how the value of the _tmp_filelocation variable ends with an asterisk. That's because I want to refer to the files within that directory, rather than the directory itself.

I'll create a new permanent directory within the .../emails/ hierarchy to make it easier for me to find messages later. The name of this new directory will be the current date.

today=$(date +"%m_%d_%Y")
[[ -d ${base_location}/"$today" ]] || mkdir ${base_location}/"$today"

I first create a new shell variable named today that will be populated by the output of the date +"%m%d%Y" command. date itself outputs the full date/timestamp, but what follows ("%m%d%Y") edits that output to a simpler and more readable format.

I then test for the existence of a directly using that name - which would indicate that I've already received emails on that day and, therefore, there's no need to recreate the directory. If such a directory does not exist (||), then mkdir will create it for me. If you don't run this test, your command could return annoying error messages.

Since Amazon SES gives ugly and unreadable names to each of the messages it drops into my S3 bucket, I'll now dynamically rename them while, at the same time, moving them over to their new home (in the dated directory I just created).

for FILE in $tmp_file_location
do
   mv $FILE ${base_location}/${today}/email$(rand)
done

The for...do...done loop will read each of the files in the directory represented by the _$tmp_filelocation variable and then move it to the directory I just created (represented by the _$baselocation variable in addition to the current value of $today).

As part of the same operation, I'll give it its new name, the string "email" followed by a random number generated by the rand command. You may need to install a random number generator: that'll be apt install rand on Ubuntu.

An earlier version of the script created names differentiated by shorter, sequential numbers that were incremented using a count=1...count=$((count+1)) logic within the for loop. That worked fine as long as I didn't happen to receive more than one batch of messages on the same day. If I did, then the new messages would overwrite older files in that day's directory.

I guess it's mathematically possible that my rand command could assign overlapping numbers to two files but, given that the default range rand uses is between 1 and 32,576, that's a risk I'm willing to take.

At this point, there should be files in the new directory with names like email3039, email25343, etc. for each of the new messages I was sent.

Running the tree command on my own system shows me that five messages were saved to my 02_27_2020 directory, and one more to 02_28_2020 (these files were generated using the older version of my script, so they're numbered sequentially).

There are currently no files in tmpemails - that's because the mv command moves files to their new location, leaving nothing behind.

$ tree
.
├── emails
│   ├── 02_27_2020
│   │   ├── email1
│   │   ├── email2
│   │   ├── email3
│   │   ├── email4
│   │   ├── email5
│   └── 02_28_2020
│       └── email1
└── tmpemails

The final section of the script opens each new message in my favorite desktop text editor (Gedit). It uses a similar for...do...done loop, this time reading the names of each file in the new directory (referenced using the "today" command) and then opening the file in Gedit. Note the asterisk I added to the end of the directory location.

for NEWFILE in ${base_location}/${today}/*
do
   gedit $NEWFILE
done

There's still one more thing to do. If I don't clean out my S3 bucket, it'll download all the accumulated messages each time I run the script. That'll make it progressively harder to manage.

So, after successfully downloading my new messages, I run this short script to delete all the files in the bucket:

#!/bin/bash
# Delete all existing emails 

aws s3 rm --recursive s3://bucket-name/ --profile myaccount

Let software tooling check the consistency of your roleplay scripts for you!

(French version of this article available here on Electro-GN)

Issue

Every writer will confirm it to you: it is not easy to remain coherent when you are working, for several months, on a long story. It is even less so when the story in question is lived by dozens of characters, each with their own partial vision of the truth. And live action roleplay games (LARPs) are especially exposed to this problem.

The danger does not lie in the first draft of the writing: if he has all his ideas well in place, the author does not risk much, except for a few typos and interchanges of names. It is during subsequent modifications (changes in the chronology of facts, additions of twists and turns, etc.) that the information — disseminated and duplicated in the documents of the various participants — will gradually become obsolete and inconsistent. Eventually, even the character sheets of a common “murder&mystery party” will end up full of spatial, temporal, lexical and structural improbabilities if they are not rigorously checked and compared after each evolution of the scenario.

What can we do to prevent this, without spending a lifetime doing comparative proofreading? First, undoubtedly, deduplicate texts common to several players, which lead to tedious copy and paste (multiplying errors and artificially inflating the mass of the text). Then, allow the author to review the interdependent sets of changes he has successively applied to his scenario. Finally, give him summaries of key information, easier to review than verbose literary texts. And all this in as automated a way as possible, because the number of documents to be managed can make the smallest operation very time-consuming (and at risk of carelessness).

The benefits of Pychronia Tools machinery

To benefit from these precious writing facilities during the creation of the Chrysalis:Mindstorm mystery party (French only), I set up a specific writing process, involving simple text files (which contain the scenario), various existing software tools, as well as a module “Pychronia Tools” developed for the occasion.

Once this machinery is in place, all you have to do is start it up and — magic — a hundred PDF files appear one after the other in the output folder: game master’s manual, complete and summarized character sheets for players, documents to print on beautiful scrolls to serve as clues in play, summary sheets for extras….

This tool is much more than a simple document generator: it includes an automatic check of the script consistency. Now, if an index is mentioned in one place but not provided in another, or if the same symbol has different values from one file to another, the error is reported.

Extract of consistency errors returned by the program:

!!! ERROR IN hints registry for key golden_box_with_blood : [‘needed’] requires a provided hint
!!! ERROR IN symbols registry for key murder_date : [‘3 January 2018′,’15 March 2018']

And thanks to the automatically generated summary tables, it is possible to check at a glance that each player is well informed of the facts concerning him/her, that the distribution of key information is more or less balanced, and that major events are correctly recorded in summary sheets.

Extract from the automatic summary of the “facts” of the scenario:

Character names are in italics when they have the “fact” in question only in their complete character sheet, not in their summary sheet.

As a result, the game master can rely quietly on his own (self-generated) documents to set up and monitor the game: detailed scenario, evening planning, checklist of materials and writings to be placed in the premises, automatic summary of missions and special skills of each player…

On top of that, this machine can also send its game documents, by email, to each player (e.g. character card and documents initially owned). This avoids the drama that awaits each organizer: spoiling a participant by sending him the wrong documents.

This system obviously adds a certain complexity to the project, compared to some common Word/LibreOffice files. But it provides invaluable support in terms of scenario scalability and robustness, detecting inconsistencies and automating daunting tasks. Personally, he saved me more than once, when I switched the names of some characters in cards, or forgot to warn some players of the new misdeeds they were supposed to have committed in the past.

How to set up such a process?

Step 1: Move away from rich office files (docx, odt, pdf…) to a plain text format, easily manipulable, where the formatting is explicitly indicated by special characters. The documents in game with high graphic and typographical needs (posters, scrolls, newspapers…) can be left aside, in more usual office automation files: Word, LibreOffice, InDesign…

Example of plain text (restructuredtext format):

Manuel du Maître de Jeu
############################

.. contents:: Table des Matières
    :depth: 2

Concept de la soirée mystère
================================

**Chrysalis:Mindstorm** est un huis clos entre `enquête 
<https://fr.wikipedia.org/wiki/Enqu%C3%AAte>`_ criminelle et conflit
géopolitique, où des agents secrets et des civils de divers pays se 
retrouvent face à un *redoutable* inspecteur de police, qui va les 
pousser dans leurs derniers retranchements.

Rendering of this text once converted to PDF:

Step 2: Use a version manager for scenario files. This makes it possible to go back in time at any time, to avoid horrifying accidental file modifications, and to check the consistency of each of the changes made (renaming a place, adding information for a group of players…).

Viewing a change made to the rules of the game:

Step 3: Add a small processing engine, to enrich the text with simple and practical features: allow one file to include another, define reusable text blocks, insert variables (e. g. the date of a crucial event, different for each session of the mystery evening), display different information according to the team to which the targeted player belongs….

Step 4: Automate consistency checks. To do this, I created specific tags in the processing engine, which I then inserted as I wrote:
 — The {% fact %} tag is used to announce a fact (e. g. “so-and-so tried to rob Loyd Georges”), and to indicate whether the player is the author or just a witness.
 — The {% hint %} tag allows you to request the existence of a physical clue (letter, object…) to give to the player.
 — The {% symbol %} tag ensures that a value is unique in all scenario files (e. g. the exact time of a crime), while avoiding the use of “variables” that obscure the text.

Example of using special tags to enrich a scenario text:

To the attention of {{agent_gamma_fake_name }} : the country of {% symbol “Balberith” for “first_country_at_war” %} has entered the war, following the plot led by agent Epsilon {% fact “agent_epsilon_triggered_war” as author %}. You have a testimony signed by him and attesting to it. {% hint “epsilon_signed_testimony_for_agent_gamma” is needed %}.

As we can see, these tags each have their own syntax, and can use other features of the processing engine, such as variables (of which we have an example with _{{agent_gamma_fakename }}).

Step 5: Link all this with scripts, which will automate the different steps of creating game documents: gathering useful data (including player photos), distributing scenario pages for each participant (global context, personal context, game rules…), transforming them into PDF format, and generating summary sheets for the game master.

Some of the PDF documents generated, next to their plain text sources:

The future

All this is all well and good, but what about the rest of the role-playing community? Can it benefit, more broadly, from the functionalities offered by this scriptwriting support system?

The answer is yes. However, as seen in the steps above, this tooling requires a certain affinity with processes that are usually reserved for computer development; an affinity that many GN authors do not have.

I am therefore listening to authors tempted by the experience, in order to see with them how they work, what formats and tools they are able to use, and how this system could be generalized to suit their use. I could then see to extract this code (which is currently strongly linked to the structure of the Chrysalis game files), to make it more autonomous and more easily deployable.

Note that software such as Twine already allows scenarios to be created in a fairly simple way, with a mini-language to define variables and use logical operations. Pychronia Tools machinery therefore only makes sense for the very high level of integration it offers, with its automated consistency checks and end-to-end generation scripts.

Interested in this scriptwriting support system? Feel free to contact me using the information on the Chrysalis Website.

Appendix : Details for computer literate people

My machinery is based on the Python language and its document manipulation/creation ecosystem.

As for the “plain text” format of the scenario, many “markup languages” can be used for this purpose: restructuredtext, markdown, textile, latex, or even html… I chose restructuredtext for its clarity, versatility, and its advanced integration with the Python language. To edit these text files, of course, Pycharm, Notepad++, Geany, or a simple notebook can do the trick.

For the version manager (or “VCS”), I chose Git and its excellent TortoiseGit graphical interface (available under Windows only unfortunately). Mercurial, Bazaar, DARCS, or others are just as relevant. At a minimum, we can use the versioned file backup proposed by Dropbox et al., even if it offers only a few features to visualize the differences between several writing steps…

Visualization, via GIT, of the sets of modifications made to the scenario:

Regarding the template engine used to process text files (and for specific tags), finally, I have integrated the powerful Jinja2, which allows you to create variables and macros directly in the templates. The data handled by this engine comes, in my case, from a tree structure of Yaml files, but many other sources (python file, csv, xml…) are very easily integrated.