Merge branch 'release-0.0.4'

chorddb/chords/finder.py

@@ -112,9 +112,9 @@ def __init__(self, positions, instrument, start=None):
         self._instrument = instrument
         self._positions = positions
         self._start = start or 0
-        if not 0 <= self._start < len(instrument):
+        if not 0 <= self._start < instrument.size():
             raise ValueError("Invalid start")
-        if len(instrument) < self._start + len(positions):
+        if instrument.size() < self._start + len(positions):
             raise ValueError("Invalid positions for instrument")
         if not all(0 <= p < instrument.frets for p in positions):
             raise ValueError("Invalid positions for instrument")
@@ -140,9 +140,9 @@ def bass(self):
         return min(self.keyoctaves())
 
     def full_positions(self):
-        res = ["x"] * len(self._instrument)
+        res = ["x"] * self._instrument.size()
         res[self._start:self._start] = self._positions
-        return res[:len(self._instrument)]
+        return res[:self._instrument.size()]
 
     def __str__(self):
         return "".join(str(x) for x in self.full_positions())
@@ -163,10 +163,10 @@ def get_fingering_penalty(fingering):
         return {'too many fingers': 10000}
     penalty = {
         'start': fingering.start * 5 ** 2,
-        'end': (len(fingering.instrument) - fingering.start -
+        'end': (fingering.instrument.size() - fingering.start -
                 len(fingering.positions)) * 8 ** 2,
         'positions': sum((p - bar + 2) ** 2 for p in fingering.positions),
-        'bar': bar * len(fingering.instrument) * 3 if bar else 0,
+        'bar': bar * fingering.instrument.size() * 3 if bar else 0,
         'consecutive_diffs': sum((a - b) ** 2 for a, b in
                                  zip(fingering.positions,
                                      fingering.positions[1:])

chorddb/instrument.py

@@ -1,35 +1,26 @@
-from .notes import KeyOctave, Key
-from .chords.variations import map_variations_to_intervals, VARIATIONS_NOTES
-
+#!/usr/bin/env python
+# encoding: utf-8
 
-class Instrument(object):
-    def __init__(self, name, keyoctaves, frets, has_bass=True,
-                 variation_overrides=None):
-        self._name = name
-        self._keyoctaves = keyoctaves
-        self._frets = frets
-        self._has_bass = has_bass
-        self._variation_overrides = variation_overrides or {}
+import collections
 
-    @property
-    def name(self):
-        return self._name
+from .notes import KeyOctave, Key
+from .chords.variations import map_variations_to_intervals, VARIATIONS_NOTES
 
-    @property
-    def keyoctaves(self):
-        return self._keyoctaves
 
-    @property
-    def frets(self):
-        return self._frets
+_Instrument = collections.namedtuple('Instrument', [
+    'name', 'keyoctaves', 'frets', 'has_bass', 'variation_overrides'], verbose=True)
 
-    @property
-    def has_bass(self):
-        return self._has_bass
 
-    @property
-    def variation_overrides(self):
-        return self._variation_overrides
+class Instrument(_Instrument):
+    def __new__(cls, *args, **kwargs):
+        defaults = {
+            'has_bass': False,
+            'variation_overrides': {},
+        }
+        fields_in_args = set(_Instrument._fields[:len(args)])
+        kwvalues = {f: kwargs.get(f, defaults[f]) for f in _Instrument._fields
+                    if f not in fields_in_args}
+        return _Instrument.__new__(cls, *args, **kwvalues)  # pylint: disable=star-args
 
     @classmethod
     def parse(cls, name, keys, frets, **kwargs):
@@ -55,18 +46,22 @@ def from_name(cls, name, default=None):
             raise
 
     def capo(self, capo_position):
-        return Instrument(
-            "{}(Capo: {})".format(self.name, capo_position),
-            [ko.transpose(capo_position) for ko in self.keyoctaves],
-            self.frets - capo_position,
-            self.has_bass
+        kwds = {
+            'name':"{}(Capo: {})".format(self.name, capo_position),
+            'keyoctaves':[ko.transpose(capo_position) for ko in self.keyoctaves],
+            'frets':self.frets - capo_position,
+        }
+        return self._replace(
+            name="{}(Capo: {})".format(self.name, capo_position),
+            keyoctaves=[ko.transpose(capo_position) for ko in self.keyoctaves],
+            frets=self.frets - capo_position,
         )
 
     def __str__(self):
         return "Instrument: {s.name}".format(s=self)
 
-    def __len__(self):
-        return len(self._keyoctaves)
+    def size(self):
+        return len(self.keyoctaves)
 
 
 LOOG_VARIATION_OVERRIDES = {