to the object's container (optional).
    Defaults to the `id()` of the element.
2.  groups: a :class:`~music21.base.Groups` object: which is a
    list of strings identifying internal sub-collections
    (voices, parts, selections) to which this element belongs
3.  duration: :class:`~music21.duration.Duration` object representing the length of the object
4.  activeSite: a reference to the currently active :class:`~music21.stream.Stream` or None
5.  offset: a floating point or Fraction value, generally in quarter lengths,
    specifying the position of the object in a site.
6.  priority: int representing the position of an object among all
    objects at the same offset.
7.  sites: a :class:`~music21.base.Sites` object that stores all
    the Streams and Contexts that an
    object is in.
8.  derivation: a :class:`~music21.derivation.Derivation` object, or None, that shows
    where the object came from.
9.  style: a :class:`~music21.style.Style` object, that contains Style information
    automatically created if it doesn't exist, so check `.hasStyleInformation` first
    if that is not desired.
10. editorial: a :class:`~music21.editorial.Editorial` object

Each of these may be passed in as a named keyword to any music21 object.

Some of these may be intercepted by the subclassing object (e.g., duration
within Note)

**Equality**

For historical reasons, music21 uses a different idea of object equality
for Music21Objects than recommended by modern Python standards.

Two Music21Objects are equal if they are the same class and same duration.

Their offset, activeSite, id, and groups do not matter for equality.

Since these two objects are therefore not interchangable, they do not have
the same hash value.

>>> obj1 = base.Music21Object(id='obj1')
>>> obj2 = base.Music21Object(id='obj2')
>>> obj1 == obj2
True
>>> hash(obj1) == hash(obj2)
False

This has the stange side effect that structures that use equality to
report containment (such as lists and tuples) will report differently from
structures that use hash values to report containment (such as dicts and sets):

>>> obj1 in [obj2]
True
>>> obj1 in {obj2}
False

Subclasses need to apply stricter criteria for equality, like Barline does here
with `.location`

>>> bar1 = bar.Barline('double', 'left')
>>> bar2 = bar.Barline('double', 'right')
>>> bar1 == bar2
False
>>> bar2.location = 'left'
>>> bar1 == bar2
True
>>> bar1.duration.type = 'whole'  # Buh?
>>> bar1 == bar2
False

In general, a subclass of Music21Object must match all super-class criteria for
equality before they can be considered equal themselves.  However, there are some
exceptions.  For instance, RomanNumeral objects with the same figure and key are
equal even if their notes are in different octaves or have different doublings.

Developers creating their own Music21Object subclasses should add a class attribute
`equalityAttributes = ('one', 'two')`.  (Remember that as a tuple of strings, if there
is only one string, don't forget the trailing comma: `('only',)`.

>>> class CarolineShawBreathMark(base.Music21Object):
...     equalityAttributes = ('direction',)
...     def __init__(self, direction, speed):
...         super().__init__(self)
...         self.direction = direction
...         self.speed = speed
>>> bm1 = CarolineShawBreathMark('in', 'fast')
>>> bm2 = CarolineShawBreathMark('out', 'fast')
>>> bm1 == bm2
False

"speed" is not in the equalityAttributes so it can differ while objects are still
equal.

>>> bm3 = CarolineShawBreathMark('in', 'slow')
>>> bm1 == bm3
True
é