Initial Commit

slip slop

app/models.py

@@ -0,0 +1,175 @@
+from sqlalchemy import Boolean, Column, Date, ForeignKey, Integer, String, Table, UniqueConstraint
+from app.extensions import db
+
+
+# ── Many-to-many: references ↔ musicians ─────────────────────
+reference_musicians = Table(
+    "reference_musicians",
+    db.metadata,
+    Column("reference_id", Integer, ForeignKey("references.id", ondelete="CASCADE"), primary_key=True),
+    Column("musician_id",  Integer, ForeignKey("musicians.id",  ondelete="CASCADE"), primary_key=True),
+)
+
+
+class Musician(db.Model):
+    __tablename__ = "musicians"
+
+    id   = Column(Integer, primary_key=True, autoincrement=True)
+    name = Column(String, nullable=False)
+
+    references        = db.relationship("Reference",       secondary=reference_musicians, back_populates="musicians")
+    instrument_entries = db.relationship("TuneByInstrument", back_populates="learned_from_musician")
+
+    def to_dict(self):
+        return {"id": self.id, "name": self.name}
+
+
+class Source(db.Model):
+    __tablename__ = "sources"
+
+    id   = Column(Integer, primary_key=True, autoincrement=True)
+    name = Column(String, nullable=False)
+
+    tunes = db.relationship("Tune", back_populates="source")
+
+    def to_dict(self):
+        return {"id": self.id, "name": self.name}
+
+
+class Instrument(db.Model):
+    __tablename__ = "instruments"
+
+    id   = Column(Integer, primary_key=True, autoincrement=True)
+    name = Column(String, nullable=False, unique=True)
+
+    entries = db.relationship("TuneByInstrument", back_populates="instrument")
+
+    def to_dict(self):
+        return {"id": self.id, "name": self.name}
+
+
+class Tuning(db.Model):
+    __tablename__ = "tunings"
+
+    id   = Column(Integer, primary_key=True, autoincrement=True)
+    name = Column(String, nullable=False, unique=True)
+
+    entries = db.relationship("TuneByInstrument", back_populates="tuning")
+
+    def to_dict(self):
+        return {"id": self.id, "name": self.name}
+
+
+class Tune(db.Model):
+    __tablename__ = "tunes"
+
+    id        = Column(Integer, primary_key=True, autoincrement=True)
+    name      = Column(String,  nullable=True)
+    key       = Column(String,  nullable=True)
+    modal     = Column(Boolean, nullable=True)
+    source_id = Column(Integer, ForeignKey("sources.id", ondelete="SET NULL"), nullable=True)
+
+    source      = db.relationship("Source",          back_populates="tunes")
+    instruments = db.relationship("TuneByInstrument", back_populates="tune", cascade="all, delete-orphan")
+    notes       = db.relationship("TuneNote",         back_populates="tune", cascade="all, delete-orphan")
+    references  = db.relationship("Reference",        back_populates="tune", cascade="all, delete-orphan")
+
+    def to_dict(self):
+        return {
+            "id":          self.id,
+            "name":        self.name,
+            "key":         self.key,
+            "modal":       self.modal,
+            "source_id":   self.source_id,
+            "source":      self.source.to_dict() if self.source else None,
+            "instruments": [i.to_dict() for i in self.instruments],
+            "notes":       [n.to_dict() for n in self.notes],
+            "references":  [r.to_dict() for r in self.references],
+        }
+
+
+class TuneByInstrument(db.Model):
+    __tablename__ = "tune_by_instrument"
+    __table_args__ = (UniqueConstraint("tune_id", "instrument_id", name="uq_tune_instrument"),)
+
+    id              = Column(Integer, primary_key=True, autoincrement=True)
+    tune_id         = Column(Integer, ForeignKey("tunes.id",       ondelete="CASCADE"),  nullable=False)
+    instrument_id   = Column(Integer, ForeignKey("instruments.id", ondelete="CASCADE"),  nullable=False)
+    learned_from_id = Column(Integer, ForeignKey("musicians.id",   ondelete="SET NULL"), nullable=True)
+    tuning_id       = Column(Integer, ForeignKey("tunings.id",     ondelete="SET NULL"), nullable=True)
+    date_learned    = Column(Date,    nullable=True)
+    callable        = Column(Boolean, nullable=True)
+    review          = Column(Boolean, nullable=True)
+    to_learn        = Column(Boolean, nullable=True, default=False)
+    difficulty      = Column(String,  nullable=True)
+
+    tune                  = db.relationship("Tune",       back_populates="instruments")
+    instrument            = db.relationship("Instrument", back_populates="entries")
+    tuning                = db.relationship("Tuning",     back_populates="entries")
+    learned_from_musician = db.relationship("Musician",   back_populates="instrument_entries")
+    notes                 = db.relationship("TuneByInstrumentNote", back_populates="entry", cascade="all, delete-orphan")
+
+    def to_dict(self):
+        return {
+            "id":              self.id,
+            "tune_id":         self.tune_id,
+            "instrument_id":   self.instrument_id,
+            "instrument_name": self.instrument.name if self.instrument else None,
+            "learned_from_id": self.learned_from_id,
+            "learned_from":    self.learned_from_musician.name if self.learned_from_musician else None,
+            "date_learned":    self.date_learned.isoformat() if self.date_learned else None,
+            "tuning_id":       self.tuning_id,
+            "tuning":          self.tuning.name if self.tuning else None,
+            "callable":        self.callable,
+            "review":          self.review,
+            "to_learn":        self.to_learn,
+            "difficulty":      self.difficulty,
+            "notes":           [n.to_dict() for n in self.notes],
+        }
+
+
+class TuneNote(db.Model):
+    __tablename__ = "tune_notes"
+
+    id      = Column(Integer, primary_key=True, autoincrement=True)
+    tune_id = Column(Integer, ForeignKey("tunes.id", ondelete="CASCADE"), nullable=False)
+    note    = Column(String, nullable=True)
+
+    tune = db.relationship("Tune", back_populates="notes")
+
+    def to_dict(self):
+        return {"id": self.id, "tune_id": self.tune_id, "note": self.note}
+
+
+class TuneByInstrumentNote(db.Model):
+    __tablename__ = "tune_by_instrument_notes"
+
+    id                    = Column(Integer, primary_key=True, autoincrement=True)
+    tune_by_instrument_id = Column(Integer, ForeignKey("tune_by_instrument.id", ondelete="CASCADE"), nullable=False)
+    note                  = Column(String, nullable=True)
+
+    entry = db.relationship("TuneByInstrument", back_populates="notes")
+
+    def to_dict(self):
+        return {"id": self.id, "tune_by_instrument_id": self.tune_by_instrument_id, "note": self.note}
+
+
+class Reference(db.Model):
+    __tablename__ = "references"
+
+    id      = Column(Integer, primary_key=True, autoincrement=True)
+    tune_id = Column(Integer, ForeignKey("tunes.id", ondelete="CASCADE"), nullable=True)
+    link    = Column(String, nullable=True)
+    site    = Column(String, nullable=True)
+
+    tune      = db.relationship("Tune",     back_populates="references")
+    musicians = db.relationship("Musician", secondary=reference_musicians, back_populates="references")
+
+    def to_dict(self):
+        return {
+            "id":        self.id,
+            "tune_id":   self.tune_id,
+            "link":      self.link,
+            "site":      self.site,
+            "musicians": [m.to_dict() for m in self.musicians],
+        }