Ubuntu – Change dynamic wallpaper directory every season

scriptswallpaper

I want to have my wallpaper be seasonal (summer, fall, winter, spring), but also update daily with a seasonal themed wallpaper.

So essentially, I am thinking of having 4 directories (summer, fall, winter, spring). During summer, my wallpaper background would rotate through the images in the summer directory on a daily basis. Then on Sept. 21, the wallpaper directory would change to fall, and the wallpaper would then cycle through those images on a daily basis, etc.

I am comfortable writing a script, but where would I start?

How this question is unique

Edit: To clarify further about what makes this question unique. While there are many methods to create a slideshow, they all depend on setting the images directory. What I am asking is how to dynamically change the images directory. So slide show today comes out of the /images/winter/ directory, and slide show in spring comes out of the /images/spring/ directory. I could manually do this by just changing the directory in the appearance settings every season, but I don't want to have to that when I can tell the computer to do it for me.

Best Answer

The basic question is how to do something at the start of Spring, Summer, Fall and Winter. For this I would create a bash script that runs on boot, rather than clogging up cron with entries.

I've approached this answer using the OP's question "How do I develop a script?". So I've deviated from usual method of simply posting a bash script and enhanced the answer with:

References are included within the code. They link to Stack Exchange answers for solving specific problems. For example: How to copy files, How to get day of year, etc.
A section on "Testing" is provided as it is something we all need to do
A section on "Enhancements" is provided because software is usually developed in versions where each is incrementally better than the previous version.

When do seasons start?

From the Farmer's Almanac:

Seasons of 2018

 Season     Astronomical Start                     Meteorological Start
 ======     =====================================  =====================
 SPRING     Tuesday, March 20, 12:15 P.M. EDT      Thursday, March 1 
 SUMMER     Thursday, June 21, 6:07 A.M. EDT       Friday, June 1
 FALL       Saturday, September 22, 9:54 P.M. EDT  Saturday, September 1
 WINTER     Friday, December 21, 5:23 P.M. EST     Saturday, December 1

Convert season start date to Day of Year

For our bash script to work we need to know what day of the year each seasons start.

$ echo $(date --date="March 20" '+%j')
079
$ echo $(date --date="June 21" '+%j')
172
$ echo $(date --date="Sep 22" '+%j')
265
$ echo $(date --date="Dec 21" '+%j')
355
# Reference: https://unix.stackexchange.com/questions/352176/take-input-arguments-and-pass-them-to-date

Create bash script: `season.sh`

Open the terminal using: Ctrl+Alt+T

Create the directory if it doesn't exist: mkdir -p ~/bin

Edit the script using: gedit ~/bin/season.sh

Note: Lubuntu user's need to use leafpad instead of gedit

Copy and paste the following lines into gedit:

#!/bin/bash
# NAME: season.sh
# PATH: ~/bin
# DATE: December 15, 2018

# NOTE: Written for: https://askubuntu.com/questions/1100934/change-dynamic-wallpaper-directory-every-season/1102084#1102084

# User defined variables, change to suit your needs
# Our directory names, lines indented for cosmetic reasons only
SlideShowDir="~/Season Slide Show"
   SpringDir="~/Pictures/Spring Slide Show"
   SummerDir="~/Pictures/Summer Slide Show"
     FallDir="~/Pictures/Fall Slide Show"
   WinterDir="~/Pictures/Winter Slide Show"

CheckTripWire () {
    # Our last season is in "~/Season Slide Show/CurrentSeason"
    LastSeasonFilename="$SlideShowDir"/CurrentSeason
    LastSeason=$(cat "$LastSeasonFilename")

    [[ "$LastSeason" == "$Season" ]] && return 0 # Season still the same

    # We now know our season has changed.

    rm -f "$SlideShowDir"/{*,.*}           # Erase all files in target
    # Reference: https://askubuntu.com/questions/60228/how-to-remove-all-files-from-a-directory

    echo "$Season" > "$LastSeasonFilename" # Record new season in target

    # Copy new slide show based on season
    if (( "$Season" == SPRING)) ; then
        cp -R "$SpringDir"/. "$SlideShowDir"/
        # Reference: https://stackoverflow.com/questions/3643848/copy-files-from-one-directory-into-an-existing-directory
    elif (( "$Season" == SUMMER)) ; then
        cp -R "$SummerDir"/. "$SlideShowDir"/
    elif (( "$Season" == FALL)) ; then
        cp -R "$FallDir"/. "$SlideShowDir"/
    else
        cp -R "$WinterDir"/. "$SlideShowDir"/
    fi

} # End of CheckTripWire () function.

# Start of Mainline

DOY=$(date '+%j')                     # DOY = Current Day of Year
# Reference: https://stackoverflow.com/questions/10112453/how-to-get-day-of-the-year-in-shell

if ((DOY>=079 && DOY<172)) ; then
    Season="SPRING"                   # Spring has sprung!
    # Reference: https://stackoverflow.com/questions/12614011/using-case-for-a-range-of-numbers-in-bash
elif ((DOY>=172 && DOY<265)) ; then
    Season="SUMMER"                   # Hit the beach!
elif ((DOY>=265 && DOY<355)) ; then
    Season="FALL"                     # Rake those leaves!
else
    Season="WINTER"                   # Shovel the snow!
fi

# Current season establish, now see if we tripped the wire
CheckTripWire

exit 0 # Command not necessary but good habit to signify no Abend.

Save the file in gedit. Now mark it as executable using:

chmod a+x ~/bin/season.sh

Next we need to add it to startup applications. Reference: How do I start applications automatically on login?

Note: You probably already have your slide show setup in startup applications. You will want to use season.sh BEFORE your regular slide show as it deletes and copies files which would crash the slide show program if it started first.

Testing

You will want to test season.sh script when you create it and not wait a year to see if it works properly or not. Reference: https://serverfault.com/questions/138325/faking-the-date-for-a-specific-shell-session

Enhancements

After initially developing a script it is common to enhance it Days, Weeks, Months or even Years later. This section discusses some enhancements you might want to make to session.sh down the road.

Compress files to save disk space

Consider keeping the off-season images compressed in TAR (Tape Archive) format to save on disk space. Then replace the cp (Copy) command with the tar command to un-compress the files. Reference: https://www.rootusers.com/23-tar-command-examples-for-linux/:

For example, we would change:

cp -R "$SpringDir"/. "$SlideShowDir"/

To:

tar -xf "$SpringDir"archive.tar -C "$SlideShowDir"/

... and so on for the other seasons.

Setup variables for season start

Using variables for season start days makes it easier to modify the script and makes the code easier to read (aka code readability).

Consider setting up Variables for start of season:

SpringStart=079
SummerStart=179
FallStart=265
WinterStart=355

Define the variables at the top of the script to make them easier to spot and change. You might want to do this for leap years. You might want to change to "Meteorological" season starts instead of "Astronomical" start dates.

Then change these lines:

if ((DOY>=079 && DOY<172)) ; then
elif ((DOY>=172 && DOY<265)) ; then
elif ((DOY>=265 && DOY<355)) ; then

To this:

if ((DOY>="$SpringStart" && DOY<"$SummerStart")) ; then
elif ((DOY>="$SummerStart" && DOY<"$FallStart")) ; then
elif ((DOY>="$FallStart" && DOY<"$WinterStart")) ; then

NOTE: I was hoping to finish this answer in an hour but it's been two hours and I have to do some Saturday Shopping. To Be Continued...

Change wallpapers according day & night as simple as it gets

Assuming the night begins somewhere after 12:00 am and ends after midnight 24:00, usage of the script below is as simple as it gets:

Run it in the background with the command:

python3 <script> <begin_of_evening> <end_of_night>

for example:

python3 /path/to/wallpaper_shift.py 19:00 6:00

During the day shift, set the wallpaper as you like. The script remembers your choice on the next day shift.
Likewise, during night shift, set your preferred wallpaper for the night. Again, the script remembers.

That's all. Now the wallpaper will switch according the moments of the day you set, running the script.

If the script is stopped

The script remembers the set wallpapers in a hidden file: ~/.wallset. WHen the script is (re-) started, it first tries to read the set wallpapers from the file. if it does not exist, it creates a new file, using the currently set wallpaper for both day- and night shift, until you change either one (or both).

Processor load zero

When the script is started, it calculates:

the current time of the day
the time span of night- and day shift
the time span from the current time of the day until the first switch
the current term (either day or night)

After that, between the wallpaper switches, the script only sleeps

what the script does

The script

#!/usr/bin/env python3
import subprocess
import os
import sys
import time

def write_walls(prefsfile, walls):
    # write new set of wallpapers to prefsfile
    open(prefsfile, "wt").write(("\n").join(walls))

def set_wall(wall):
    # set the wallapaper
    new = wall.replace("night:", "").replace("day:", "")
    command = "gsettings set org.gnome.desktop.background picture-uri "+\
              new
    subprocess.Popen(["/bin/bash", "-c", command])

def get_currwal():
    # get the current wallpaper
    return subprocess.check_output([
        "/bin/bash", "-c",
        "gsettings get org.gnome.desktop.background picture-uri"
        ]).decode("utf-8").strip()

def produce_setwalls(prefsfile):
    # on startup of the script, try to read the set wallapapers
    # or take the currently set on first run
    try:
        return open(prefsfile).read().splitlines()
    except FileNotFoundError:
        currwall = get_currwal()
        newwalls = ["night:"+currwall, "day:"+currwall]
        write_walls(prefsfile, newwalls)
        return newwalls

def convert_tosecs(t):
    # convert time of the day (hrs/mins) to seconds
    t = [int(n) for n in t.split(":")]
    return (3600*t[0])+(60*t[1])

# --- set constants
day_period = 24*3600
prefsfile = os.environ["HOME"]+"/.wallset"
# ---

# --- define time- shifts
curr_t = convert_tosecs(time.strftime("%H:%M"))
t1 = convert_tosecs(sys.argv[1])
t2 = convert_tosecs(sys.argv[2])
# ---

# --- define start- data
if any([curr_t > t1, curr_t < t2]):
    curr_term = "night"
    first_period = 86400 - curr_t + t2
else: 
    curr_term = "day"
    first_period = t1 - curr_t
# ---

# --- define time spans
night_shift = 86400 - t1 + t2
day_shift = 86400 - night_shift
# ---

# run first term, set wallpaper according (possible) settings
set_wallpapers = produce_setwalls(prefsfile)
to_set = [wall for wall in set_wallpapers if curr_term in wall][0]
set_wall(to_set)
time.sleep(first_period)

# then start loop
while True:
    if curr_term == "day":
        new_daywall = "day:"+get_currwal()
        sleeptime = night_shift
        new_term = "night"
    elif curr_term == "night":
        new_daywall = "night:"+get_currwal()
        sleeptime = day_shift
        new_term = "day"

    toremove = [item for item in set_wallpapers if curr_term+":" in item][0]
    # replace possibly changed wallpaper in the prefsfile and the currently
    # used set of wallpapers
    set_wallpapers.remove(toremove)
    set_wallpapers.append(new_daywall)
    write_walls(prefsfile, set_wallpapers)
    # switch daytime <> night, set the wallpaper accordingly
    curr_term = new_term
    set_wall([item for item in set_wallpapers if new_term+":" in item][0])
    # sleep again...
    time.sleep(sleeptime)

How to use

Copy the script into an empty file, save it as wallpaper_shift.py
Test- run it from a terminal by the command (example):
```
python3 /path/to/wallpaper_shift.py 19:00 6:00
```
where the time format should be 20:00
In any of the two terms, simply set the wallpaper as you like, the script remembers and re- applies it on the next "day" or "night".
If all works fine, add it to Startup Applications: Dash > Startup Applications > Add. Add the command:
```
/bin/bash -c "sleep 20 && python3 /path/to/wallpaper_shift.py 19:00 6:00"
```

Notes

The script works correctly if the evening starts between 12:00 a.m. and ends after midnight. That seems however obvious.
The script rounds the time on minutes, meaning that the accuracy is also somewhere between 0-60 seconds.