Helper classes design question

[Peter Otten]

John O'Hagan wrote:

> I want to know the best way to organise a bunch of functions designed to
> operate on instances of a given class without cluttering the class itself
> with a bunch of unrelated methods.
> 
> What I've done is make what I think are called helper classes, each of
> which are initialized with an instance of the main class and has methods
> which are all of the same type (insofar as they return a boolean, or
> modify the object in place, or whatever).
> 
> I'm not sure if I'm on the right track here design-wise. Maybe this could
> be better done with inheritance (not my forte), but my first thought is
> that no, the helper classes (if that's what they are) are not actually a
> type of the main class, but are auxiliary to it.
> 
> Here's what I've done:
> 
> I have a class MySequence which is initialized with a number sequence (in
> a list), which has a bunch of methods which deal with various (musical)
> properties of the sequence. Toy example:
> 
> class MySequence(object):
>     """MySequence, a representation musical sequences as numbers.
>         Its methods return various characteristics of the sequence."""
>     def __init__(self, sequence):
>         self.pitches = sequence[:]
>     def pcset(self):
>         """Example method: The pitch class set
>             derived from the sequence"""
>         return sorted(list(set([ i % 12 for i in self.pitches])))
> 
> A generator function spits out MySequence objects, and I want to filter
> them (i.e. reject those which do not meet certain criteria) and then be
> able to modify them in various ways. For that I have two classes; toy
> examples:
> 
> class SeqTest(object):
>     """SeqTest, initialized with a MySequence object. Its methods
>         return the boolean result of tests against the Sequence object."""
>     def __init__(self, myseq_obj):
>         self.seq = myseq_obj
>     def degrees(self, degrees):
>         """Example method: Test for certain members, passed as list"""
>         return all(i in self.seq.pcset() for i in degrees)
> 
> class SeqMod(object):
>     """A SeqMod object's methods modify in place
>         the MySequence object with which it is initialized """
>     def __init__(self, myseq_obj):
>         self.seq = myseq_obj
>     def rotate(self, num):
>         """Example method: Rotate pitches  by n steps"""
>         self.seq.pitches = self.seq.pitches[-num:] +
>         self.seq.pitches[:-num]
> 
> 
> And here is a toy version of how I'm using them with the generator:
> 
> def seq_factory(generator_func, test_opts, mod_opts):
>     """Yields Sequence objects, filtered and modified.
>     Opts are dictionaries."""
>     for sequence in generator_func:
>         seq = MySequence(sequence)
>         tester = SeqTest(seq)
>         if any (not getattr(tester, opt)(value)
>             for opt, value in test_opts.items()):
>             continue
>         modifier = SeqMod(seq)
>         for opt, value in mod_opts.items():
>             getattr(modifier, opt)(value)
>         yield seq
> 
> 
> Used, say, like this:
> 
> generator_func = (range(n, n+5) for n in range(5))
> test_opts = {'degrees': [5,7]}
> mod_opts = {'rotate': 3}
> 
> for i in seq_factory(generator_func, test_opts, mod_opts):
>     print i.pitches
> 
> Which yields:
> 
> [5, 6, 7, 3, 4]
> [6, 7, 8, 4, 5]
> 
> It actually works well, so there's no real problem apart from wanting to
> know if this is a good way to do what I want.
> 
> Thanks for any wise words,

As far as I can see the SeqMod and SeqTest classes don't keep any state 
apart from the sequence instance. Therefore functions instead of methods 
would do as well:

from functools import partial

class MySequence(object):
    def __init__(self, sequence):
        self.pitches = sequence[:]
    def pcset(self):
        return sorted(list(set([ i % 12 for i in self.pitches])))

def degrees(seq, degrees):
    return all(i in seq.pcset() for i in degrees)

def rotate(seq, num):
    seq.pitches = seq.pitches[-num:] + seq.pitches[:-num]

def seq_factory(sequences, tests, modifications):
    for seq in sequences:
        if all(test(seq) for test in tests):
            for modify in modifications:
                modify(seq)
            yield seq

sequences = (MySequence(range(n, n+5)) for n in range(5))
tests = [
    partial(degrees, degrees=[5,7]),
    # ...
]
modifications = [
    partial(rotate, num=3),
    # ...
]

for i in seq_factory(sequences, tests, modifications):
    print i.pitches

When you see that your module becomes too messy move the testing and 
modifying functions into separate modules that are part of the same package.

Peter