Noob component design issue

Question

Updated question, see below.

I am starting a new project and I would like to experiment with component-based architecture (I chose PyProtocols ). This is a small program to display and attach with real-time graphics.

I started by developing custom input components:

• IInputDevice - for example. mouse, keyboard, etc. An InputDevice can have one or more output channels:
  • IOutput - an output channel containing a single value (for example, a MIDI slider value)
  • ISequenceOutput - an output channel containing a sequence of values ​​(for example, 2 integers representing the position of the mouse)
  • IDictOutput - an output channel containing named values ​​(for example, the state of each keyboard key indexed by keyboard characters)

Now I would like to define the interfaces for filtering these outputs (smooth, jittery, inverted, etc.).

My first approach was to create an InputFilter interface, which had different filtering methods for each type of output channel to which it was connected ... But the introduction to the PyProtocols documentation clearly says that the entire interface and adapters are about checking type exceptions!

So, I assume that my InputFilter interfaces should look like this:

• IInputFilter - IOutput filters
• ISequenceInputFilter - ISequenceOutput filters
• IDictInputFilter - IDictOutput filters

connect() * Ouptut, , .

, :

class InputFilter(object):
    """
    Basic InputFilter implementation. 
    """

    advise(
            instancesProvide=[IInputFilter],
        )

    def __init__(self):
        self.parameters = {}

    def connect(self, src):
        self.src = src

    def read(self):
        return self.src.read()


class InvertInputFilter(InputFilter):
    """
    A filter inverting single values.
    """

    def read(self):
        return -self.src.read()


class InvertSequenceInputFilter(InputFilter):
    """
    A filter inverting sequences of values.
    """

    advise(
            instancesProvide=[ISequenceInputFilter],
            asAdapterForProtocols=[IInputFilter],
        )

    def __init__(self, ob):
        self.ob = ob

    def read(self):
        res = [] 
        for value in self.src.read():
            res.append(-value)
        return res

:

filter = InvertInputFilter()
single_filter = IInputFilter(filter)           # noop
sequence_filter = ISequenceInputFilter(filter) # creates an InvertSequenceInputFilter instance

single_filter sequence_filter . , InputFilter , :

TypeError: ('Ambiguous adapter choice', <class 'InvertSequenceInputFilter'>, <class 'SomeOtherSequenceInputFilter'>, 1, 1)

- , ? , , , InputFilterS?

2

, , , , , , (, !).

, ( dict):

class IInputFilter(Interface):

    def read():
        pass

    def connect(src):
        pass


class ISingleInputFilter(Interface):        

    def read_single():
        pass


class ISequenceInputFilter(Interface):

    def read_sequence():
        pass

, IInputFilter , , ISingleInputFilter ISequenceInputFilter . :

class SingleInputFilterAsInputFilter(object):

    advise(
            instancesProvide=[IInputFilter],
            asAdapterForProtocols=[ISingleInputFilter],
        )

    def __init__(self, ob):
        self.read = ob.read_single


class SequenceInputFilterAsInputFilter(object):

    advise(
            instancesProvide=[IInputFilter],
            asAdapterForProtocols=[ISequenceInputFilter],
        )

    def __init__(self, ob):
        self.read = ob.read_sequence

InvertInputFilter :

class InvertInputFilter(object):

    advise(
            instancesProvide=[
                    ISingleInputFilter, 
                    ISequenceInputFilter
                ]
        )

    def read_single(self):
        # Return single value inverted

    def read_sequence(self):
        # Return sequence of inverted values 

, :

filter = InvertInputFilter()
single_filter = SingleInputFilterAsInputFilter(filter)
sequence_filter = SequenceInputFilterAsInputFilter(filter)

, , , InvertInputFilter:

TypeError: ('Ambiguous adapter choice', <class 'SingleInputFilterAsInputFilter'>, <class 'SequenceInputFilterAsInputFilter'>, 2, 2)

( , instanceProvide)

3

PEAK , PyProtocols, . zope.interface, .

Answer 1

PyProtocols, Zope Component Architecture, , .

, , . . , , " ".

, , . Zope . ''. , "" "", , , .

, , . , . , dict , , . .