For me, that time is now, that library is ConfigParser, and the replacement is included below the fold. It’s called conf, and it means that the only interaction you as a programmer are required to have with your config file is to assign and/or read values to/from it. Assigning and reading look exactly like normal attribute assignment/reading.

Subversion/TRAC string: https://svn.coriolinus.net/OOconf
distutils packaged version: conf-0.2.0

As always, I’m too cheap to pay a thousand dollars for a site certificate, so please ignore any certificate mismatch errors you encounter when viewing the https side of the site. If you don’t trust me enough to click through, you’ll still find the current version under the fold.

import os
import codecs
import json
from ConfigParser import SafeConfigParser

def internal(func):
	def tf(self, *args, **kwargs):
		self.__dict__['__conf__'].__dict__['__internal__'] += 1
		try:
			return func(self, *args, **kwargs)
		finally:
			self.__dict__['__conf__'].__dict__['__internal__'] -= 1
	return tf

class Section(object):
	def __init__(self, conf, name, fullname=None):
		if fullname is None:
			fullname = name

		self.__dict__['__conf__'] = conf
		self.__name__ = name
		self.__fullname__ = fullname

		self.__dict__['subsections'] = set()
		self.__dict__['attributes'] = set()

		#this lines MUST be the last in __init__
		self.__restrictedvars__ = set((i for i in dir(self) if '__' not in i))

	@internal
	def __setattr__(self, name, value):
		if self.restricted(name):
			if (not self.__conf__.__restrict__) or self.__conf__.__internal__ > 0:
				self.__dict__[name] = value
			else:
				raise AttributeError("Namespace conflict: %s restricted for Conf use." % name)
		else:
			self.__conf__.__new_data__ = True
			self.attributes.add(name)
			self.__conf__.__cp__.set(self.__fullname__, name, json.dumps(value))

	@internal
	def __getattr__(self, name):
		if self.restricted(name):
			return self.__dict__[name]
		else:
			return json.loads(self.__conf__.__cp__.get(self.__fullname__, name))

	@internal
	def __delattr__(self, name):
		if self.restricted(name):
			if (not self.__conf__.__restrict__) or self.__conf__.__internal__ > 0:
				del self.__dict__[name]
			else:
				raise AttributeError("Namespace conflict: %s restricted for Conf use." % name)
		else:
			self.__conf__.__new_data__ = True
			self.attributes.remove(name)
			self.__conf__.__cp__.remove_option(self.__name__, name)

	@internal
	def restricted(self, name):
		"""
		This function returns true for all attributes which should be stored locally, not in the
		configuration file proper.
		"""
		if name.startswith('__') or name.endswith('__'):
			return True
		if name in self.__restrictedvars__:
			return True

		return False

	@internal
	def add_section(self, name):
		fullname = ''.join((self.__fullname__, '.', name))

		if hasattr(self, name):
			raise ValueError("Namespace conflict: %s already in use" % fullname)

		if not self.__conf__.__cp__.has_section(fullname):
			self.__conf__.__cp__.add_section(fullname)
		self.subsections.add(name)
		self.__dict__[name] = Section(self.__conf__, name, fullname)
		self.__restrictedvars__.add(name)
		self.__new_data__ = True

	@internal
	def remove_section(self, name):
		fullname = ''.join((self.__fullname__, '.', name))

		if not hasattr(self, name):
			raise ValueError("Can't remove section %s, as it doesn't exist" % fullname)

		sub = getattr(self, name)
		for subsub in list(sub.subsections):
			sub.remove_section(subsub)

		self.__conf__.__cp__.remove_section(fullname)
		self.subsections.remove(name)
		self.__restrictedvars__.remove(name)
		del self.__dict__[name]
		self.__new_data__ = True

class Conf(Section):
	"""
	Automatic storage and retrieval of arbitrary values into a config file. 

	Uses type information and automatic reconversions to store a variety of primitive types in a
	perfectly human-readable format. Primitive types are those encodable by the json module.

	Usage:
	>>> from conf import Conf
	>>> conf = Conf() #or Conf(filename, defaultsectionname)
	>>> conf.foo = 'hello world'
	>>> conf.bar = 723
	>>> conf.baz = False
	>>> conf.flush()

	[exit, start a new session here]

	>>> conf = Conf()
	>>> conf.foo
	'hello world'
	>>> conf.bar
	723
	>>> conf.baz
	False

	If you want implicit file creation, you need to use a with statement:
	>>> with Conf() as conf:
	...      conf.foo = 2783.1
	...
	>>> del conf
	>>> with Conf() as otherConf:
	...      otherConf.foo
	...
	2783.1
	"""
	def __init__(self, filename ='.conf', sectionName=None):
		"""
		Initialize a new Conf object.
		"""
		self.__dict__['__internal__'] = 0
		self.__dict__['__restrict__'] = False
		#the above is magic; it must come first

		#sanity check
		if sectionName is not None and '.' in sectionName:
			raise ValueError("Namespace: '.' cannot be part of a section name")

		#initialize the superclass
		Section.__init__(self, self, sectionName if sectionName is not None else 'config')

		self.__filename__ = filename
		self.__cp__ = SafeConfigParser()

		#load and initialize the configparser
		if os.path.exists(filename):
			with codecs.open(filename, 'rb', 'utf8') as cf:
				self.__cp__.readfp(cf, filename)

		if sectionName is None:
			topLevelSections = [s for s in self.__cp__.sections() if s.count('.') == 0]
			if len(topLevelSections) == 1:
				sectionName = topLevelSections[0]
				self.__name__ = sectionName
				self.__fullname__ = sectionName
			else:
				sectionName = 'config'

		#create the default section
		if not self.__cp__.has_section(sectionName):
			self.__cp__.add_section(sectionName)

		#load default section attributes
		self.attributes = set(self.__cp__.options(sectionName))

		#load the various sections
		#first, sort them by the number of dots they contain
		secs = [(s.count('.'), s) for s in self.__cp__.sections() if s != sectionName]
		secs.sort()
		for name in [sec for count, sec in secs]:
			if '.' not in name:
				self.subsections.add(name)
				self.__dict__[name] = Section(self, name)
				self.__dict__[name].attributes = set(self.__cp__.options(name))
				self.__restrictedvars__.add(name)
			else:
				fullname = name
				rest, name = name.rsplit('.', 1)
				sec = self
				for part in rest.split('.'):
					sec = getattr(sec, part)
				sec.subsections.add(name)
				sec.__dict__[name] = Section(self, name, fullname)
				sec.__dict__[name].attributes = set(self.__cp__.options(fullname))
				sec.__restrictedvars__.add(name)

		self.__new_data__ = False

		#this must come last:
		self.__internal__ = 0
		self.__restrict__ = True
		#This is used in combination with the @internal decorator. Each method so decorated
		# increments this variable on entry, and decrements it on exit. They can then check: is
		# __internal__ > 0? If yes, they were called from within this Conf object, and can adjust
		# their behavior accordingly.
		#
		#Note that we initialize it here to 0. When this __init__ exits, it decrements to -1. This
		# is intentional. Since each internal function starts by incrementing it, this means that
		# only if the variable is > 0 was its caller also internal.

	@internal
	def __enter__(self):
		return self

	@internal
	def __exit__(self, exc_type, exc_value, traceback):
		if self.__new_data__:
			self.flush()

	@internal
	def flush(self):
		with codecs.open(self.__filename__, 'wb', 'utf8') as cf:
			self.__cp__.write(cf)
		self.__new_data__ = False

	@internal
	def add_section(self, name):
		"""
		Create a new section in the conf file. This will become a dotted extension of the conf object.

		For example:
		>>> c = Conf()
		>>> c.foo = 'hello world'
		>>> c.add_section('bar')
		>>> c.bar.baz = 'world says hello'

		The above turns into a config file which looks like this:
		[config]
		foo = hello world

		[bar]
		baz = world says hello
		"""
		if hasattr(self, name):
			raise ValueError("Namespace conflict: %s already in use" % name)
		if '.' in name:
			raise ValueError("Namespace: '.' cannot be part of a section name")

		if not self.__conf__.__cp__.has_section(name):
			self.__conf__.__cp__.add_section(name)
		self.subsections.add(name)
		self.__dict__[name] = Section(self, name)
		self.__restrictedvars__.add(name)
		self.__new_data__ = True

	@internal
	def remove_section(self, name):
		"""
		Remove a section and all included data.
		"""
		if not hasattr(self, name):
			raise ValueError("Can't remove section %s, as it doesn't exist" % name)

		sub = getattr(self, name)
		for subsub in sub.subsections:
			sub.remove_section(subsub)

		self.__cp__.remove_section(name)
		self.subsections.remove(name)
		self.__restrictedvars__.remove(name)
		del self.__dict__[name]
		self.__new_data__ = True

conf.py by coriolinus is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License.
Permissions beyond the scope of this license may be available at http://www.coriolinus.net/contact/.

Perl is an agglomeration of functionality combining the worst of incomprehensibly terse unix syntax with the worst of every other incomprehensibly terse syntax Larry Wall could get ahold of.

There are people who love Perl. Who enjoy producing write-only code. Who are proud that an incredibly high percentage of completely random files will be parsed, will do something legal, in Perl. This disgusts me.

I find it hard to look past the fact that in at least five of the last ten or so times an automated build of something I didn’t write failed, the specific component which failed either was a Perl component or was written in Perl.

I would be almost tempted to look deeper for the source of the problem, maybe to fix it–if I didn’t have to deal with Perl.

I sometimes think that Perl was a compromise, or an experiment, to determine exactly how horrible an interpreted language could be and still be widely adopted. Funge was the first experiment. Perl was the second. This astounded the researchers, who had planned a course of twelve, culminating in python. They later released python anyway out of pity.

In a normal language, to access the contents of a variable, you ask for the variable: foo. In Perl, you ask for $@%$foo. The implied profanity cannot be accidental. Actually, scratch the ‘implied’, because you really needed to write $$@%foo and your program doesn’t work and this error is actually impossible for a human to debug.

This leads to the speculation that Larry Wall is the leader of a race of bugs–think Men in Black–who came to Earth to right an injustice which really was only a poor translation. His mission: to do battle with all programmers who want to eliminate bugs from their code. His tactic: release a language in which bugs proliferate like cockroaches in a dump. I’m not saying this is the truth. But it’s possible.

It’s just that it’s so incredibly picky.

Say that, for some reason, you want to include a GUI checkbox in a program. You can drop one in with no problems at all; it looks like a checkbox, it can be checked and unchecked, it has a string attached, all seems good. Then, say you want to find out what is the state of the checkbox. It turns out to be LITERALLY IMPOSSIBLE. You are REQUIRED to use Java’s event-driven methodology, which means more work, and more coding time. The checkbox MUST remember its own state internally; it just refuses to tell you. It’ll fire off an event, in case you’ve attached a listener, but that really seems like a whole lot of work to just retrieve a boolean value from a component.

I’m going to go to sleep, and work on this more tomorrow. I wish there was a language that combined the best features of Java and Perl. That is, I want it to be universally supported, have quick and easy GUI applications… and not enforce a specific programming style on you. Because maybe if you’re handling 40 checkboxes in a single page, an event driven model really is easier to code and reduces bugs and all that. But when you’ve got a single checkbox, in its own container class with some other things, and you just want the state so you can write the toString() for the container class… it’s just annoying.

This leads to an odd procrastination problem whereby I do cool things on the computer that make me happy, and to some extent are actual accomplishments, instead of doing the boring work which is typically easier, and a requirement for one course or another. It’s not that I’m not being productive, it’s just that what I’m producing isn’t what the courses are asking for.

I wish I could trade in, perhaps, the Perl music-fixing program and a working webcomics directory instead of my ethics of computation essay.

The short story is that my computer died, and that I’m using a public machine right now (and for the conceivable future) because I can no longer log into my own.

I guess that the Perl will have to wait a little bit longer.

You know, I’m not sure I ever got around to mentioning what program I’m writing, or why I’m using Perl to write it. I’m going to quote the Program Spec:

The purpose of MusicFix is simple: to clean your music directory of duplicate files, and fix oddly formatted filenames. To use it, simply specify the root of a music directory.

MusicFix will recursively traverse that directory. It will then target and fix several odd filename formats… [cut for length] All filenames will then be normalized… [cut for length] While doing this renaming, some files may run into duplicates as their names become standardized. In this case, MusicFix will delete the smaller of the two files.

It does some other relatively minor stuff, but nothing too exciting. The thing to keep in mind is that this is a dangerous program: its main purpose is to rename and delete files, based on its own ideas of what is RIGHT. I’m going to test it out pretty thoroughly before letting it anywhere near my actual music. Once it’s ready, though, I’m going to make it available for public consumption, because I get the impression that I’m not the only person who’s sick of having music on my system which was apparantly ripped by a chimpanzee, to look at the filename.

Oh, and the reason I’m learning an entirely new language for this project is twofold. One, I haven’t learned Perl yet, but it’s been on my list of languages to get a feel of for quite some time now. I figure that writing a moderately complex utility in a language qualifies you to say you’ve got a feel for it. The other reason is that Perl was designed especially to handle weird regular expressions, which are the simplest way to handle the problem of extracting the information we want from the filenames and rewriting them to make sense.

On a related note, I just borrowed a manual from a friend of mine. On the back, it says “Teach yourself all about programming with Perl5 in a week!” I wonder if the authors realized that the average buyer of this book would be either a computer science student or professional programmer, and would therefore be able to pick up most of the applicable concepts with an expended effort of only a few hours? How many people who don’t otherwise know anything about programming would even believe such a claim?

### dirread.pl
# this is a test program
# it tries to read the names of files in a directory to a file

print “Please enter the name of the directory you want to list.\n”;
print “Be careful of capitalization.\n”;
print “: “;

$dirname = <STDIN>;

# ok, i’ve got the name of the directory to read; now how about opening the output stream?

open(OUT, ‘> filelist.txt’) or die “can’t open file for output! $!”;

# what are the chances that eliminating the error handling code eliminates the error?
# nope, that just eliminated the error message. putting back the code.
opendir(DIR, $dirname) or die “can’t opendir $dirname: $!”;
while (defined($file = readdir(DIR))) {
# do something with “$dirname/$file”
print OUT $file . “\n”;
}
closedir(DIR);

### simpledirtest.pl
opendir(DIR, “.”); # . is the current directory

while ( $filename = readdir(DIR) ) {
print $filename , “\n”;
}

closedir DIR;

Then, I have output as follows:

C:\My Documents\programs\perl\musicfix\test>perl -w simpledirtest.pl
.
..
a.txt
renamer.pl
test.txt
testout.pl
filelist.txt
simpledirtest.pl
dirread.pl

C:\My Documents\programs\perl\musicfix\test>perl -w dirread.pl
Please enter the name of the directory you want to list.
Be careful of capitalization.
: .
can’t opendir .
: No such file or directory at dirread.pl line 16, line 1.

C:\My Documents\programs\perl\musicfix\test>

Somebody, anybody, please tell me why this doesn’t work. I’m tearing my hair out here.

This is a good thing. I intend to learn it enough to write a functional program to fix my .mp3 filetags by tomorrow, having no previous knowledge of the language.

The fun part about working with frames is that I can keep the old php code in all the other frames where it’s still the best-suited language.