omde.score
index
/usr/local/lib/python2.1/site-packages/omde/score.py

Base classes for OMDE events and co.
 
Here you find the base classes for events and
aggregates, the basic elements of OMDE compositions.

 
Modules
            
cPickle
copy
types

 
Classes
            
Spot
Event
Aggregate
PseudoEvent

 
class Aggregate(Event)
      A container for Events.
 
It is also an Event subclass and can also contain other Aggregate.
 
Development notes:
Overrides Event.[onset(), duration(), end()]
 
  
__add__(self, object)
Add operator implementation
 
Clone the aggregate and add the object.
 
>>> x = Aggregate()
>>> x = x + Event(0, 1) + Event(10, 20) + Event(21, 1)
>>> for e in x.list:
...    print e.onset(), e.end()
...
0 1
10 30
21 22
>>> print x.onset(), x.end()
0 30
__init__(self, *args)
Return an Aggregate instance.
__len__(self)
Return the length of the Aggregate as the number
of object directly contained.
 
It is not recursive!
 
>>> len(Aggregate(Event(0,1), Event(1,2), Event(2,3)))
3
_invalidate_cache(self)
_is_cache_valid(self)
_update_cache(self)
add(self, *objects)
Extends the list of contained events with the arguments.
append(self, *objects)
Append the arguments to the list of contained objects.
 
append(object [...])
 
>>> x = Aggregate(Event(0, 1), Event(2, 1), Event(3, 1))
>>> x.append(Event(10, 1))
>>> for e in x.list:
...   print e.onset(), e.end()
...
0 1
2 3
3 4
10 11
>>> print x.onset(), x.end()
0 11
apply(self, callable, *args)
Call callable passing each of the contained objects as first argument.
 
Options arguments are passed thru.
 
Same as apply_for_real().
apply_for_real(self, callable, *args)
Call callable passing each of the contained objects as first argument.
 
Options arguments are passed thru.
calc_begin_duration(self)
This returns the first beginning time and
overall duration span of the entire Aggregate.
 
>>> x = Aggregate(Event(10, 20), Event(100, 1))
>>> start, dur = x.calc_begin_duration()
>>> print start, dur
10 91
>>> (start, start + dur) == x.calc_begin_end()
1
calc_begin_end(self)
Calculate start and end times for the entire aggregate based
on those of all contained events.
 
>>> x = Aggregate(Event(10, 1), Event(42, 0), Event(1, 99))
>>> print x.calc_begin_end()
(1, 100)
>>> x.onset(), x.end()
(1, 100)
calc_onset_min_max(self)
Returns the largest and smallest onset times of the contained events.
 
>>> x = Aggregate(Event(10, 1), Event(42, 0), Event(1, 99))
>>> print x.calc_onset_min_max()
(1, 42)
clone(self)
Clone aggregate.
 
A fresh copy of the aggregate and all contained
object is returned.
disjoint(self)
Adjust first-level contained event so that they don't overlap.
dump(self, file_or_filename)
Dump an aggregate to a file as binary object.
 
file_or_filename may be a file name (as a string)
or a file already open in write mode.
Everything else raises a ValueError exception.
duration(self, duration=None)
Return the duration of the event.
If an argument is given, the duration is stretched by that amount,
affecting sub-objects.
 
>>> x = Aggregate(Event(10,1), Event(20,1))
>>> x.duration()
11
>>> x.duration(x.duration() * 2)
>>> for e in x.list:
...     print e.onset(), e.end()
10.0 12.0
30.0 32.0
end(self, end=None)
This method returns the end time of the Aggregate.
 
>>> x = Aggregate(Event(0,1), Event(10,1), Event(20,1))
>>> x.end()
21
>>> x.onset(50)
>>> x.end()
71
extend(self, aggregate)
Extend this aggregate using the events contained
in the agregate passed as argument.
 
>>> x = Aggregate(Event(0, 1), Event(2, 1))
>>> y = x.clone()
>>> y.move(10, 'relative')
>>> x.extend(y)
>>> for e in x.list:
...    print e.onset(), e.end()
...
0 1
2 3
10 11
12 13
>>> print x.onset(), x.end()
0 13
extract_event_if(self, predicate)
Extract (by copy) event that match the given predicate.
 
The hierarchical structure is preserved but
resulting empty aggregates (that is aggregates containing
no matching events) are deleted.
flatten(self)
Make this aggregate flat.
load(self, file_or_filename)
Loads an aggregate from a file created with dump().
 
file_or_filename may be a file name (as a string)
or a file already open in read mode.
Everything else raises a ValueError exception.
move(self, time, mode='absolute')
Perform a translation on time exis.
 
mode can be 'absolute' or 'relative'. Default value is 'absolute'.
This method affects onset but not duration. It can raise
ValueError if an uknown mode is passed.
 
>>> x = Aggregate(Event(0, 1), Event(2, 1))
>>> x.move(10, 'absolute')
>>> print x.onset(), x.end()
10 13
>>> x.move(-5, 'relative')
>>> print x.onset(), x.end()
5 8
>>> x.move(10, 'spam')
Traceback (most recent call last):
...
ValueError: Translation mode can only be 'absolute' or 'relative' (got spam)
move_absolute(self, time)
Perform an absolute translation on the time axis.
 
This method affects onset but not duration.
move_relative(self, time)
Perform a relative translation on the time axis.
 
This method affects onset but not duration.
onset(self, onset=None)
Get (without arguments) or set (with 1 argument)
the onset time of the event.
 
>>> x = Aggregate(Event(0, 1), Event(10,1), Event(20,1))
>>> x.onset()
0
>>> print [e.onset() for e in x.list]
...
[0, 10, 20]
>>> x.onset(5)
>>> print [e.onset() for e in x.list]
...
[5, 15, 25]
>>> x.onset(-2)
>>> print [e.onset() for e in x.list]
...
[-2, 8, 18]
stretch(self, alpha, mode='absolute', direction='forward') from Event
stretch_absolute_backward(self, time) from Event
stretch_absolute_forward(self, time)
Set the overall duration to time.
 
Sub-events have their onset and duration adjusted
appropriately, relative to the first onset which is not
changed.
 
>>> x = Aggregate(Event(10,1), Event(12,1), Event(20,10))
>>> for e in x.list:
...   print e.onset(), e.end()
...
10 11
12 13
20 30
>>> x.stretch_absolute_forward(4)
>>> for e in x.list:
...   print e.onset(), e.end()
...
10.0 10.2
10.4 10.6
12.0 14.0
stretch_relative_backward(self, alpha) from Event
stretch_relative_forward(self, alpha)
Set the overall duration to time.
 
Sub-events have their onset and duration adjusted
appropriately, relative to the first onset which is not
changed.
 
(Note to Maurizio: This seemed like the most appropriate
interpretation to me!)
 
>>> x = Aggregate(Event(10,1), Event(12,1), Event(20,10))
>>> for e in x.list:
...   print e.onset(), e.end()
...
10 11
12 13
20 30
>>> x.stretch_absolute_forward(4)
>>> for e in x.list:
...   print e.onset(), e.end()
...
10.0 10.2
10.4 10.6
12.0 14.0
timewarp(self, time, mode='absolute')
Perform time warping (absolute mode) or time adjusting (relative mode)
of the contained events.
 
timewarp(time[, mode='absolute'])
 
time must be a function of time to time.
 
One of the way to get such a function is using the Tempo class
in omde.csound.
unwind(self)
Unwind list of contained objects.
Returns a single flat list (not an Aggregate!).
 
>>> x = Aggregate(Event(10,1), Event(20, 1),
...               Aggregate(Event(5,5),Event(6,6),
...                         Aggregate(Event(99,99))
...                        )
...               )
>>> flat = x.unwind()
>>> len(flat)
5
>>> for e in flat: print e.onset(), e.end()
...
10 11
20 21
5 10
6 12
99 198

 
class Event(Spot)
      Events are Spots with a duration.
 
  
__init__(self, onset, duration)
Return an Event instance.
 
onset is the onset time of the event.
duration is the duration of the event.
apply(self, callable, *args) from Spot
apply_for_real(self, callable, *args) from Spot
duration(self, duration=None)
Return the duration of the event.
>>> x = Event(0, 4)
>>> x.duration()
4
>>> x.duration(9)
>>> x.duration()
9
end(self, end=None)
Return the end time of the event.
 
>>> x = Event(1, 4)
>>> x.end()
5
>>> x.duration(x.duration() - 1.5)
>>> x.end()
3.5
move(self, time, mode='absolute') from Spot
move_absolute(self, onset) from Spot
move_relative(self, time) from Spot
onset(self, onset=None) from Spot
stretch(self, alpha, mode='absolute', direction='forward')
Perform a duration stretching.
 
mode can be 'absolute' or 'relative'. Default is 'absolute'
direction can be:
'forward' (onset is preserved, only duration is affected) (default)
'backward' (end point is preserved, duration and offset are modified)
 
>>> x = Event(10, 10)
>>> x.stretch(5)
>>> x.onset(), x.duration(), x.end()
(10, 5, 15)
>>> x.stretch(5, mode='relative')
>>> x.onset(), x.duration(), x.end()
(10, 25, 35)
>>> x.stretch(5, mode='absolute', direction='backward')
>>> x.onset(), x.duration(), x.end()
(30, 5, 35)
>>> x.stretch(5, mode='relative', direction='backward')
>>> x.onset(), x.duration(), x.end()
(10, 25, 35)
stretch_absolute_backward(self, time)
Perform and absolute backward stretch
 
Absolute backward stretch means that end time remains
unchanged and duration is set to 'time'.
Onset is adjusted accordingly.
 
>>> x = Event(10, 10)
>>> x.onset(), x.duration(), x.end()
(10, 10, 20)
>>> x.stretch_absolute_backward(5)
>>> x.onset(), x.duration(), x.end()
(15, 5, 20)
stretch_absolute_forward(self, time)
Stretch the event forward.
 
onset is not affected; duration is set to 'time'.
 
>>> x = Event(10, 10)
>>> x.onset(), x.duration(), x.end()
(10, 10, 20)
>>> x.stretch_absolute_forward(6)
>>> x.onset(), x.duration(), x.end()        
(10, 6, 16)
stretch_relative_backward(self, alpha)
Perform a relative backward stretch.
 
Relative backward stretch keeps the end time unchanged
but scales the duration by alpha and adjusts onset accordingly.
 
>>> x = Event(10, 10)
>>> x.onset(), x.duration(), x.end()
(10, 10, 20)
>>> x.stretch_relative_backward(2)
>>> x.onset(), x.duration(), x.end()
(0, 20, 20)
>>> x.stretch_relative_backward(0.2)
>>> x.onset(), x.duration(), x.end()
(16.0, 4.0, 20.0)
stretch_relative_forward(self, alpha)
Keep the onset unchanged, but scale the duration by alpha.
 
>>> x = Event(10, 10)
>>> x.onset(), x.duration(), x.end()
(10, 10, 20)
>>> x.stretch_relative_forward(5)
>>> x.onset(), x.duration(), x.end()
(10, 50, 60)

 
class PseudoEvent(Event)
      PseudoEvent is place older for complex events
or large Aggregates of event.
PseudoEvent subclasses in general have an higher level
(more abstract) interface.
 
  
__init__(self, onset, duration)
Return a PseudoEvent instance.
 
onset and duration as in Event.
apply(self, callable, *args) from Spot
apply_for_real(self, callable, *args)
Realize the PseudoEvent and call callable passing
the resulting object as first argument.
 
Options arguments are passed thru.
 
Overrides the Event's method with the same name.
duration(self, duration=None) from Event
end(self, end=None) from Event
move(self, time, mode='absolute') from Spot
move_absolute(self, onset) from Spot
move_relative(self, time) from Spot
onset(self, onset=None) from Spot
realize(self)
Realize the PseudoEvent and return an real event
or an Aggregate.
 
Pure virtual method.
stretch(self, alpha, mode='absolute', direction='forward') from Event
stretch_absolute_backward(self, time) from Event
stretch_absolute_forward(self, time) from Event
stretch_relative_backward(self, alpha) from Event
stretch_relative_forward(self, alpha) from Event

 
class Spot
      Spot are dimensionless (point-like) events.
 
  
__init__(self, onset)
Return a Spot instance.
 
onset is the onset time of the spot.
apply(self, callable, *args)
Call callable passing self as first argument.
 
Options arguments are passed thru.
 
Same as apply_for_real().
apply_for_real(self, callable, *args)
Call callable passing self as first argument.
 
Options arguments are passed thru.
move(self, time, mode='absolute')
Perform a translation on time exis.
 
mode can be 'absolute' or 'relative'. Default value is 'absolute'.
This method affects onset but not duration. It can raise
ValueError if an uknown mode is passed.
 
>>> x = Event(0, 1)
>>> x.move(4.5)
>>> x.onset(), x.end()
(4.5, 5.5)
>>> x.move(-3, 'relative')
>>> x.onset(), x.end()
(1.5, 2.5)
>>> x.move(0, 'foo')
Traceback (most recent call last):
ValueError: Translation mode can only be 'absolute' or 'relative' (got foo)
move_absolute(self, onset)
Perform an absolute translation on the time axis.
 
This method affects onset but not duration.
 
>>> x = Event(4, 1)
>>> x.move_absolute(1.5)
>>> x.onset(), x.end()
(1.5, 2.5)
move_relative(self, time)
Perform a relative translation on the time axis.
 
This method affects onset but not duration.
 
>>> x = Event(4, 1)
>>> x.move_relative(1.5)
>>> x.onset(), x.end()
(5.5, 6.5)
onset(self, onset=None)
With no arguments, return the onset time of the event.
With one argument, set the onset time of the event.
 
>>> x = Event(1, 2)
>>> print x.onset()
1
>>> x.onset(5.1)
>>> print x.onset()
5.1

 
Functions
            
_test()
disjoint(events, mode='cut')
This adjusts a list of events so that their start and end times do not
overlap. As a side effect, the list is sorted by onset.
 
XXX Note that if two events have the same onset, the result
depends on what the sorting mechanism does... we should probably
think about what it should do.
 
If mode is 'cut', the events' durations are shortened as necessary.
 
>>> events = [Event(0, 10), Event(2, 10), Event(2,4),
...           Event(3,10), Event(99,1)]
>>> disjoint(events)
>>> for e in events:
...    print e.onset(), e.end()
...
0 2
2 2
2 3
3 13
99 100
 
If mode is 'push', the events' start times are increased as
necessary.
 
>>> events = [Event(0, 10), Event(2, 10), Event(2,3),
...           Event(3,10), Event(100,1)]
>>> disjoint(events, 'push')
>>> for e in events:
...    print e.onset(), e.end()
...
0 10
10 20
20 23
23 33
100 101
serialize(aggregates, time=None, mode='disjoint', gap=0.0)
serialize(aggregates [, mode='disjoint')
 
serialize the specified aggregates (needs at least two of them).
 
aggregates is the list of objects to serialize.

 
Data
             __file__ = '/usr/local/lib/python2.1/site-packages/omde/score.pyc'
__name__ = 'omde.score'