#  $Date: 2009-12-07 19:11:09 -0700 (Mon, 07 Dec 2009) $
#  $Author: scott.hendrickson<at>buildingsi<dot>com $
#
##############################################
# Default resource files are named after class:
# class_name.properties
#
# If this class is the base class, then properties
# file is required.

import os, sys
import logging

class res:
    def __init__(self, logger=None,
                 resourceName=None):
        self.resourceValidFlag = False
        self.logger = logger
        self.resourceMap = {}
        # current path, path of script
        searchPaths = [os.getenv('PWD'),
                       sys.path[0]]
        if resourceName is None:
            filename = ''.join([self.__class__.__name__,
                                ".properties"])
        else:
            filename = ''.join([resourceName,
                                ".properties"])
        propFile = None
        for path in searchPaths:
            tmp = os.path.normpath(''.join([path,
                                            '/',
                                            filename]))
            if os.path.exists(tmp):
                propFile = tmp
        if propFile is not None:
            if self.logger is not None:
                self.logger.info("opening properties file %s" %
                                 filename)
            try:
                f = open(propFile, 'rb')
                for prop in f:
                    if prop[0] <> "#" and prop[0] <> '\n':
                        list = prop.split("=")
                        value = ''
                        for i in range(1,len(list)):
                            value += list[i] + "="
                        key = list[0]
                        value = value[:-1]
                        self.resourceMap[key] = value.strip("\n\r '\"").strip('\n\r')
                        if self.logger is not None:
                            self.logger.debug("property %s set to '%s'" %
                                              (key,
                                               self.resourceMap[key]))
                self.resourceValidFlag = True
            except IOError:
                if self.logger is not None:
                    self.logger.info("unable to read resource file %s" %
                                     propFile)
                else:
                    sys.stderr.write("unable to read resource file %s\n" %
                                     propFile)
        else:
            if self.logger is not None:
                self.logger.info("unable to find resource file %s in %s" %
                                 (filename,
                                  str(searchPaths)))
            else:
                sys.stderr.write("unable to find resource file %s in %s" %
                                 (filename,
                                  str(searchPaths)))

    def isValid(self):
        return self.resourceValidFlag

    def getString(self, key):
        if key in self.resourceMap:
            return self.resourceMap[key]
        else:
            if self.logger is not None:
                self.logger.error("resource %s missing" %
                                  key )
            else:
                sys.stderr.write("resource %s missing\n" %
                                 key )
        return None

Of course, with pretty code formatting, managing string constants and varying configurations within your Python code is not as inconvenient as with a compiled language. The main advantage is uniformity.  During maintenance or message changing tasks, you merely edit all of the *.properties files at once.  A secondary advantage has been the ability to use identical code for staging and production by using platform/environment-dependent properties like,

"SOURCE.hostname="/cygdrive/c/..."

accessed by the Python code snippet,

hostname = os.environ['HOSTNAME']

SOURCE = self.getString("SOURCE." + hostname)

I haven’t worked out Localization analogous to Java resources, but it seems like a natural extension.

To use the code, just add the module res to your PYTHON_PATH and use it as a base class for each object (named like the module, if you want foo.py and foo.properties, for example).

# Resource files are named after class:
# class_name.properties
#
# If this class is the base class, then properties
# file is required.

# Logging is standard Python logging framework

import sys

class res:
    def __init__(self, logger=None):
        self.logger = logger
        self.resMap = {}
        filename = ''.join([sys.path[0],'/',self.__class__.__name__,".properties"])
        if self.logger is not None:
            self.logger.info("opening properties file %s"%filename)
        try:
            f = open(filename, 'rb')
            for prop in f:
                if prop[0] <> "#" and prop[0] <> '\n':
                    list = prop.split("=")
                    value = ''
                    for i in range(1,len(list)):
                        value += list[i] + "="
                    key = list[0]
                    value = value[:-1]
                    self.resMap[key] = value.strip("\n\r '\"").strip('\n\r')
                    if self.logger is not None:
                        self.logger.debug("property %s set to '%s'"%(key, self.resMap[key]))
        except IOError:
            if self.logger is not None:
                self.logger.info("unable to read resource file %s"%filename)
            else:
                sys.stderr.write("unable to read resource file %s\n"%filename)

    def getString(self, key):
        if key in self.resMap:
            return self.resMap[key]
        else:
            if self.logger is not None:
                self.logger.error("resource %s missing"%key )
            else:
                sys.stderr.write("resource %s missing\n"%key )
        return ""

Be sure to call res’s __init__ function for your class. Notice you can call it with a logger reference if you are using Python logging.

class test1(res.res):
    def __init__(self):
        res.res.__init__(self)

To access a property,

case1.getString("key1")

where the properties file looks just like it’s Java counterpart. If you try it out or make any extensions, let me know how it goes.