Arch Linux

drewbie

Member

From: England

Registered: 2006-02-12

Posts: 12

[python] setting a variable in a loaded module from the main script

Hi,

I have have two python scripts, one generally controlling my desktop wallpaper, the other downloads the APOD picture from the net and sets it as my wallpaper.

At the moment I can get the wallpaper script to load the apod script as a module to use its functionality.

The problem comes when I try to get the module to recognise variables set from the parent script:
I have both scripts using the variable  'verbose' to control how much output is printed, (which can be set from the command line options).
How do I get the 'verbose' variable in the imported module to be the same as the variable set by the script?

I can get it into an imported function using a keyword assignment when called, 'download(verbose=options.verbose)', but this is forgotten when other functions are called.

I have also tried making it a global variable.

I assume it is because I am importing the module and setting the default value before the main script sets its value, but I cant see a way round this.

Any ideas?
Many thanks,
Drew

dandaman0061

Member

From: Boise, ID

Registered: 2009-05-06

Posts: 12

Re: [python] setting a variable in a loaded module from the main script

First I would suggest posting some code examples of what you've tried...
But from your descriptions I would try something like:
File1.py

verbose = True

File2.py

import File1
verbose = File1.verbose

However IMHO, this is kind of ugly.  It starts looking like a 'global' namespace, which I cannot stand.  It is better (again IMHO), to have the variables separate and keep testing them individually.

Last edited by dandaman0061 (2009-05-06 22:28:38)

drewbie

Member

From: England

Registered: 2006-02-12

Posts: 12

Re: [python] setting a variable in a loaded module from the main script

simplistically the two scripts look like this

wallpaper.py

import 'stuff'
import apod

## set default values of things
verbose = False

some functions


def main():
    some stuff
    if command == 'apod':
        apod.download()
    other stuff

if __name__ == '__main__':
   turn on verbose using optparse
   main()

apod.py

import 'stuff'

## set default values of things
verbose = False

some functions

download():
    yet more stuff

def main():
    some stuff

if __name__ == '__main__':
   turn on verbose using optparse
   main()

the problem is that the import command is before the command line options are parsed. I don't want to get into circular import commands also because if the import is at startup i'm not sure it will import the right value.

the only way i have found so far that works is to pass the options to the next function explicitly:

in wallpaper:

def function1(verbose=False):
    print('hello world')
    verbose = options.verbose  # set from optparse 
    apod.function2(verbose=verbose)



in apod:

def function2(verbose=False):
    pass

This does however mean that i need to pass on the variable to every subsequent function or else it will 'forget'. Is there another way to do this that might be easier?

genisis300

Member

From: Uk

Registered: 2008-01-15

Posts: 284

Re: [python] setting a variable in a loaded module from the main script

wallpaper.py


import 'stuff'
import apod

## set default values of things


some functions

class myclass:
    self.verbose = false   ## set default
    def main(self):
        some stuff
        if command == 'apod':
            apod.download()
        other stuff

if __name__ == '__main__':
    wall = myclass()
    wall.main()

mport 'stuff'

## set default values of things

from wallpaper import myclass

opts = myclass()

some functions

download():
    yet more stuff

def main():
    some stuff

if __name__ == '__main__':
   opts.verbose = True / False
   main()

very crude but i think you get the idea.

you may even be able to assing it as a global in the 2nd module
after the import put the folloing

opt = myclass()
Verbose = myclass.verbose

lol just realise it's not that different to the above suggestion

Last edited by genisis300 (2009-05-08 23:05:44)

---

"is adult entertainment killing our children or is killing our children entertaining adults?" Marilyn Manson

pointone

Wiki Admin

From: Waterloo, ON

Registered: 2008-02-21

Posts: 379

Re: [python] setting a variable in a loaded module from the main script

I'm so utterly confused... How are you using the variable "verbose"? I can't imagine how this could be an issue. Could you please post the actual code you're trying to use?

---

M*cr*s*ft: Who needs quality when you have marketing?

kumyco

Member

From: somewhere

Registered: 2008-06-23

Posts: 153

Website

Re: [python] setting a variable in a loaded module from the main script

don't forget you can import anywhere in the script, so you can do it after parsing the command line
and it's supposedly not best practice, but worse comes to worst global should help

drewbie

Member

From: England

Registered: 2006-02-12

Posts: 12

Re: [python] setting a variable in a loaded module from the main script

simplicity:

test1.py

#!/usr/bin/python3
__version__ = 1

from optparse import OptionParser, OptionGroup, SUPPRESS_HELP

import test2
def_msg = 3

###

def function1(msg=def_msg):
    print('1 message level here is {0}' .format(msg))

def function2():
    print('2 message level here is {0}' .format(msg))

def function3(msg=def_msg):
    msg = def_msg
    print('3 message level here is {0}' .format(msg))

def function4():
    print('4 message level here is {0}' .format(msg))


def main(msg=def_msg):
    print('m message level here is {0}' .format(msg))
    function1(msg=msg)
    function2()
    function3()
    function4()
    test2.main(msg=msg)
    function2()






if __name__ == "__main__":



    parser = OptionParser(usage = "usage: %prog [options] command", version="%prog {0}" .format(__version__),
                  description = "Test script 1.")


    parser.set_defaults()

    standard = OptionGroup(parser, "Standard Options")


## Standard Options
    standard.add_option("-q", "--quiet",
                  action="store_true", dest="quiet", default=False, #help=SUPPRESS_HELP)
                  help="only display warnings and errors")
    standard.add_option("-v", "--verbose",
                  action="store_true", dest="verbose", default=False, #help=SUPPRESS_HELP)
                  help="display all output")
    standard.add_option("--debug",
                  action="store_true", dest="debug", default=False, #help=SUPPRESS_HELP)
                  help="debug mode: detailed output of commands")
    standard.add_option("--really-quiet", 
                  action="store_true", dest="reallyquiet", default=False, help=SUPPRESS_HELP)
                  #help="only display errors")
    standard.add_option("--silent",
                  action="store_true", dest="silent", default=False, help=SUPPRESS_HELP)
                  #help="don't display any output")



    parser.add_option_group(standard)

    (options, args) = parser.parse_args()

    ## message level

    if options.debug == True:
        msg = 5
    elif options.verbose == True:
        msg = 4
    elif options.quiet == True:
        msg = 2
    elif options.reallyquiet == True:
        msg = 1
    elif options.silent == True:
        msg = 0
    else:
        msg = 3

    main(msg=msg)

test2.py

#!/usr/bin/python3
__version__ = 1
from optparse import OptionParser, OptionGroup, SUPPRESS_HELP

#from test1 import msg
def_msg = 3
#msg = 3



def function1(msg=def_msg):
    print('1 message level here is {0}' .format(msg))

def function2(msg=def_msg):
    print('2 message level here is {0}' .format(msg))

def function3():
    print('3 message level here is {0}' .format(msg))



def main(msg=def_msg):
    #from test1 import msg
    #import test1
    #msg = test1.msg
    print('m message level here is {0}' .format(msg))
    function1(msg=msg)
    function2()
    function3()







if __name__ == "__main__":



    parser = OptionParser(usage = "usage: %prog [options] command", version="%prog {0}" .format(__version__),
                  description = "Test script 2.")


    parser.set_defaults()

    standard = OptionGroup(parser, "Standard Options")


## Standard Options
    standard.add_option("-q", "--quiet",
                  action="store_true", dest="quiet", default=False, #help=SUPPRESS_HELP)
                  help="only display warnings and errors")
    standard.add_option("-v", "--verbose",
                  action="store_true", dest="verbose", default=False, #help=SUPPRESS_HELP)
                  help="display all output")
    standard.add_option("--debug",
                  action="store_true", dest="debug", default=False, #help=SUPPRESS_HELP)
                  help="debug mode: detailed output of commands")
    standard.add_option("--really-quiet", 
                  action="store_true", dest="reallyquiet", default=False, help=SUPPRESS_HELP)
                  #help="only display errors")
    standard.add_option("--silent",
                  action="store_true", dest="silent", default=False, help=SUPPRESS_HELP)
                  #help="don't display any output")



    parser.add_option_group(standard)

    (options, args) = parser.parse_args()

    ## message level

    if options.debug == True:
        msg = 5
    elif options.verbose == True:
        msg = 4
    elif options.quiet == True:
        msg = 2
    elif options.reallyquiet == True:
        msg = 1
    elif options.silent == True:
        msg = 0
    else:
        msg = 3

    main(msg=msg)
else:
    msg = def_msg

I think I understand why it gives the results it does when run as 'test1.py -v'

I was just wondering if there was an easier way to get the second script to take and remember the variable without having to write variable=value into the function call every single time? However this is the only way I have found so far.

The actual code:

wallpaper.py:

#!/usr/bin/python3
#Filename: wallpaper.py
__version__ = '6.2.0'

import os, sys
from optparse import OptionParser, OptionGroup, SUPPRESS_HELP
#import warnings
import random
#import apod




#####################################################################
#####                         CONFIG                            #####
#####################################################################

## Global Variables
root               = '/home/wallpaper'

feh_wallpaper_file = os.path.expanduser('~/.fehbg')
filter_file        = os.path.expanduser('~/.config/openbox/wallpaper/mask')
config_path        = os.path.expanduser('~/.config/openbox/wallpaper')


list_default = 'default-list'
list_alt     = 'alt-list'

menu_default = 'menu-folders' 
menu_alt     = 'alt-menu'

lockfile='/tmp/wallpaper.lock'

valid_list_list = 'alt-list', 'default-list'

def_msg = 3


#####################################################################
#####                          LOCK v2.2                        #####
#####################################################################

def LockScript(fun, lock=lockfile, msg=def_msg):
    """Locks the script before starting a function."""
    if msg >= 5:
        print('Lock :: Locking Script')
    from os import O_CREAT, O_EXCL
    try:
        fd = os.open(lock, O_CREAT+O_EXCL)
        if msg >= 5:
            print('Lock :: created lock file')
    except OSError:
        if msg >= 1:
            print('Error :: Already running function {0}...' .format(fun))
        sys.exit(1)
    try:
        fun(msg=msg)
    finally:
        try:
            os.remove(lock)
            if msg >= 6:
                print('Lock :: Removed Lock File')
        except:
            if msg >= 1:
                print('Lock :: Error :: Lockfile missing')

#####################################################################
#####                     CURRENT INFO                          #####
#####################################################################





def get_filter(msg=def_msg):
    """Retrieves the filter."""
    f = open(filter_file, 'r')
    i = f.read()
    f.close()
    if msg >= 6:
        print('Got Filter :: {0}' .format(i))
    return i


def get_info(msg=def_msg):
    """Returns the path and name of the current wallpaper."""
    with open(feh_wallpaper_file, 'r') as f:
        a = f.read()
        b = a[15:-1]
        f.close()
    name = os.path.basename(b) 
    try:
        import apod
        if name == 'apod':
            path = os.path.join(apod.archive_folder, apod.thisyear)
            w = os.listdir(path)
            w.sort()
            wnum = len(w) -1
            name = w[wnum]
        else:
            path = os.path.dirname(b)
    except:
            path = os.path.dirname(b)
    if msg >= 5:
        print('current wallpaper :: {0} {1}' .format(path, name))
    return path, name




    


def get_next(c, z, msg=def_msg):
    """Gets the next number in the sequence of length z."""
    if c == (len(z) - 1):
        n = 0
    else:
        n = c + 1
    if msg >= 6:
        print('next number is {0}' .format(n))
    return n

def get_prev(c, z, msg=def_msg):
    """Gets the previous number in the sequence of length z."""
    if c == 0:
        p = (len(z) - 1)
    else:
        p = c - 1
    if msg >= 6:
        print('previous number is {0}' .format(p))
    return p

        


def current_wallpaper_info(msg=def_msg):
    """Print the details of the current wallpaper."""
    name = get_info(msg=msg)[1]
    path = get_info(msg=msg)[0]
    folder = os.path.basename(path)
    mask = get_filter(msg=msg)

    try:
        import apod
        if path.startswith(apod.archive_folder) or name.startswith('APOD'):
            title = apod.get_name(fname=name, msg=msg)
            print('currently the wallpaper is "{0}", {1}' .format(title, name))
        elif not  mask == '': 
            print('currently the wallpaper is {0} from folder {1} using mask {2}' .format(name, folder, mask))
        else:
            print('currently the wallpaper is {0} from folder {1}' .format(name, folder))
    except:
        print('currently the wallpaper is {0} from folder {1}' .format(name, folder))


#####################################################################
#####                  SET WALLPAPER FUNCTIONS                  #####
#####################################################################




def set_filter(i=None, msg=def_msg, mask_file=filter_file):
    """Sets the filter."""
    if test:
        f = open(mask_file, 'r')
    else:
        f = open(mask_file, 'w')
    if i == None:
        if msg >= 5:
            print('clearing filter') 
        if test:
            print('exec :: Clear filter')
        else:
            f.write('')
    else:
        if msg >= 4:
            print('Setting filter as "{0}"' .format(i)) 
        if test:
            print('exec :: Writing filter as :: "{0}"' .format(i)) 
        else:
            f.write(i)
    f.close()

def set_wallpaper(name, path_in=get_info()[0], msg=def_msg):
    """Set the wallpaper."""
    spath  = path_in.split(':')
    path   = spath[0]

    try:
        mask = spath[1]
        set_filter(mask, msg=msg)
    except:
        pass
    full = os.path.join(path, name)
    if msg >= 4:
        print("setting {0} as wallpaper" .format(name))
    if test:
        print("exec :: feh --bg-scale {0}" .format(full))
    else:
        os.system("feh --bg-scale {0}" .format(full))


#def set_default(d=default_file):
#    """Sets the default walllpaper."""
#    set_wallpaper(d[1], d[0])

def set_wallpaper_last(msg=def_msg):
    """Set the wallpaper as the last image."""

    ## alternativly use "eval `cat ~/.fehbg`"

    full = os.path.join(get_info()[0], get_info()[1])
    if msg >= 4:
        print("setting {0} as wallpaper" .format(full))
    if test:
        print("exec :: feh --bg-scale {0}" .format(full))
    else:
        os.system("feh --bg-scale {0}" .format(full))



def change_folder(folder0, mask=None, msg=def_msg):
    """Change Wallpaper folder (optional filter) relative from root dir."""
    folder_split = folder0.split(':')
    folder = folder_split[0]
    path = os.path.join(root, folder)
    

    if not os.path.exists(path):  # Path does not exist
        if msg >= 1:
            print('Fatal Error :: path does not exist')
            print('avaliable folders are {0}' .format(avaliable_folders()))
        sys.exit()

    if msg >= 4:
        print('changing folder to {0}' .format(folder))

    f1 = os.listdir(path)

    try:
        if folder_split[1]:
            mask = folder_split[1]
            f2 = []
            for i in f1:
                if i.find(mask) > -1:
                    f2.append(i)
            f = f2
            if len(f) == 0:
                if msg >= 2:
                    print('Warning :: invalid filter')
                raise
            set_filter(mask, msg=msg)
        else: #            print('null mask')
            if msg >= 2:
                print('Warning :: null filter')
            raise
    except:
        if msg >= 5:
            print('No filter used, clearing')
        set_filter(msg=msg)
        f = f1

    if len(f) == 0:
        if msg >= 1:
            print('Fatal Error :: no files in path')
        sys.exit()
    r = random.randrange(0,len(f))
    if msg >= 5:
        print('chosing random number:: {0}' .format(r))
    set_wallpaper(f[r], path, msg=msg)

def avaliable_folders(r=root, msg=def_msg):
    """Returns a list of avaliable folders in the root wallpaper directory."""
    allfolders = os.listdir(r)
    folders = []
    for f in allfolders:
        if not f.startswith("."):
            folders.append(f)
    return folders





#####################################################################
#####             DEFAULT / ALT SEQUENCE LISTS                  #####
#####################################################################



def strip_opt(p):
    #q1 = p.replace(' ','')
    #q2 = q1.replace('\t','')
    #q3 = q2.replace('\n','')
    q = p.replace(' ','').replace('\t','').replace('\n','')
    return q



def check_list(l, path=config_path, dl=list_default, al=list_alt, msg=def_msg, returnF=False):
    """Checks to see (and returns) valid path to list."""
    if l == 'default' or l == 'def' or l == None :
        if msg >= 4:
            print('using default list')
        return os.path.join(path, dl)
    elif l == 'alt':
        if msg >= 4:
            print('using alternative list')
        return os.path.join(path, al)
    else:
        try:
            if not os.path.exists(os.path.join(path, l)):
                if msg >= 1:
                    print('Error :: list does not exist')
                raise
            elif not os.path.isfile(os.path.join(path, l)):
                if msg >= 1:
                    print('Error :: list not a file')
                raise
            else:
                try:
                    c = valid_list_list.index(l)
                    if msg >= 6:
                        print('list name has been validated')
                except:
                    if msg >= 2:
                        print('Warnimg :: list used has not been vaildated by script')
                        print('Warnimg :: if valid; add to the list of valid lists')
                if msg >= 5:
                    print('path exists')
                return os.path.join(path, l)

        except:
            if returnF == True:
                return False
            else:
                if msg >= 2:
                    print('Warning :: using default list')
                return os.path.join(config_path, dl)




def get_seq(msg=def_msg):
    """Returns the sequence of current wallpaper and curr position."""
    mask = get_filter(msg=msg)
    path = get_info(msg=msg)[0]
    name = get_info(msg=msg)[1]
    list1 = os.listdir(path)

    if mask == '':
        list0 = list1
    else:
        list2 = []
        for i in list1:
            if i.find(mask) > -1:
                list2.append(i)
        try:    # check the filter is currently being used
            num = list2.index(name)
            #print('wallpaper in filtered list')
            list0 = list2
        except:   # filter is out of date
            if msg >= 5:
                print('wallpaper not in filtered list... clearing')
            list0 = list1
            set_filter(msg=msg)  # clear filter
    list0.sort()
    try:  # needed if current wallpaper has been removed
        num = list0.index(name)
        if msg >= 5:
            print('current wallpaper info ::')
            print('name : {0}, number : {1}' .format(name, num))
        return num, list0
    except:
        if msg >= 1:
            print('Error :: get_seq :: Current wallpaper file missing :: name : {0}' .format(name))
        return 0, list0
    


def list_sequence(com='next', seq=None, msg=def_msg):

    cname = get_info(msg=msg)[1]

    if seq == None:
        list_dir = get_info(msg=msg)[0]
        list_file = get_seq(msg=msg)[1]
        if msg >= 4:
            print('Changing wallpaper in sequence using current folder:mask')
    else:
        ## Build a list.
        a = check_list(seq, msg=msg)
        list_dir = []
        list_file = []
        with open(a, 'r') as f:
            for line in f:
                i = line.split(',')
                list_dir.append(os.path.join(root, strip_opt(i[0])))
                list_file.append(strip_opt(i[1])) 
        set_filter(msg=msg) # flush mask if using a list
        if msg >= 4:
            print('Changing wallpaper in sequence using list file')

    try:
        c = list_file.index(cname)
        if msg >= 5:
            print('found current wallpaper in list at position {0}' .format(c))

        if com == 'random':
            n = random.randrange(0, len(list_file))
            if msg >= 4:
                print('setting random wallpaper from sequence')
        elif com == 'prev':
            n = get_prev(c, list_file)
            if msg >= 4:
                print('setting previous wallpaper in sequence')
        elif com == 'next':
            n = get_next(c, list_file)
            if msg >= 4:
                print('setting next wallpaper in sequence')
        elif com == 'first':
            if msg >= 4:
                print('setting first wallpaper in sequence')
            n = 0
        else:
            if msg >= 2:
                print('Warning :: Unknown commmand')
            n = 0


    except:
        if msg >= 4:
            print('Warning :: not found current wallpaper in list / folder')
            print('using first file in list / folder')
        n = 0


    if seq == None:
        set_wallpaper(list_file[n], list_dir, msg=msg)
    else:
        set_wallpaper(list_file[n], list_dir[n], msg=msg)

    







def toggle_list(d='default', com='toggle', msg=def_msg):
    """Removes the current file from the list."""
    a = check_list(d, msg=msg)

    file_list = []
    mod_file = []

    cname = get_info(msg=msg)[1]
    cpath = get_info(msg=msg)[0]

    if os.path.dirname(cpath) == root:
        cdir = os.path.basename(cpath)
    elif os.path.dirname(os.path.dirname(cpath)) == root:
        cdir = os.path.join(os.path.basename(os.path.dirname(cpath)), os.path.basename(cpath))
    else:
        print('error')
        sys.exit()
    cmask = get_filter(msg=msg)
    if cmask == '':
        cdmask = cdir
    else:
        cdmask = '{0}:{1}' .format(cdir, cmask)
    in_list = False

    with open(a) as f:
        for line in f:
            i = line.split(',')
            if cname == strip_opt(i[1]):
                if msg >= 6:
                    print('file in list')
                in_list = True
            else:
                if msg >= 6:
                    print('file not in list')
                file_list.append(strip_opt(i[1]))
                mod_file.append('{0} , {1} \n' .format(strip_opt(i[0]), strip_opt(i[1])))
    if in_list and com != 'rmfile' :
        if msg >= 3:
            print('Removed file from list')
        if test:
            for j in mod_file:
                print('writing newline: {0}' .format(j))
        else:
            with open(a, 'w') as newf:
                for j in mod_file:
                    newf.writelines(j)
    elif not in_list and com != 'addfile':
        mod_file.append('{0} , {1}  \n' .format(cdmask, cname))
        if msg >= 3:
            print('Added wallpaper to list')
        if test:
            for j in mod_file:
                print('writing newline: {0}' .format(j))
        else:
            with open(a, 'w') as newf:
                for j in mod_file:
                    newf.writelines(j)
    else:
        if com == 'addfile':
            if msg >= 2:
                print('Warning :: File already in list')
        elif com == 'rmfile':
            if msg >= 2:
                print('Warning :: File not in list')
        else:
            if msg >= 1:
                print('Error :: UNKNOWN :: TOG LIST FUNCTION')
        





#####################################################################
#####                   OPENBOX MENU                            #####
#####################################################################






def gen_obmenu():
    import oblib
    for i in avaliable_folders():
        oblib.item(i, 'wallpaper.py --silent --change {0}' .format(i))


def gen_obmenu_simple(name=None, i=None):
    import oblib
    if name == None:
        oblib.pipe_start()
    else:
        oblib.menu_start(name, i)
    oblib.item('Deafult',   'wallpaper.py --silent --default')
    oblib.sep()
    oblib.item('APOD',      'wallpaper.py --silent --apod')
    oblib.item('APOD Save', 'wallpaper.py --silent --apod-save')
    oblib.item('Random',    'wallpaper.py --silent --random')
    if name == None:
        oblib.pipe_end()
    else:
        oblib.menu_end()

def gen_obmenu_standard():
    import oblib
    oblib.pipe_start()
    oblib.item('Deafult',   'wallpaper.py --silent --default')
    oblib.sep()
    oblib.item('APOD',      'wallpaper.py --silent --apod')
    oblib.item('APOD Save', 'wallpaper.py --silent --apod-save')
    oblib.sep()
    oblib.menu_start('Change Set')
    obmenu_change_set()
    oblib.menu_end()
    apod.obmenu_archive_folders(t='menu')
    oblib.item('Toggle List', 'wallpaper.py --silent --toggle')
    oblib.item('Random',      'wallpaper.py --silent --random')
    oblib.pipe_end()

def gen_obmenu_alt():
    import oblib
    oblib.pipe_start()
    oblib.sep('Alt Menu')
    obmenu_change_set('alt')
    oblib.pipe_end()


def obmenu_change_set(a='default', dl=menu_default, al=menu_alt):
    import oblib
    menu = check_list(a, dl=dl, al=al, returnF=True)
    if menu != False:
        f = open(menu, 'r')
        for line in f:
            i = line.split(',')
            oblib.item(strip_opt(i[0]), 'wallpaper.py --change {0}' .format(strip_opt(i[1])))
        f.close()
    else:
        for i in avaliable_folders():
            oblib.item(i, 'wallpaper.py --change {0}' .format(i))




#####################################################################
#####                   TEST FUNCTIONS                          #####
#####################################################################





def parser_options():
    print('Options are: {0}' .format(options))
    print('Args are : {0}' .format(args))
    print('Command is : {0}' .format(command))




def meta_info():
    if options.meta_source == None:
        print('No source specifieed')
    else:
        print('Script launched from source :: {0}' .format(options.meta_source))



def test_module():
    #pass
    #print(check_list(args[0]))
    new_mod()

def new_mod():
    #if path == None:
    #    print('No path specified, using pwd')
    #    path = os.curdir
    #need_new_name = False
    #print('Checking filenames in {0}' .format(path))
    #for name in os.listdir(path):
    #    if name.find(" ") > -1:
    #        print("Warning :: > < in {0}" .format(name))
    #        need_new_name = True
    #    if name.find("'") > -1:
    #        print("Warning :: >'< in {0}" .format(name))
    #        need_new_name = True
    #    if name.find("&") > -1:
    #        print("Warning :: >&< in {0}" .format(name))
    #        need_new_name = True
    #    if name.find('"') > -1:
    #        print('Warning :: >"< in {0}' .format(name))
    #        need_new_name = True
    #    if need_new_name:
    #        new_name = name.replace('"', "").replace(" ", "_").replace("&", "and").replace("'", "")
    #        if re_name:
    #            print("Renaming to new name:: {0}" .format(new_name))
    #            os.rename(os.path.join(path, name), os.path.join(path, new_name))
    #        else:
    #            print("Suggested new name:: {0}" .format(new_name))
    #        need_new_name = False
    pass



#####################################################################
#####              SANITISE WALLPAPER FILE NAMES                #####
#####################################################################

def sane_names(path=None, re_name=False, msg=def_msg):
    """Check file names in a path."""
    if path == None:
        print('No path specified, using pwd')
        path = os.curdir
    need_new_name = False
    print('Checking filenames in {0}' .format(path))
    for name in os.listdir(path):
        if name.find(" ") > -1:
            print("Warning :: > < in {0}" .format(name))
            need_new_name = True
        if name.find("'") > -1:
            print("Warning :: >'< in {0}" .format(name))
            need_new_name = True
        if name.find("&") > -1:
            print("Warning :: >&< in {0}" .format(name))
            need_new_name = True
        if name.find('"') > -1:
            print('Warning :: >"< in {0}' .format(name))
            need_new_name = True
        if need_new_name:
            new_name = name.replace('"', "").replace(" ", "_").replace("&", "and").replace("'", "")
            if re_name:
                print("Renaming to new name:: {0}" .format(new_name))
                os.rename(os.path.join(path, name), os.path.join(path, new_name))
            else:
                print("Suggested new name:: {0}" .format(new_name))
            need_new_name = False
            
    print('File name check complete')


#####################################################################
#####                    MAIN FUNCTION                          #####
#####################################################################


def Main(msg=def_msg):
    """Chooses which command to run."""
    if options.direction != None:    # a dircetion has been set
        list_sequence(com=options.direction, seq=options.whichlist, msg=msg)
    elif command == 'last':
        set_wallpaper_last(msg=msg)
    elif command == 'info':
        current_wallpaper_info(msg=msg)

## change folder
    elif options.newfolder != None:
        change_folder(options.newfolder, msg=msg)

## apod
    elif command == 'apod':
        #apod.download2(msg=msg, test=test)
        try: 
            import apod        
            apod.download2(msg=msg, test=test)
        except:
            pass
    elif command == 'apod-save':
        #apod.apod_save('today', msg=msg, test=test)
        try: 
            import apod        
            apod.apod_save('today', msg=msg, test=test)
        except:
            pass


## list management
    elif options.toggle != None:
        toggle_list(options.whichlist, com=options.toggle, msg=msg)

## openbox menu
    elif command == 'obmenu':
        gen_obmenu_standard()
    elif command == 'obmenu-simple':
        gen_obmenu_simple()
    elif command == 'obmenu-alt':
        gen_obmenu_alt()

## filename check
    elif command == 'sane-name':
        sane_names(path=options.sane_path, re_name=options.sane_rename, msg=msg)


## cycle
    elif command == 'cycle':
        print('ERROR :: function not implemented')
    elif command == 'testmod':
        test_module()
    elif options.whichlist != None:   # a list but no direction specified
        list_sequence(seq=options.whichlist, msg=msg)

    elif command == "TestNone":
        print('Test mode null op[tion')
    elif command == None: ## no command specified
        pass
    else:
        print('Error :: no valid command found')



#####################################################################
#####                    SCRIPT STARTUP                         #####
#####################################################################

if __name__ == "__main__":

#    def parse_change(option, opt_str, value, parser):
#        parser.values.command = 'change'
#        parser.values.newfolder  = value

#    def parse_smask(option, opt_str, value, parser):
#        parser.values.command = 'set-mask'
#        parser.values.mask  = value

    def parse_cycle(option, opt_str, value, parser):
        parser.values.command = 'cycle'
        parser.values.interval  = value

    def parse_msglevel(option, opt_str, value, parser):
        parser.values.msg  = value

#    def parse_addfile(option, opt_str, value, parser):
#        parser.values.command = 'addfile'
#        parser.values.whichlist  = value

#    def parse_rmfile(option, opt_str, value, parser):
#        parser.values.command = 'rmfile'
#        parser.values.whichlist  = value


    parser = OptionParser(usage = "usage: %prog [options] command", version="%prog {0}" .format(__version__),
                  description = "Drews Script to the manage wallpapers using feh.")


    parser.set_defaults(command=None, whichlist=None, direction=None, toggle=None, newfolder=None)

    standard = OptionGroup(parser, "Standard Options")
    metaopt = OptionGroup(parser, "Meta Info Options", "Further datails about the script startup useful for debugging")
    gapod = OptionGroup(parser, "APOD Options", "Controls for the Astronomy Picture of the Day.  ")
    obmenu = OptionGroup(parser, "Openbox Menu", "Support for openbox xml menu generation.  ")
    #groupalt = OptionGroup(parser, "Alternative Wallpapers")
    gplist = OptionGroup(parser, "List Support")
    namecheck = OptionGroup(parser, "Filename Support")
    direction = OptionGroup(parser, "Direction Commands")


## Standard Options
    standard.add_option("-q", "--quiet",
                  action="store_true", dest="quiet", default=False, #help=SUPPRESS_HELP)
                  help="only display warnings and errors")
    standard.add_option("-v", "--verbose",
                  action="store_true", dest="verbose", default=False, #help=SUPPRESS_HELP)
                  help="display all output")
    standard.add_option("--debug",
                  action="store_true", dest="debug", default=False, #help=SUPPRESS_HELP)
                  help="debug mode: detailed output of commands")
    standard.add_option("--really-quiet", 
                  action="store_true", dest="reallyquiet", default=False, help=SUPPRESS_HELP)
                  #help="only display errors")
    standard.add_option("--silent",
                  action="store_true", dest="silent", default=False, help=SUPPRESS_HELP)
                  #help="don't display any output")


    standard.add_option('-t', "--test",
                  action="store_true", dest="test", default=False, #help=SUPPRESS_HELP)
                  help="test mode :: only print output")
    standard.add_option("--test-mod",
                  action="store_const", const="testmod", dest="command", #help=SUPPRESS_HELP)
                  help="test mode :: use test function module")
    standard.add_option("--test-none",
                  action="store_const", const="TestNone", dest="command", #help=SUPPRESS_HELP)
                  help="test mode :: no command specified")



    parser.add_option("--info", '-i',
                  action="store_const", const="info", dest="command",
                  help="Displays information about the current wallpaper.")
    parser.add_option("--last", '-l',
                  action="store_const", const="last", dest="command",
                  help="Sets the wallpaper as the last picture")



    direction.add_option('-n', "--next",
                  action="store_const", const="next", dest="direction",
                  help="Sets the next wallpaper in the sequence")
    direction.add_option('-p', "--prev", '--previous',
                  action="store_const", const="prev", dest="direction",
                  help="Sets the previous wallpaper in the sequence")
    direction.add_option('-r', '--rand', "--random",
                  action="store_const", const="random", dest="direction",
                  help="Sets a random wallpaper from the sequence")
    direction.add_option('-1', '--first', "--safe",
                  action="store_const", const="first", dest="direction",
                  help="Sets the first wallpaer in the sequence")




    gplist.add_option('-d', "--default",
                  action="store_const", const="default", dest="whichlist",
                  help="Uses the wallpapers from the default file list")
    gplist.add_option("--alt",
                  action="store_const", const="alt", dest="whichlist",
                  help="Uses the wallpapers from the alternative list")
    parser.add_option("--change", '-c',
                  metavar="Folder[:Filter]", dest="newfolder",
                  help="Changes the wallpaper folder, optional filter.")


    gapod.add_option('-a', "--apod",
                  action="store_const", const="apod", dest="command",
                  help="downloads and sets the wallpaper as todays APOD picture")
    gapod.add_option("--apod-save",
                  action="store_const", const="apod-save", dest="command",
                  help="Saves todays APOD picture")
#    gapod.add_option("--apod-last",
#                  action="store_const", const="apod-last", dest="command",
#                  help="Sets the wallpaper as yesterdays APOD picture")
#    gapod.add_option("--apod-force",
#                  action="store_const", const="apod-force", dest="command",
#                  help="force the download of todays APOD picture")




    gplist.add_option("--add-to-list",
                  action="store_const", const='rmfile', dest='toggle',
                  help="Adds the current wallpaper to the list.")
    gplist.add_option("--remove-from-list",
                  action="store_const", const='addfile', dest='toggle',
                  help="Removes the current wallpaper from a list.")
    gplist.add_option("--toggle-list", '--toggle',
                  action="store_const", const='toggle', dest='toggle',
                  help="Adds/Removes the current wallpaper from a list.")

    gplist.add_option("--list",
                  metavar="LIST", dest='whichlist',
                  help="Sets which list to use.")



    obmenu.add_option("--obmenu",
                  action="store_const", const="obmenu", dest="command",
                  help="Prints the standard openbox menu.")
    obmenu.add_option("--obmenu-simple",
                  action="store_const", const="obmenu-simple", dest="command",
                  help="Prints the simple openbox menu.")
    obmenu.add_option("--obmenu-alt",
                  action="store_const", const="obmenu-alt", dest="command", #help=SUPPRESS_HELP)
                  help="Prints the alternative openbox menu.")



    namecheck.add_option("--name-check",
                  action="store_const", const="sane-name", dest="command",
                  help="Checks if wallpaper names are valid.")
    namecheck.add_option("--name-path",
                  metavar="PATH", dest="sane_path", default=None,
                  help="Which folder to check.")
    namecheck.add_option("--rename",
                  action="store_true", dest="sane_rename", default=False,
                  help="If to rename invalid files.")



    metaopt.add_option("--meta-from",
                  metavar="Source", dest='meta_source', default=None,
                  help="Details from where the script was launched from")



    parser.add_option_group(direction)
    parser.add_option_group(gplist)
    parser.add_option_group(gapod)
    parser.add_option_group(obmenu)
    
    #parser.add_option_group(standard)
    #parser.add_option_group(metaopt)
    
    #parser.add_option_group(namecheck)

    (options, args) = parser.parse_args()

    test = options.test
    #debug = options.debug
    #verbose = options.verbose
    #quiet = options.quiet

    ## message level

    if options.debug == True:
        msg = 5
    elif options.verbose == True:
        msg = 4
    elif options.quiet == True:
        msg = 2
    elif options.reallyquiet == True:
        msg = 1
    elif options.silent == True:
        msg = 0
    else:
        msg = 3

    #if options.command == None:
    #    try:   # try and find a command
    #        command = args[0]
    #    except:
    #        pass
    #else:
    #    command = options.command


    command = options.command

    if options.debug:
        parser_options()
        meta_info()


    LockScript(Main, msg=msg) # start the script

else:
    pass

apod.py

#!/usr/bin/python3
#Filename: apod.py
__version__ = '3.2.0'

import os, sys
from optparse import OptionParser, OptionGroup, SUPPRESS_HELP
import shutil
from datetime import date

#print('loaded apod')

#####################################################################
#####                       VARIABLES                           #####
#####################################################################

## Files and Paths
#apod_archive_folder = '/home/wallpaper/apod_archive'

archive_folder = '/home/wallpaper/apod_archive'
save_folder    = '/home/wallpaper/Space'

tmpdir = '/tmp/wallpaper/apod'

html_file   = os.path.join(tmpdir, 'apod-html')
img_file    = os.path.join(tmpdir, 'apod-img')
index_file  = os.path.join(tmpdir, 'apod-index')

work = os.path.expanduser('~/.config/openbox/apod')

date_file = os.path.join(work, 'apod-date')
apodfile  = os.path.join(work, 'apod')
apodlast  = os.path.join(work, 'apod-last')
namefile  = os.path.join(work, 'apod-names')
video_dir = os.path.join(work, 'apod-videos')
errs      = os.path.join(work, 'archive-errors')


dtoday   = str(date.today())        # todays date
thisyear = dtoday[:4]
saveprefix = 'APOD-'

## Defaults
def_test = False
def_msg = 3

def_command = None

def_apodset      = True
def_archive_apod = True  # Keep all APOD pictures
def_clear_apod   = False
def_force_apod   = False
def_cutoff = None

store_file_list = ''






#####################################################################
#####                          LOCK v2                          #####
#####################################################################

## Lock v2
def LockScript(fun, lock='/tmp/apod.lock', msg=def_msg):
    """Locks the script before starting a function."""
    from os import O_CREAT, O_EXCL
    try:  # lock the function
        fd = os.open(lock, O_CREAT+O_EXCL)
        #print('created lock file')
    except OSError:
        print('Already running function {0}...' .format(fun))
        sys.exit(1)
    try:
        fun(msg)
    finally:
        try: # release lock
            os.remove(lock)
        except:
            print('Error :: Lockfile missing !!!')



#####################################################################
#####                        DEFINITIONS                        #####
#####################################################################



def get_date(dfile=date_file):
    check_file(dfile, create=True, msg=1)
    f = open(dfile)
    return f.read()


def check_dir(d, create=False, msg=def_msg):
    """Check if path exists."""
    if not os.path.exists(d):
        if msg > 3:
            print('Error : folder missing...')
        if create:
            try:
                os.makedirs(d)
                if msg > 3 :
                     print('...created folder')
                     return True
            except:
                 print('Fatal Error :: could not create directory {0}' .format(d))
                 sys.exit()
        else:
            return False  
    elif not os.path.isdir(d):
        print('Fatal Error :: this is not a directory')
        sys.exit()
    else:
        return True


def check_file(f, create=False, msg=def_msg):
    """Check if path exists."""
    if not os.path.exists(f):
        #if msg > 3:
        #    print('Error : file missing...')
        if create:
            check_dir(os.path.dirname(f), create=create, msg=msg)
            if msg > 5:
                print('creating file {0}' .format(f))
            try:
                q = open(f, 'w')
                q.write('')
                q.close()
                return True
            except:
                if msg >= 1:
                    print('Fatal Error :: could not create file {0}' .format(f))
                sys.exit()
        else:
            if msg >= 5:
                print('file {0} does not exist' .format(f))
            return False 
    else:
        if msg >= 5:
            print('file {0} exists' .format(f))
        return True


def copy_file(ffrom, fto, msg=def_msg, test=def_test):
    """Copy files, from to (with test option)."""
    if test:
        print('[[copy command: {0} to {1}]]' .format(ffrom, fto))
    else:
        try:
            shutil.copy(ffrom, fto)
        except:
            if not os.path.exists(ffrom):
                print('Warning: error copying file, does not exist')
            elif os.path.isdir(ffrom):
                print('Fatal Error :: file being copied is a directory!')
                sys.exit()
            else:
                print('Fatal Error :: UNKNOWN ERROR during copy')
                sys.exit()


def download_files(hfile=html_file, ifile=img_file, datefile=date_file, msg=def_msg, test=def_test, apodset=def_apodset, day='today', archive_apod=def_archive_apod):
    """Download the APOD html and img."""
    import urllib.request
    import socket

    timeout = 10
    socket.setdefaulttimeout(timeout)

    if day == 'today':
        url = 'http://antwrp.gsfc.nasa.gov/apod/astropix.html'
        name = dtoday
        year = thisyear
    else:
        url = 'http://antwrp.gsfc.nasa.gov/apod/ap{0}.html' .format(day)
        name = day
        if day[:1] == '9' :
            name =  '19{0}-{1}-{2}' .format(day[:2], day[2:4], day[4:])
        else:
            name =  '20{0}-{1}-{2}' .format(day[:2], day[2:4], day[4:])
        year = name[:4]
    try:
        response = urllib.request.urlopen(url)
        html = response.read()
        if msg > 3:
            print('downloaded html data for {0}' .format(day))
        check_file(hfile, create=True, msg=msg)
        f = open(hfile, 'wb')
        f.write(html)
        f.close()
    except:
        if msg >= 1:
            print('ERROR :: page not found :: exiting.')
        sys.exit(1)

    if day == 'today':
        t = open(datefile, 'w')
        t.write(dtoday)
        t.close()
        if msg > 3:
            print('updated date file with todays date')

        if msg > 3:
            print('copying over yesterdays APOD image')
        copy_file(apodfile, apodlast, msg=msg, test=test)

    found_img = False
    with open(hfile, 'r', encoding='latin-1') as g:
        for line in g:
            if 'IMG SRC' in line:
                i = line.split('"')
                if msg > 4:
                    print('found image : {0}' .format(i[1]))
                found_img = True

                try:
                    img_responce = urllib.request.urlopen(os.path.join('http://antwrp.gsfc.nasa.gov/apod/', i[1]))
                    img_data = img_responce.read()
                except:
                    print('error in img download')
                    check_dir(errs, create=True, msg=1)
                    check_file(os.path.join(errs, name), create=True, msg=0)
                else:
                    if msg >= 5:
                        print('read img data')
                    check_file(ifile, create=True, msg=0)
                    if msg >= 5:
                        print('created img file')
                    with open(ifile, 'wb') as l:
                        l.write(img_data)
                    if msg >= 3:
                        print('downloaded image for {0}' .format(day))
                    if day == 'today':
                        copy_file(ifile,apodfile, msg=msg, test=test)

                    if archive_apod:
                        apod_archive(msg=msg, test=test, dfile=ifile, year=year, name=name)

    if not found_img :
        if msg >= 3:
            print('video :: not found image line in file from {0}' .format(i))
        check_file(os.path.join(video_dir, name), create=True, msg=0)
        if day == 'today':
            print('Warning : no image line in html file')
            copy_file(apodlast,apodfile, msg=msg, test=test)
        
    os.remove(hfile)
    os.remove(ifile)


def apod_archive(dfile=img_file, msg=def_msg, test=def_test, year=thisyear, name=dtoday):
    """Archive APOD picture."""
    arch_file = os.path.join(archive_folder, year, name)
    check_dir(os.path.join(archive_folder, year), msg=msg, create=True)
    if check_file(arch_file, create=False, msg=msg):
        if  msg > 3:
            print('APOD picture already archived')
    else:
        if  msg > 3:
            print('Archiving APOD picture')
        copy_file(dfile, arch_file, msg=msg, test=test)



def apod_save(day='current', sfolder=save_folder, msg=def_msg, test=def_test, prefix=saveprefix):
    """Save APOD picture as best of APOD."""
    with open(os.path.expanduser('~/.fehbg'), 'r') as f:
        a = f.read()
        b = a[15:-1]
        f.close()
    if day == 'today' or b[-4:] == 'apod':
        source = apodfile
        sfile = prefix + dtoday
    elif day == 'current':
        if not (os.path.dirname(b) == archive_folder or os.path.dirname(os.path.dirname(b)) == archive_folder ):
            print('picture is not in the recognised apod archive folder')
            sys.exit()
        source = b
        sfile = prefix+ b[-10:]
    else:
        if msg >= 1:
            print('unknown file specified')
        sys.exit(1)
    if  msg > 3:
        print('Saving APOD picture to Save folder')
    copy_file(source, os.path.join(sfolder, sfile), msg=msg, test=test)



def set_apod(a=apodfile, msg=def_msg, test=def_test, apodset=def_apodset ):
    """Sets the APOD wallpaper."""
    if not apodset:
        if msg > 3:
            print('Skipping setting APOD picture')
    else:
        if msg > 3:
            print('Setting APOD picture')
        if test:
            print("exec :: feh --bg-scale {0}" .format(a))
        else:
            os.system("feh --bg-scale {0}" .format(a))


def clear_date(msg=def_msg, test=False):
    """Clears the date file."""
    if msg > 3:
        print('reseting date')
    if not test:
        t = open(datefile, 'w')
        t.write('')
        t.close()






#####################################################################
#####                     APOD NAMES                            #####
#####################################################################


def get_name(fname=None, names=namefile, msg=def_msg, rerun=True, prefix=saveprefix):
    """Returns the name of an APOD file."""
    name_index = []
    title_index = []

    with open(names, 'r') as f:
        for line in f:
            i = line.split(',', 3)
            name_index.append(i[0])
            title_index.append(i[3])

    if fname == None:
       if msg >= 4:
           print('getting todays date')
       date = get_date()

    elif fname.startswith(prefix):
        if msg >= 4:
            print('removing save prefix from name')
        date = fname[len(prefix):]
    else:
        date = fname

    try:
        c = name_index.index(date)
        return title_index[c][:-2]

    except:
        if rerun:
            if msg >= 2:
                print('Warning :: name not in index, recreating')
            download_apod_index(msg=msg)
            build_name_list(msg=msg)
            get_name(fname=fname, names=names, msg=msg, rerun=False)
        else:
            if msg >= 1:
                print('Error :: name not in index, please recreate')
             
        





def regen_index(msg=def_msg, cutoff=None):
    download_apod_index(msg=msg)
    build_name_list(msg=msg, cutoff=cutoff)

def file_status(date, msg=def_msg, cutoff=None):
    """Status of an APOD Picture."""
    
    downloaded_files = [] # files in main apod download folder
    archive_files    = [] # files in sub folder
    archive_download = [] # files from archive download
    videolist = []

    for i in os.listdir(archive_folder):
        if os.path.isdir(os.path.join(archive_folder,i)):
            for j in os.listdir(os.path.join(archive_folder, i)):
                j1 = j[2:]
                j2 = j1.replace('-','')
                archive_files.append(j2)
        else:
            i1 = i[2:]
            i2 = i1.replace('-','')
            downloaded_files.append(i2)



    for i in os.listdir(video_dir):
        videolist.append(i)
              

    if date[:1] == '9' :
        tdate =  '19{0}' .format(date)
    else:
        tdate =  '20{0}' .format(date)

    if cutoff == None:
        cutoff = '1995' # apod started 1995 06 16

    if tdate <= cutoff:
        return 'cut-off'  
    try:
        downloaded_files.index(date)
        if msg >= 5:
            print('picture has been downloaded')
        return 'downloaded'                    #print('picture from {0} has already been downloaded' .format(pagedate))
    except:
        pass 
    try:
        archive_files.index(date)
        if msg >= 5:
            print('picture has been downloaded')
        return 'archived'                    #print('picture from {0} has already been downloaded' .format(pagedate))
    except:
        pass
    try:
        archive_download.index(date)
        if msg >= 5:
            print('picture has been downloaded by archive retrieval')
        return 'retrieved'
    except:
        pass
    try:
        videolist.index(date)
        if msg >= 5:
            print('picture is a video')
        return 'video file'
    except:
        if msg >= 5:
            print('picture is missing')
        return 'missing'



def download_apod_index(msg=def_msg, index=index_file):
    """Downloads the apod index file."""
    import urllib.request
    try:
        response = urllib.request.urlopen('http://antwrp.gsfc.nasa.gov/apod/archivepix.html')
        html = response.read()
        if msg > 3:
            print('downloaded apod index')
        check_file(index, create=True, msg=msg)
        f = open(index, 'wb')
        f.write(html)
        f.close()
    except:
        if msg >= 1:
            print('Fatal Error :: index page not found')
        sys.exit()


def build_name_list(msg=def_msg, index=index_file, names=namefile, cutoff=None):
    """Builds a name list."""

    check_file(names, create=True, msg=msg)
    data = []

    with open(index, 'r') as f:
        for line in f:
            if '<a href="ap' in line:
                i = line.split(':', 1)
                imgdate = i[1][13:19]
                imgname = i[1][26:-9]
                status = file_status(date=imgdate, msg=msg, cutoff=None)

                if imgdate[:1] == '9' :
                    imgfile =  '19{0}-{1}-{2}' .format(imgdate[:2], imgdate[2:4], imgdate[4:])
                else:
                    imgfile =  '20{0}-{1}-{2}' .format(imgdate[:2], imgdate[2:4], imgdate[4:])

                if msg >= 3:
                    print('found file : date = {0} : status = {1} : filename = {2}' .format(imgdate, status, imgfile))

                data.append('{0},{1},{2},{3} \n' .format(imgfile, imgdate, status, imgname))

                
    if msg >= 4:
        print('finished parsing index file')

    with open(namefile, 'w') as newf:
        for j in data:
            newf.writelines(j)

    if msg >= 4:
        print('written new name list')



#####################################################################
#####                          MACROS                           #####
#####################################################################

def download2(msg=def_msg, test=def_test, apodset=def_apodset, force_apod=def_force_apod, clear_apod=def_clear_apod, archive_apod=def_archive_apod):
    """Downloads and sets APOD picture."""
    if clear_apod:
        clear_date(msg=msg, test=test)

    if force_apod:
        if msg >= 3:
            print('download forced') 

    if get_date() !=  dtoday or force_apod:
        download_files(msg=msg, test=test, archive_apod=archive_apod)
    else:
        if msg >= 2:
            print('apod has already been downloaded today')
    set_apod(msg=msg, test=test, apodset=apodset) # #set apod picture





    
def archive_download(msg=def_msg, newindex=False, cutoff=None, test=def_test):
    """Search and download missing pictures from the APOD archive pages"""

    if newindex:
        regen_index(msg=msg, cutoff=cutoff)

    target_dates = []

    with open(namefile, 'r') as g:
        for line in g:
            i = line.split(',')
            if i[2] == 'missing':
                if file_status(date=i[1], msg=msg) == 'missing':
                    target_dates.append(i[1])
    if msg >= 4:
        print('target list built')

    target_dates.sort()

    for j in target_dates:
        if msg >= 4:
            print('')
        download_files(msg=msg, test=test, day=j, archive_apod=True)
        


#####################################################################
#####                     OPENBOX MENU                          #####
#####################################################################

def gen_obmenu_standard():
    import oblib
    oblib.pipe_start()
    oblib.item('APOD',      'apod.py --update')
    oblib.item('APOD Save', 'apod.py --save')
    oblib.item('APOD Force', 'apod.py --force')
    oblib.pipe_end()



def obmenu_archive_folders(t='pipe'):
    import oblib
    years = []
    for i in os.listdir(archive_folder):
        if os.path.isdir(os.path.join(archive_folder,i)):
            years.append(i)
    years.sort()
    years.reverse()

    if t == 'pipe':
        oblib.pipe_start()
    else:
        oblib.menu_start('Apod Archive')

    for k in years:
        oblib.item('Apod: {0}' .format(k), 'wallpaper.py --change {0}/{1}' .format(archive_folder, k))
    
    if t == 'pipe':
        oblib.pipe_end()
    else:
        oblib.menu_end()


#####################################################################
#####                   TEST FUNCTIONS                          #####
#####################################################################

def parser_options():
    print('Options are: {0}' .format(options))
    print('Args are : {0}' .format(args))
    print('Command is : {0}' .format(options.command))


def meta_info():
    if options.meta_source == None:
        print('No source specifieed')
    else:
        print('Script launched from source :: {0}' .format(options.meta_source))

def test_module(msg=def_msg):
    pass
    #gen_obmenu_arfolders()
    #unicode_test()
    #apod_archive_download(msg=msg)
    #print(check_list(args[0]))
    #regen_index(msg=msg)
    #print(get_name(fname=None, msg=msg))
    #print(len(saveprefix))

















#####################################################################
#####                    MAIN FUNCTION                          #####
#####################################################################

def Apod_Main(msg=def_msg):
    """Main functions."""
    command = options.command
    check_dir(work, create=True, msg=msg)

    if options.regen_index :
        regen_index(msg=msg, cutoff=options.cutoff)
        if command == None:
            command = 'pass'


    if command == "download":
        if msg > 3:
            print('Updating APOD')
        download2(msg=msg, test=options.test, apodset=options.apodset, force_apod=options.force, clear_apod=options.clear, archive_apod=options.archive)

    elif command == "download-only":
        if msg > 3:
            print('Downloading APOD picture only')
        download2(msg=msg, test=options.test, apodset=False, force_apod=options.force, clear_apod=options.clear, archive_apod=False)

    elif command == "last":
        if msg > 3:
            print('Setting last APOD')
        set_apod(apodlast, msg=msg, test=options.test, apodset=options.apodset)

    elif command == "save-today":
        apod_save('today', msg=msg, test=options.test)

    elif command == "save":
        apod_save('current', msg=msg, test=options.test)

    elif command == "set":
        if msg > 3:
            print('Setting APOD')
        set_apod(msg=msg, test=options.test, apodset=options.apodset)

    elif command == "restore":
        if msg > 3:
            print('Restoreing yesterdays APOD picture.')
        copy_file(apodlast, apodfile, msg=msg, test=options.test)
        set_apod(msg=msg, test=options.test, apodset=options.apodset)

    elif command == 'retrieve':
        archive_download(msg=msg, newindex=options.newindex, cutoff=options.cutoff)


    elif command == 'testmod':
        test_module(msg=msg)
    elif command == "TestNone":
        print('Test mode null op[tion')
    elif command == "pass":
        if msg >= 4:
            print('pass option has been called')

    elif not command == None:
        if msg >= 2:
            print('Warning :: Unrecognised command specified')
        #pass
    else:
        if msg >= 2:
            print('Warning :: no commands found, using default option')
        set_apod(msg=msg, test=options.test, apodset=options.apodset)



#####################################################################
#####                    SCRIPT STARTUP                         #####
#####################################################################

if __name__ == "__main__":

    parser = OptionParser(usage = "usage: %prog [download options] [command]", version="%prog {0}" .format(__version__),
                  description = "Script to manage APOD wallpapers.")


    parser.set_defaults(archive=def_archive_apod, apodset=def_apodset, command=None)

    standard = OptionGroup(parser, "Standard Options")
    doptions = OptionGroup(parser, "Download Options")
    aoptions = OptionGroup(parser, "Archive Options")
    metaopt = OptionGroup(parser, "Meta Info Options", "Further datails about the script startup useful for debugging")


    standard.add_option("-q", "--quiet",
                  action="store_true", dest="quiet", default=False,
                  help="only display warnings and errors")
    standard.add_option("-v", "--verbose",
                  action="store_true", dest="verbose", default=False,
                  help="display all output")
    standard.add_option("--debug",
                  action="store_true", dest="debug", default=False,
                  help="debug mode: detailed output of commands")
    standard.add_option("--really-quiet", 
                  action="store_true", dest="reallyquiet", default=False, help=SUPPRESS_HELP)
                  #help="only display errors")
    standard.add_option("--silent",
                  action="store_true", dest="silent", default=False, help=SUPPRESS_HELP)
                  #help="don't display any output")


    standard.add_option('-t', "--test",
                  action="store_true", dest="test", default=False, help=SUPPRESS_HELP)
                  #help="test mode :: only print output")
    standard.add_option("--test-mod",
                  action="store_const", const="testmod", dest="command", help=SUPPRESS_HELP)
                  #help="test mode :: use test function module")
    standard.add_option("--test-none", "--pass",
                  action="store_const", const="TestNone", dest="command", help=SUPPRESS_HELP)
                  #help="test mode :: no command specified")



    parser.add_option('-a', '-u', '--update',
                  action="store_const", const="download", dest="command",
                  help="Downloads and sets the wallpaper as todays APOD picture")
    parser.add_option("--save",
                  action="store_const", const="save", dest="command",
                  help="Saves the curent APOD wallpaper")
    parser.add_option("--set",
                  action="store_const", const="set", dest="command",
                  help="Sets wallpaper as APOD")
    parser.add_option('--download-only',
                  action="store_const", const="download-only", dest="command",
                  help="Only downloads todays APOD picture")
    parser.add_option("--last",
                  action="store_const", const="last", dest="command",
                  help="Sets the wallpaper as yesterdays APOD picture")
    parser.add_option("--restore",
                  action="store_const", const="restore", dest="command", help=SUPPRESS_HELP)
                  #help="Restores yesterdays APOD picture as todays.")

    aoptions.add_option("--retrieve", '--populate',
                  action="store_const", const="retrieve", dest="command",
                  help="Retrives archive APOD images from the APOD archive")
    aoptions.add_option("--regen-index",
                  action="store_true", dest="regen_index", default=False,
                  help="Regenerates the APOD index file")
    aoptions.add_option("--no-index",
                  action="store_false", dest="newindex", default=True, help=SUPPRESS_HELP)
                  #help="Do not build a nex index")

    aoptions.add_option("--cut-off",
                  metavar="Date", dest='cutoff', default=def_cutoff,
                  help="Cut off date for downloading archive pictures")
#    parser.add_option("--get-name",
#                  metavar="NAME", dest="getname", default=None,
#                  help="Returns the name of a pictures name")

    doptions.add_option("--force",
                  action="store_true", dest="force", default=def_force_apod,
                  help="Force the download of todays APOD picture")
    doptions.add_option("--clear",
                  action="store_true", dest="clear", default=def_clear_apod, help=SUPPRESS_HELP)
                  #help="resets the date of last APOD download.")
    doptions.add_option("--archive",
                  action="store_true", dest="archive",
                  help="If to archive a picture after download")
    doptions.add_option("--no-archive",
                  action="store_false", dest="archive",
                  help="If to archive a picture after download")
    doptions.add_option("--force-set",
                  action="store_true", dest="apodset", help=SUPPRESS_HELP)
                  #help="If to set the wallpaper as APOD.")
    doptions.add_option("--no-set",
                  action="store_false", dest="apodset", help=SUPPRESS_HELP)
                  #help="Skips setting APOD as wallpaper")



    metaopt.add_option("--meta-from",
                  metavar="Source", dest='meta_source', default=None,
                  help="Details from where the script was launched from")

    parser.add_option_group(doptions)
    parser.add_option_group(aoptions)
    parser.add_option_group(standard)
    #parser.add_option_group(metaopt)

    (options, args) = parser.parse_args()


    ## message level

    if options.debug == True:
        msg = 5
    elif options.verbose == True:
        msg = 4
    elif options.quiet == True: # warnings
        msg = 2
    elif options.reallyquiet == True: # errors only
        msg = 1
    elif options.silent == True:  # no output
        msg = 0
    else:
        msg = 3


    if options.debug:
        parser_options()
        meta_info()

    LockScript(Apod_Main, msg=msg)

pointone

Wiki Admin

From: Waterloo, ON

Registered: 2008-02-21

Posts: 379

Re: [python] setting a variable in a loaded module from the main script

I recommend you read this thread entirely:

http://mail.python.org/pipermail/tutor/ … 26734.html

Two wonderful solutions are presented.

---

M*cr*s*ft: Who needs quality when you have marketing?